las-laz-js 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # Changelog
 
+## 0.7.0 (2026-10-22)
+
+Denoise: stray points, normals and smoothing, for fuzzy handheld scans.
+
+- `selectOutliers(cols, { k = 8, multiplier = 2 })` selects stray points by PDAL's statistical
+  outlier rule (a point's mean distance to its k nearest above the cloud's average plus
+  `multiplier` standard deviations), for `removePoints`. Checked point for point against PDAL's
+  `filters.outlier` `method=statistical`.
+- `denoisePoints(cols, { method, k = 16, maxDistance, sigma, iterations = 1, normals, inPlace })`
+  smooths the points against their neighbours (the other points among the k nearest within
+  `maxDistance`, which is required): `"bilateral"` (default) moves each point along its normal
+  and keeps crests sharp; `"mls"` moves it onto its neighbours' fitted plane. The noise level
+  `sigma` is measured unless given. Returns columns as `transformPoints` does; `normals: true`
+  adds a `normal` column.
+- `pointNormals(cols, { k = 16, maxDistance })` → `{ normal, residual }`: unit normals (pointing
+  up) and each point's RMS distance from its fitted plane; `estimateNoise` is the median residual
+  over up to 100,000 points.
+- `nearestPoints(index, point, k, { maxDistance, xy })` → `{ points, d }`: the k nearest on the
+  0.6.0 voxel index, nearest first, ties to the lowest number.
+- The denoise tools search an implicit k-d tree (about 4.6 bytes a point), which suits a scan's
+  thousand-fold changes of density. On a 1 M-point handheld scan (Node): `selectOutliers` 2.5 s,
+  `pointNormals` 4.6 s, `denoisePoints` 6.3 s, the measured noise going from 0.60 cm to 0.11 cm; on a
+  34 M-point scan, `denoisePoints` takes about 3.7 min. A cluster of exact duplicates costs a search k
+  points, not the cluster's size.
+- Demo: a Denoise section on the Edit tab and a Roughness colour mode.
+
+## 0.6.2 (2026-10-22)
+
+- `dedupe` and `dedupeSelection` handle more than 16,777,216 occupied cells. They used a
+  JavaScript Map, which stops at 2^24 entries, so a 20-30 M-point cloud at a small tolerance threw
+  `RangeError: Map maximum size exceeded`. A typed-array hash table (5 bytes a slot) replaces
+  it, with the same results and about 1.5 to 2 times the speed (2 M points: 0.9 s in 2D, 2.2 s in 3D).
+
 ## 0.6.1 (2026-10-22)
 
 - Demo: a read bigger than the draw cap (20 M) is drawn as an even spread over the whole cloud,

package/README.md

@@ -40,7 +40,8 @@ library's Worker (LAZ on every core) behind a progress bar, then shown once in a
 colour changes recolour the points already read, without reading the file again. The side panel shows the header, VLRs, coordinate
 system and LAZ compression; reads with class, return, bounds, thinning and dedupe filters;
 colours by RGB, intensity, elevation or class; lists point statistics; selects points by polygon,
-box or class and keeps, deletes, splits, transforms or crops them (the Edit tab); and saves the
+box, class, dust or outliers and keeps, deletes, splits, transforms, smooths or crops them (the
+Edit tab), with a Roughness colour to see the noise; and saves the
 points back out as LAS or LAZ. To run it locally: `npm run demo`, then open http://localhost:8080/.
 
 ## Reading
@@ -235,15 +236,56 @@ cost of thin features. It works on columns in memory (x / y / z, or a k = 3 `pos
 points take about 2 s in Node. With PDAL's `filters.outlier` (`method=radius`), `min_k` is the same
 as `minNeighbours`, but PDAL does not count a point exactly `radius` away.
 
+### Denoise
+
+```js
+import { selectOutliers, removePoints, estimateNoise, denoisePoints, pointNormals } from "las-laz-js";
+
+var strays = selectOutliers(pts);                       // PDAL's statistical rule: k 8, multiplier 2
+var kept   = removePoints(pts, strays);
+var noise  = estimateNoise(kept, { maxDistance: 0.3 }); // e.g. 0.006: 6 mm of fuzz
+var smooth = denoisePoints(kept, { maxDistance: 0.3 }); // bilateral; { method: "mls" } for the plane fit
+var { normal, residual } = pointNormals(smooth, { maxDistance: 0.3 });   // unit normals, local roughness
+```
+
+A handheld scan reads a flat bench as a band centimetres thick. Remove the stray points first
+(`selectOutliers`), so they cannot pull the surface, then smooth what is left (`denoisePoints`).
+- **`selectOutliers(cols, { k = 8, multiplier = 2 })`** — each point's mean distance to its k
+  nearest other points; a point is selected when that mean is above the cloud's average of those
+  means plus `multiplier` standard deviations. It is PDAL's `filters.outlier` `method=statistical`
+  and selects the same points.
+- **`denoisePoints(cols, { method, k = 16, maxDistance, sigma, iterations = 1, normals, inPlace })`**
+  moves each point against its neighbours — the other points among its k nearest within
+  `maxDistance` (required: about 0.2–0.5 m for a handheld scan; a point with fewer than 5 stays
+  put). `"bilateral"` (the default) moves a point along its normal by the weighted height of its
+  neighbours above its plane, and nearly ignores points far off that plane, so a crest or a toe
+  stays sharp. `"mls"` moves it onto the plane fitted to its neighbours: a little smoother, and
+  it rounds edges and the top of a cone. `sigma` is the noise level in metres; omitted, it is
+  measured (`estimateNoise`). More `iterations`, or a larger `k`, smooth more. The result is
+  as `transformPoints` returns: new x, y, z (or `positions`) of the input's types, every other
+  column shared; `normals: true` adds a `normal` column.
+- **`pointNormals`** gives each point the unit normal of the plane through it and its neighbours
+  (pointing up) and the residual, the RMS distance of those points from the plane: a roughness
+  map. Fewer than 3 neighbours, or points all on one line: normal (0, 0, 0), residual NaN.
+  **`estimateNoise`** is the median residual over up to 100,000 points spread through the cloud.
+
+On a 1 M-point handheld scan (Node, one thread): `selectOutliers` 2.5 s, `estimateNoise` 0.7 s,
+`pointNormals` 4.6 s, `denoisePoints` 6.3 s, taking the measured noise from 0.60 cm to 0.11 cm. On a
+34 M-point scan: 2.1 min, 14 s, 3.2 min and 3.7 min (about 6.5 µs a point), noise 0.74 cm to 0.58 cm.
+The searches run on a k-d tree (about 4.6 bytes a point); an output's coordinates cost what the
+input's do. The calls are synchronous; for a big scan, run them in a Worker and pass
+`onProgress(done, total)`.
+
 ### Neighbour index
 
 ```js
-import { buildIndex, nearestPoint, pointsInRadius, pointsNearRay } from "las-laz-js";
+import { buildIndex, nearestPoint, nearestPoints, pointsInRadius, pointsNearRay } from "las-laz-js";
 
 var index = buildIndex(pts);                              // or { cellSize: 0.5 }; omitted: ~16 points a cell
 var i     = nearestPoint(index, [x, y, z]);               // point number, or -1
 var j     = nearestPoint(index, [x, y], { xy: true, maxDistance: 0.3 });   // nearest in plan, within 0.3
 var near  = pointsInRadius(index, [x, y, z], 5);          // a selection
+var knn   = nearestPoints(index, [x, y, z], 8);           // { points, d }: the 8 nearest, nearest first
 var hit   = pointsNearRay(index, origin, direction, { radius: 0.2, growth: 0 });
 // hit = { points, t, d }: every point within radius + growth · t of the ray, t along it, d from its axis
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "las-laz-js",
-	"version": "0.6.1",
+	"version": "0.7.0",
 	"description": "Zero-dependency JavaScript reader and writer for ASPRS LAS point clouds, and reader and writer for LAZ (LASzip), for the browser and Node, built for files larger than memory.",
 	"type": "module",
 	"exports": {

package/src/filter/dedupe.js

@@ -12,6 +12,7 @@
 
 import { LasError, ERROR_CODES } from "../errors.js";
 import { columnsOf, gather, sameType } from "../ops/columns.js";
+import { hash32 } from "../index/grid.js";
 
 /**
  * The points dedupe keeps, and where every input point went.
@@ -46,12 +47,40 @@ export function dedupeSelection(cols, tolerance, opts) {
 	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();
+	function cellKey(p) {
+		return key(Math.floor(x[p] / tolerance) - lo[0] + 1, Math.floor(y[p] / tolerance) - lo[1] + 1, use3d ? Math.floor(z[p] / tolerance) - lo[2] + 1 : 1);
+	}
+
+	// Each cell is a linked list of kept points through next[]. Its newest point sits in
+	// an open-addressing table (linear probing, power-of-two capacity, at most half
+	// full). A slot holds the point number and an 8-bit tag of its key's hash; the key
+	// itself is recomputed from the point's cell, only when the tag matches. 5 bytes a
+	// slot. (A Map stops at 2^24 cells.)
+	var cells = (hi[0] - lo[0] + 1) * (hi[1] - lo[1] + 1) * (hi[2] - lo[2] + 1);
+	var cap = 16;
+	while (cap < Math.min(n, cells)) cap *= 2;
+	var mask = cap - 1, used = 0, table = new Int32Array(cap).fill(-1), tags = new Uint8Array(cap);
+	var tag = 0;   // the tag of the key find() last looked up
+	// The slot of cell key c: its newest kept point, or -1 (the free slot c would take)
+	function find(c) {
+		var g = hash32(c), h = g & mask;
+		tag = Math.imul(g, 0x9E3779B1) >>> 24;   // top bits of a multiply mix every bit of g
+		while (table[h] >= 0 && (tags[h] !== tag || cellKey(table[h]) !== c)) h = (h + 1) & mask;
+		return h;
+	}
+	function grow() {
+		var old = table, oldTags = tags;
+		cap *= 2; mask = cap - 1; table = new Int32Array(cap).fill(-1); tags = new Uint8Array(cap);
+		for (var s = 0; s < old.length; s++) {
+			if (old[s] < 0) continue;
+			var h = hash32(cellKey(old[s])) & mask;
+			while (table[h] >= 0) h = (h + 1) & mask;
+			table[h] = old[s]; tags[h] = oldTags[s];
+		}
+	}
 	var next = new Int32Array(n);
 	var kept = new Uint32Array(n);
 	var map = new Uint32Array(n);
-	var dropped = [];
 	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;
@@ -60,8 +89,8 @@ export function dedupeSelection(cols, tolerance, opts) {
 		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 k = head.get(key(cx + dx, cy + dy, cz + dz));
-					while (k !== undefined && k >= 0) {
+					var k = table[find(key(cx + dx, cy + dy, cz + dz))];
+					while (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; }
@@ -70,25 +99,31 @@ export function dedupeSelection(cols, tolerance, opts) {
 				}
 			}
 		}
-		if (dup) { dropped.push(i); continue; }
-		var own = key(cx, cy, cz);
-		var prev = head.get(own);
-		next[i] = prev === undefined ? -1 : prev;
-		head.set(own, i);
+		if (dup) continue;
+		var own = key(cx, cy, cz), h = find(own);
+		if (table[h] < 0) {
+			if (2 * (used + 1) > cap) { grow(); h = find(own); }
+			used++;
+			tags[h] = tag;
+		}
+		next[i] = table[h];
+		table[h] = i;
 		map[i] = nKept;
 		kept[nKept++] = i;
 	}
 
-	// Each dropped point maps to its nearest kept point (the cell lists hold kept points only)
-	dropped.forEach(function (i) {
+	// Each dropped point (every point not in kept) maps to its nearest kept point;
+	// the cell lists hold kept points only
+	for (i = 0, p = 0; i < n; i++) {
+		if (p < nKept && kept[p] === i) { p++; continue; }
 		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 best = -1, bd = Infinity;
 		for (var dx = -1; dx <= 1; dx++) {
 			for (var dy = -1; dy <= 1; dy++) {
 				for (var dz = -dzRange; dz <= dzRange; dz++) {
-					var k = head.get(key(cx + dx, cy + dy, cz + dz));
-					while (k !== undefined && k >= 0) {
+					var k = table[find(key(cx + dx, cy + dy, cz + dz))];
+					while (k >= 0) {
 						var ex = x[k] - x[i], ey = y[k] - y[i];
 						var ez = use3d ? z[k] - z[i] : 0;
 						var d = ex * ex + ey * ey + ez * ez;
@@ -99,7 +134,7 @@ export function dedupeSelection(cols, tolerance, opts) {
 			}
 		}
 		map[i] = map[best];
-	});
+	}
 	return { keep: kept.slice(0, nKept), map: map };
 }
 

package/src/index/grid.js

@@ -56,6 +56,16 @@ function fmix32(h) {
 	return (h ^ (h >>> 16)) >>> 0;
 }
 
+/**
+ * A 32-bit hash of a cell key (an integer below 2^53).
+ * @param {number} key
+ * @returns {number}
+ */
+export function hash32(key) {
+	var lo = key % 4294967296, hi = (key - lo) / 4294967296;
+	return fmix32(lo ^ fmix32(hi));
+}
+
 /**
  * The home slot of a cell key (an integer below 2^53) in a table of mask + 1 slots.
  * @param {number} key
@@ -63,8 +73,7 @@ function fmix32(h) {
  * @returns {number}
  */
 export function hashKey(key, mask) {
-	var lo = key % 4294967296, hi = (key - lo) / 4294967296;
-	return fmix32(lo ^ fmix32(hi)) & mask;
+	return hash32(key) & mask;
 }
 
 function nextPow2(n) {

package/src/index/kdtree.js

@@ -0,0 +1,176 @@
+// src/index/kdtree.js
+//==========================================================
+// A k-d tree for k-nearest searches over clouds whose density changes
+// a thousand-fold (a handheld scan: dense beside the walk path,
+// sparse far from it), where one grid cell size cannot suit every
+// point. Implicit and balanced: point numbers are permuted so each
+// node's points are perm[lo, hi), split at mid = floor((lo + hi) / 2)
+// on the axis of the node's largest extent, with every left point at
+// most the split value and every right point at least it. A node
+// stores its axis (a byte) and split value (a Float64), in heap order.
+// Leaves hold up to 16 points. About 4.6 bytes a point. A node whose
+// points all coincide (zero extent) is not split: its point numbers are
+// sorted (axis UNIFORM) and a search offers only the lowest ones, so a
+// cluster of exact duplicates costs k, not its size, per search. Distances are checked in Float64 and pruning compares the
+// same rounded differences, so results are exact; ties go to the
+// lowest point number.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+import { coordsOf, checkPointCount } from "./grid.js";
+
+var LEAF = 16, UNIFORM = 3;
+
+function bad(message) { return new LasError(ERROR_CODES.INVALID_ARGUMENT, message); }
+
+/**
+ * Build a k-d tree over point columns.
+ * @param {object} cols - point columns (x, y, z or a k = 3 positions column).
+ * @param {string} fn - the calling function's name, for messages.
+ * @returns {{count: number, perm: Uint32Array, axis: Uint8Array, split: Float64Array, leafSize: number, coords: object}}
+ */
+export function buildKdTree(cols, fn) {
+	var coords = coordsOf(cols, fn), n = cols.count;
+	checkPointCount(n);
+	var A = [coords.x, coords.y, coords.z], st = coords.stride, i, o;
+	for (i = 0, o = 0; i < n; i++, o += st) {
+		var a = A[0][o], b = A[1][o], c = A[2][o];
+		if (a - a !== 0 || b - b !== 0 || c - c !== 0) throw bad("point " + i + " has a non-finite " + (a - a !== 0 ? "x" : b - b !== 0 ? "y" : "z") + " coordinate");
+	}
+	var perm = new Uint32Array(n);
+	for (i = 0; i < n; i++) perm[i] = i;
+	// Internal nodes sit at depths 0 .. d - 1, where ceil(n / 2^d) <= LEAF
+	var d = 0;
+	while (Math.ceil(n / Math.pow(2, d)) > LEAF) d++;
+	var nodes = Math.max(1, Math.pow(2, d) - 1), axis = new Uint8Array(nodes), split = new Float64Array(nodes);
+
+	// The point at position kth of perm[lo, hi) on axis ax, smaller ones before it,
+	// larger after (Hoare's selection, median-of-three pivot)
+	function select(lo, hi, kth, V) {
+		var l = lo, r = hi - 1;
+		while (r > l) {
+			var m = Math.floor((l + r) / 2), va = V[perm[l] * st], vb = V[perm[m] * st], vc = V[perm[r] * st];
+			var pv = va < vb ? (vb < vc ? vb : (va < vc ? vc : va)) : (va < vc ? va : (vb < vc ? vc : vb));
+			var x = l, y = r;
+			do {
+				while (V[perm[x] * st] < pv) x++;
+				while (V[perm[y] * st] > pv) y--;
+				if (x <= y) { var t = perm[x]; perm[x] = perm[y]; perm[y] = t; x++; y--; }
+			} while (x <= y);
+			if (kth <= y) r = y;
+			else if (kth >= x) l = x;
+			else return;
+		}
+	}
+
+	var stack = [0, 0, n];
+	while (stack.length) {
+		var hi = stack.pop(), lo = stack.pop(), node = stack.pop();
+		if (hi - lo <= LEAF) continue;
+		var best = 0, ext = -1;
+		for (var ax = 0; ax < 3; ax++) {
+			var V = A[ax], mn = Infinity, mx = -Infinity;
+			for (var j = lo; j < hi; j++) { var v = V[perm[j] * st]; if (v < mn) mn = v; if (v > mx) mx = v; }
+			if (mx - mn > ext) { ext = mx - mn; best = ax; }
+		}
+		if (ext === 0) {
+			// every point here is the same point: sort by number and stop
+			perm.subarray(lo, hi).sort();
+			axis[node] = UNIFORM;
+			continue;
+		}
+		axis[node] = best;
+		var mid = Math.floor((lo + hi) / 2);
+		select(lo, hi, mid, A[best]);
+		// the children reorder their ranges, so perm[mid] does not keep this value
+		split[node] = A[best][perm[mid] * st];
+		stack.push(2 * node + 1, lo, mid, 2 * node + 2, mid, hi);
+	}
+	return { count: n, perm: perm, axis: axis, split: split, leafSize: LEAF, coords: coords };
+}
+
+// The search's state, module-wide: a search is synchronous and does not nest
+var T, X, Y, Z, ST, Q = [0, 0, 0], K, MAXD2, SKIP, P, D, M;
+
+function worse(i, j) { return D[i] > D[j] || (D[i] === D[j] && P[i] > P[j]); }
+function swap(i, j) { var tp = P[i]; P[i] = P[j]; P[j] = tp; var td = D[i]; D[i] = D[j]; D[j] = td; }
+function down(i, len) {
+	for (;;) {
+		var l = 2 * i + 1, r = l + 1, w = i;
+		if (l < len && worse(l, w)) w = l;
+		if (r < len && worse(r, w)) w = r;
+		if (w === i) return;
+		swap(i, w); i = w;
+	}
+}
+function offer(p, d) {
+	if (M < K) {
+		P[M] = p; D[M] = d;
+		for (var i = M++; i > 0;) { var up = Math.floor((i - 1) / 2); if (!worse(i, up)) break; swap(i, up); i = up; }
+	} else if (d < D[0] || (d === D[0] && p < P[0])) {
+		P[0] = p; D[0] = d; down(0, M);
+	}
+}
+function limit() { return M === K && D[0] < MAXD2 ? D[0] : MAXD2; }
+
+function search(node, lo, hi) {
+	var perm = T.perm;
+	if (hi - lo <= LEAF) {
+		for (var j = lo; j < hi; j++) {
+			var p = perm[j];
+			if (p === SKIP) continue;
+			var o = p * ST, dx = X[o] - Q[0], dy = Y[o] - Q[1], dz = Z[o] - Q[2];
+			var d = dx * dx + dy * dy + dz * dz;
+			if (d <= MAXD2) offer(p, d);
+		}
+		return;
+	}
+	var a = T.axis[node];
+	if (a === UNIFORM) {
+		// one distance for all, numbers ascending: once the heap is full, the rest lose
+		var u = perm[lo] * ST, ux = X[u] - Q[0], uy = Y[u] - Q[1], uz = Z[u] - Q[2], du = ux * ux + uy * uy + uz * uz;
+		if (du > MAXD2) return;
+		for (var i = lo; i < hi; i++) {
+			var q = perm[i];
+			if (q === SKIP) continue;
+			if (M === K && (du > D[0] || (du === D[0] && q > P[0]))) return;
+			offer(q, du);
+		}
+		return;
+	}
+	var mid = Math.floor((lo + hi) / 2);
+	var diff = Q[a] - T.split[node];
+	// The far side's points are at least |diff| away on this axis
+	if (diff < 0) {
+		search(2 * node + 1, lo, mid);
+		if (diff * diff <= limit()) search(2 * node + 2, mid, hi);
+	} else {
+		search(2 * node + 2, mid, hi);
+		if (diff * diff <= limit()) search(2 * node + 1, lo, mid);
+	}
+}
+
+/**
+ * The k nearest points to (qx, qy, qz), nearest first by (distance², point number).
+ * Fills outP / outD2 (squared distances) and returns how many it found (<= k).
+ * @param {object} tree - from buildKdTree.
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} k - >= 1; outP and outD2 hold at least k.
+ * @param {number} maxD2 - squared distance limit (Infinity: none).
+ * @param {number} skip - a point number to leave out (-1: none).
+ * @param {Uint32Array} outP
+ * @param {Float64Array} outD2
+ * @returns {number}
+ */
+export function kdNearest(tree, qx, qy, qz, k, maxD2, skip, outP, outD2) {
+	if (tree.count === 0) return 0;
+	T = tree; X = tree.coords.x; Y = tree.coords.y; Z = tree.coords.z; ST = tree.coords.stride;
+	Q[0] = qx; Q[1] = qy; Q[2] = qz; K = k; MAXD2 = maxD2; SKIP = skip; P = outP; D = outD2; M = 0;
+	search(0, 0, tree.count);
+	for (var end = M - 1; end > 0; end--) { swap(0, end); down(0, end); }
+	var m = M;
+	T = X = Y = Z = P = D = null;
+	return m;
+}

package/src/index/knn.js

@@ -0,0 +1,196 @@
+// src/index/knn.js
+//==========================================================
+// The k nearest points on a PointIndex (grid.js): Chebyshev rings of
+// cells outward from the query's cell, as nearestPoint searches, with
+// the best k kept in a bounded max-heap ordered by (distance², point
+// number), so ties go to the lowest number. Distances are checked in
+// Float64 against the stored coordinates, so results are exact.
+// Also the argument checks and progress ticker the denoise tools
+// share (their own searches run on a k-d tree, kdtree.js, which suits
+// a scan's thousand-fold changes of density better than one grid).
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+import { checkIndex, lookup } from "./grid.js";
+import { checkPoint, checkPositive, cellDist2, decode } from "./query.js";
+
+var EPS = 1e-6;   // in cells, as query.js
+
+function bad(message) { return new LasError(ERROR_CODES.INVALID_ARGUMENT, message); }
+
+/**
+ * Refuse a k that is not a whole number >= 1.
+ * @param {*} v
+ * @param {string} name
+ */
+export function checkK(v, name) {
+	if (!(Number.isInteger(v) && v >= 1)) throw bad(name + " must be a whole number >= 1, not " + String(v));
+}
+
+/**
+ * Refuse a missing or non-positive maxDistance.
+ * @param {*} v
+ */
+export function checkMaxDistance(v) {
+	if (v === undefined) throw bad("maxDistance is required: a positive distance in the columns' units (e.g. 0.3 m for a handheld scan)");
+	checkPositive(v, "maxDistance");
+}
+
+/**
+ * A ticker that calls onProgress(done, total) about every 1 % of total, and at total.
+ * @param {function|undefined} onProgress
+ * @param {number} total
+ * @returns {function(number)}
+ */
+export function progress(onProgress, total) {
+	if (onProgress === undefined) return function () {};
+	if (typeof onProgress !== "function") throw bad("onProgress must be a function");
+	var step = Math.max(1, Math.floor(total / 100)), last = 0;
+	return function (done) {
+		if (done === total || done - last >= step) { last = done; onProgress(done, total); }
+	};
+}
+
+/**
+ * The k nearest points to (qx, qy, qz), nearest first by (distance², point number).
+ * Fills outP / outD2 (squared distances) and returns how many it found (<= k).
+ * @param {object} index - PointIndex.
+ * @param {number} qx
+ * @param {number} qy
+ * @param {number} qz - ignored with xy.
+ * @param {number} k - >= 1; outP and outD2 hold at least k.
+ * @param {number} maxD2 - squared distance limit (Infinity: none).
+ * @param {number} skip - a point number to leave out (-1: none).
+ * @param {Uint32Array} outP
+ * @param {Float64Array} outD2
+ * @param {boolean} [xy] - measure in XY only.
+ * @returns {number}
+ */
+export function knnSearch(index, qx, qy, qz, k, maxD2, skip, outP, outD2, xy) {
+	var m = 0;
+	if (index.count === 0) return 0;
+	var q = [qx, qy, xy ? 0 : qz];
+	var n = [index.nx, index.ny, index.nz], cs = index.cellSize, inv = 1 / cs, mn = index.min, axes = xy ? 2 : 3;
+	var c = [0, 0, 0], a;
+	for (a = 0; a < axes; a++) c[a] = Math.min(n[a] - 1, Math.max(0, Math.floor((q[a] - mn[a]) * inv)));
+	var co = index.coords, X = co.x, Y = co.y, Z = co.z, st = co.stride, order = index.order;
+	var P = outP, D = outD2, visited = 0, budget = index.keys.length;
+	var out = [0, 0, 0];
+	for (a = 0; a < axes; a++) {
+		var gl = mn[a], gh = mn[a] + n[a] * cs;
+		out[a] = Math.max(0, (q[a] < gl ? gl - q[a] : q[a] > gh ? q[a] - gh : 0) - cs * EPS);
+	}
+
+	// Max-heap on (D, P): the root is the worst of the best m
+	function worse(i, j) { return D[i] > D[j] || (D[i] === D[j] && P[i] > P[j]); }
+	function swap(i, j) { var tp = P[i]; P[i] = P[j]; P[j] = tp; var td = D[i]; D[i] = D[j]; D[j] = td; }
+	function down(i, len) {
+		for (;;) {
+			var l = 2 * i + 1, r = l + 1, w = i;
+			if (l < len && worse(l, w)) w = l;
+			if (r < len && worse(r, w)) w = r;
+			if (w === i) return;
+			swap(i, w); i = w;
+		}
+	}
+	function offer(p, d) {
+		if (m < k) {
+			P[m] = p; D[m] = d;
+			for (var i = m++; i > 0;) { var up = Math.floor((i - 1) / 2); if (!worse(i, up)) break; swap(i, up); i = up; }
+		} else if (d < D[0] || (d === D[0] && p < P[0])) {
+			P[0] = p; D[0] = d; down(0, m);
+		}
+	}
+	function limit() { return m === k ? Math.min(D[0], maxD2) : maxD2; }
+	function scanSlot(s) {
+		for (var j = index.start[s], e = j + index.length[s]; j < e; j++) {
+			var p = order[j];
+			if (p === skip) continue;
+			var o = p * st;
+			var dx = X[o] - q[0], dy = Y[o] - q[1], dz = xy ? 0 : Z[o] - q[2];
+			var d = dx * dx + dy * dy + dz * dz;
+			if (d <= maxD2) offer(p, d);
+		}
+	}
+	function cell(ix, iy, iz) {
+		visited++;
+		var s = lookup(index, ix, iy, iz);
+		if (s < 0 || cellDist2(index, ix, iy, iz, q, xy) > limit()) return;
+		scanSlot(s);
+	}
+	function ring(r) {
+		var x0 = Math.max(0, c[0] - r), x1 = Math.min(n[0] - 1, c[0] + r);
+		var y0 = Math.max(0, c[1] - r), y1 = Math.min(n[1] - 1, c[1] + r);
+		var z0 = xy ? 0 : Math.max(0, c[2] - r), z1 = xy ? n[2] - 1 : Math.min(n[2] - 1, c[2] + r);
+		function column(ix, iy) { for (var iz = z0; iz <= z1; iz++) cell(ix, iy, iz); }
+		for (var ix = x0; ix <= x1; ix++) {
+			if (ix === c[0] - r || ix === c[0] + r) {
+				for (var iy = y0; iy <= y1; iy++) column(ix, iy);
+				continue;
+			}
+			if (c[1] - r >= 0) column(ix, c[1] - r);
+			if (c[1] + r < n[1]) column(ix, c[1] + r);
+			if (xy) continue;
+			for (iy = Math.max(y0, c[1] - r + 1); iy <= Math.min(y1, c[1] + r - 1); iy++) {
+				if (c[2] - r >= 0) cell(ix, iy, c[2] - r);
+				if (c[2] + r < n[2]) cell(ix, iy, c[2] + r);
+			}
+		}
+	}
+	function gap(g) { g = Math.max(0, g - cs * EPS); return g * g; }
+	// The occupied cells in order of distance, from scratch, for queries rings would make slow
+	function byScan() {
+		m = 0;
+		var keys = index.keys, cand = [];
+		for (var s = 0; s < keys.length; s++) {
+			if (keys[s] < 0) continue;
+			var cc = decode(index, keys[s]), cd = cellDist2(index, cc[0], cc[1], cc[2], q, xy);
+			if (cd <= maxD2) cand.push([cd, s]);
+		}
+		cand.sort(function (u, v) { return u[0] - v[0]; });
+		for (var i = 0; i < cand.length; i++) {
+			if (cand[i][0] > limit()) break;
+			scanSlot(cand[i][1]);
+		}
+	}
+
+	for (var r = 0; ; r++) {
+		ring(r);
+		if (visited > budget) { byScan(); break; }
+		// A lower bound on the squared distance of every point not yet visited
+		var bound2 = Infinity;
+		for (a = 0; a < axes; a++) {
+			var rest = 0;
+			for (var b = 0; b < axes; b++) if (b !== a) rest += out[b] * out[b];
+			if (c[a] - r > 0) bound2 = Math.min(bound2, gap(q[a] - (mn[a] + (c[a] - r) * cs)) + rest);
+			if (c[a] + r < n[a] - 1) bound2 = Math.min(bound2, gap(mn[a] + (c[a] + r + 1) * cs - q[a]) + rest);
+		}
+		if (bound2 === Infinity) break;
+		if (m === k && D[0] < bound2) break;
+		if (bound2 > maxD2) break;
+	}
+	// Heap sort: ascending by (D, P)
+	for (var end = m - 1; end > 0; end--) { swap(0, end); down(0, end); }
+	return m;
+}
+
+/**
+ * The k nearest points to a point, nearest first (lowest number on a tie).
+ * @param {object} index - PointIndex from buildIndex.
+ * @param {number[]} point - [x, y, z]; with xy, [x, y] is enough.
+ * @param {number} k - how many, a whole number >= 1.
+ * @param {{maxDistance?: number, xy?: boolean}} [opts] - maxDistance omitted: unlimited.
+ * @returns {{points: Uint32Array, d: Float64Array}} point numbers and their distances
+ */
+export function nearestPoints(index, point, k, opts) {
+	checkIndex(index, "nearestPoints");
+	var xy = !!(opts && opts.xy);
+	var q = checkPoint(point, xy, "point");
+	checkK(k, "k");
+	var maxD = opts ? opts.maxDistance : undefined;
+	checkPositive(maxD, "maxDistance", true);
+	var kk = Math.min(k, index.count), P = new Uint32Array(kk), D = new Float64Array(kk);
+	var m = kk === 0 ? 0 : knnSearch(index, q[0], q[1], q[2], kk, maxD === undefined ? Infinity : maxD * maxD, -1, P, D, xy);
+	for (var i = 0; i < m; i++) D[i] = Math.sqrt(D[i]);
+	return { points: m === kk ? P : P.slice(0, m), d: m === kk ? D : D.slice(0, m) };
+}

package/src/index.js

@@ -6,7 +6,7 @@
 //==========================================================
 
 /** Library version, matches package.json. */
-export var VERSION = "0.6.1";
+export var VERSION = "0.7.0";
 
 export { LasError, ERROR_CODES } from "./errors.js";
 export { openLas, LasReader } from "./LasReader.js";
@@ -19,11 +19,15 @@ export { makeKeep, countKept } from "./filter/filters.js";
 export { dedupe, dedupeSelection } from "./filter/dedupe.js";
 export { buildIndex } from "./index/grid.js";
 export { pointsInRadius, nearestPoint, pointsNearRay } from "./index/query.js";
+export { nearestPoints } from "./index/knn.js";
 export { selectBox, selectPolygon, selectClasses, selectReturns, thinSelection, unionSelections, intersectSelections, subtractSelections } from "./ops/select.js";
 export { keepPoints, removePoints, splitPoints, mergePoints } from "./ops/apply.js";
 export { makeTransform, transformPoints } from "./ops/transform.js";
 export { interleavePositions } from "./ops/interleave.js";
 export { selectSparse } from "./ops/sparse.js";
+export { selectOutliers } from "./ops/outliers.js";
+export { pointNormals, estimateNoise } from "./ops/normals.js";
+export { denoisePoints } from "./ops/denoise.js";
 export { MemorySource } from "./io/MemorySource.js";
 export { BlobSource } from "./io/BlobSource.js";
 export { NodeFileSource } from "./io/NodeFileSource.js";

package/src/ops/denoise.js

@@ -0,0 +1,131 @@
+// src/ops/denoise.js
+//==========================================================
+// Smooth a fuzzy scan: each point moves against its neighbours (the
+// other points among its k nearest within maxDistance).
+//  - "bilateral" (the default; edges stay sharp): the point moves
+//    along its normal by the weighted mean height of its neighbours
+//    above its plane (Fleishman, Drori and Cohen-Or, 2003, on points).
+//    A neighbour's weight falls with its distance (σc, half the
+//    farthest neighbour's distance) and with its height (σs, twice
+//    the noise level), so a face across a crest counts for almost
+//    nothing. The normal is fitted twice: plainly, then with those
+//    weights, so a crest point follows the face it is on.
+//  - "mls": the point moves onto the plane fitted to its neighbours
+//    with distance weights. Smooths more; rounds edges slightly.
+// The noise level (sigma) is measured (estimateNoise) unless given.
+// Every point is computed from the old coordinates, so the result
+// does not depend on point order; a further pass rebuilds the index.
+// A point with fewer than 5 neighbours, or on no plane, stays put.
+// The result is as transformPoints returns it: new coordinates of the
+// input's types, every other column shared.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+import { coordsOf } from "../index/grid.js";
+import { checkK, checkMaxDistance, progress } from "../index/knn.js";
+import { buildKdTree, kdNearest } from "../index/kdtree.js";
+import { fitPlane, estimateNoise } from "./normals.js";
+import { columnsOf, sameType, checkNoSharedMemory } from "./columns.js";
+
+var MIN_NEIGHBOURS = 5;
+
+function bad(message) { return new LasError(ERROR_CODES.INVALID_ARGUMENT, message); }
+
+/**
+ * Smooth point columns against their neighbours.
+ * @param {object} cols - point columns (x, y, z or a k = 3 positions column).
+ * @param {{method?: string, k?: number, maxDistance: number, sigma?: number, iterations?: number,
+ *   normals?: boolean, inPlace?: boolean, onProgress?: function(number, number)}} opts -
+ *   method "bilateral" or "mls" (default "bilateral"), k 16, sigma measured, iterations 1.
+ * @returns {object} point columns: new x, y, z (or positions); with normals, a normal column (Float32, k = 3)
+ */
+export function denoisePoints(cols, opts) {
+	opts = opts || {};
+	var method = opts.method === undefined ? "bilateral" : opts.method;
+	if (method !== "bilateral" && method !== "mls") throw bad("method must be \"bilateral\" or \"mls\", not " + String(method));
+	var k = opts.k === undefined ? 16 : opts.k;
+	checkK(k, "k");
+	checkMaxDistance(opts.maxDistance);
+	var iterations = opts.iterations === undefined ? 1 : opts.iterations;
+	if (!(Number.isInteger(iterations) && iterations >= 1)) throw bad("iterations must be a whole number >= 1, not " + String(iterations));
+	if (opts.sigma !== undefined && !(typeof opts.sigma === "number" && isFinite(opts.sigma) && opts.sigma > 0)) throw bad("sigma must be a positive finite number, not " + String(opts.sigma));
+	var maxDistance = opts.maxDistance, maxD2 = maxDistance * maxDistance;
+	var co = coordsOf(cols, "denoisePoints"), n = cols.count, positions = co.stride === 3;
+	var tick = progress(opts.onProgress, n * iterations);
+	if (opts.inPlace && !positions) checkNoSharedMemory(cols, [{ name: "x" }, { name: "y" }, { name: "z" }]);
+	var sigma = opts.sigma !== undefined ? opts.sigma : estimateNoise(cols, { k: k, maxDistance: maxDistance });
+	var move = sigma > 0;
+
+	// Coordinate buffers of the input's types: pass i reads src and writes dst
+	function buffers() { return positions ? { count: n, positions: sameType(cols.positions, 3 * n) } : { count: n, x: sameType(cols.x, n), y: sameType(cols.y, n), z: sameType(cols.z, n) }; }
+	var src = positions ? { count: n, positions: cols.positions } : { count: n, x: cols.x, y: cols.y, z: cols.z };
+	var dst = buffers();
+	var normal = opts.normals ? new Float32Array(3 * n) : null;
+	var P = new Uint32Array(k), D = new Float64Array(k), W = new Float64Array(k), fit = new Float64Array(7);
+	var inv2s = 1 / (2 * (2 * sigma) * (2 * sigma));
+
+	for (var pass = 0; pass < iterations; pass++) {
+		var last = pass === iterations - 1;
+		var index = move || (last && normal) ? buildKdTree(src, "denoisePoints") : null;
+		var sc = index ? index.coords : coordsOf(src, "denoisePoints");
+		var X = sc.x, Y = sc.y, Z = sc.z, st = sc.stride;
+		var dc = coordsOf(dst, "denoisePoints"), OX = dc.x, OY = dc.y, OZ = dc.z;
+		for (var p = 0, o = 0; p < n; p++, o += st) {
+			var px = X[o], py = Y[o], pz = Z[o], nx = 0, ny = 0, nz = 0, delta = 0;
+			var m = index ? kdNearest(index, px, py, pz, k, maxD2, p, P, D) : 0;
+			if (m >= 3 && fitPlane(X, Y, Z, st, p, P, m, null, fit)) {
+				nx = fit[0]; ny = fit[1]; nz = fit[2];
+				if (move && m >= MIN_NEIGHBOURS && D[m - 1] > 0) {
+					var s = 0.5 * Math.sqrt(D[m - 1]), inv2c = 1 / (2 * s * s), j, q, h;
+					if (method === "bilateral") {
+						for (j = 0; j < m; j++) {
+							q = P[j] * st;
+							h = nx * (X[q] - px) + ny * (Y[q] - py) + nz * (Z[q] - pz);
+							W[j] = Math.exp(-D[j] * inv2c - h * h * inv2s);
+						}
+						if (fitPlane(X, Y, Z, st, p, P, m, W, fit)) { nx = fit[0]; ny = fit[1]; nz = fit[2]; }
+						var num = 0, den = 0;
+						for (j = 0; j < m; j++) {
+							q = P[j] * st;
+							h = nx * (X[q] - px) + ny * (Y[q] - py) + nz * (Z[q] - pz);
+							var w = Math.exp(-D[j] * inv2c - h * h * inv2s);
+							num += w * h; den += w;
+						}
+						if (den > 0) delta = num / den;
+					} else {
+						for (j = 0; j < m; j++) W[j] = Math.exp(-D[j] * inv2c);
+						if (fitPlane(X, Y, Z, st, p, P, m, W, fit)) {
+							nx = fit[0]; ny = fit[1]; nz = fit[2];
+							delta = nx * fit[4] + ny * fit[5] + nz * fit[6];
+						}
+					}
+				}
+			}
+			var d = p * dc.stride;
+			if (delta !== 0) { OX[d] = px + nx * delta; OY[d] = py + ny * delta; OZ[d] = pz + nz * delta; }
+			else { OX[d] = px; OY[d] = py; OZ[d] = pz; }
+			if (normal && last) { normal[3 * p] = nx; normal[3 * p + 1] = ny; normal[3 * p + 2] = nz; }
+			tick(pass * n + p + 1);
+		}
+		if (!last) {
+			// the input is never written: pass 1 needs a second buffer, later passes swap the two
+			var old = src;
+			src = dst; dst = pass === 0 ? buffers() : old;
+		}
+	}
+
+	var moved = dst;
+	if (opts.inPlace) {
+		if (positions) cols.positions.set(dst.positions);
+		else { cols.x.set(dst.x); cols.y.set(dst.y); cols.z.set(dst.z); }
+		moved = cols;
+	}
+	var names = positions ? ["positions"] : ["x", "y", "z"], out = { count: n };
+	columnsOf(cols).forEach(function (c) {
+		// defineProperty so a column named "__proto__" stays a column
+		var v = names.indexOf(c.name) >= 0 ? moved[c.name] : cols[c.name];
+		Object.defineProperty(out, c.name, { value: v, enumerable: true, writable: true, configurable: true });
+	});
+	if (normal) Object.defineProperty(out, "normal", { value: normal, enumerable: true, writable: true, configurable: true });
+	return out;
+}

package/src/ops/normals.js

@@ -0,0 +1,177 @@
+// src/ops/normals.js
+//==========================================================
+// Surface normals by a plane fit: the covariance of a point and its
+// neighbours (the other points among its k nearest within
+// maxDistance), whose smallest eigenvector is the normal, from a
+// cyclic Jacobi solver on the 3 × 3 matrix (steady when eigenvalues
+// are equal, as on a line of points). Sums are taken on offsets from
+// the point, so UTM-sized coordinates lose nothing. Normals point up
+// (z > 0; a horizontal one has x > 0, then y > 0). The residual, the
+// RMS distance of the fitted points from the plane, measures the local
+// noise; estimateNoise is its median over a spread sample. The fit is
+// shared with denoisePoints, which weights it.
+//==========================================================
+
+import { checkK, checkMaxDistance, progress } from "../index/knn.js";
+import { buildKdTree, kdNearest } from "../index/kdtree.js";
+import { thinSelection } from "./select.js";
+
+var NOISE_SAMPLE = 100000;
+
+/**
+ * Flip a unit vector so z > 0; if z is 0, x > 0; if x is also 0, y > 0.
+ * @param {Float64Array|number[]} v - v[0..2], changed in place.
+ */
+export function orientNormal(v) {
+	if (v[2] < 0 || (v[2] === 0 && (v[0] < 0 || (v[0] === 0 && v[1] < 0)))) { v[0] = -v[0]; v[1] = -v[1]; v[2] = -v[2]; }
+	// no negative zeros
+	v[0] += 0; v[1] += 0; v[2] += 0;
+}
+
+/**
+ * The unit eigenvector of the smallest eigenvalue of a symmetric 3 × 3 matrix, oriented
+ * (orientNormal), and that eigenvalue. The lowest axis wins a tie.
+ * @param {Float64Array} m - [c00, c01, c02, c11, c12, c22].
+ * @param {Float64Array} out - out[0..2] the vector, out[3] the eigenvalue; out[4], when out has
+ *   room, the middle eigenvalue.
+ * @returns {boolean} false (out = 0, 0, 0, NaN) when the trace is 0
+ */
+export function smallestEigen(m, out) {
+	if (!(m[0] + m[3] + m[5] > 0)) { out[0] = 0; out[1] = 0; out[2] = 0; out[3] = NaN; return false; }
+	var A = [[m[0], m[1], m[2]], [m[1], m[3], m[4]], [m[2], m[4], m[5]]];
+	var V = [[1, 0, 0], [0, 1, 0], [0, 0, 1]];
+	var PQ = [[0, 1], [0, 2], [1, 2]];
+	for (var sweep = 0; sweep < 50; sweep++) {
+		var off = A[0][1] * A[0][1] + A[0][2] * A[0][2] + A[1][2] * A[1][2];
+		var diag = A[0][0] * A[0][0] + A[1][1] * A[1][1] + A[2][2] * A[2][2];
+		if (off <= 1e-30 * diag) break;
+		for (var r = 0; r < 3; r++) {
+			var p = PQ[r][0], q = PQ[r][1], apq = A[p][q];
+			if (apq === 0) continue;
+			// Numerical Recipes' rotation: t = tan of the angle that zeroes A[p][q]
+			var theta = (A[q][q] - A[p][p]) / (2 * apq);
+			var t = Math.abs(theta) > 1e150 ? 1 / (2 * theta) : (theta >= 0 ? 1 : -1) / (Math.abs(theta) + Math.sqrt(theta * theta + 1));
+			var c = 1 / Math.sqrt(t * t + 1), s = t * c;
+			for (var i = 0; i < 3; i++) {
+				var aip = A[i][p], aiq = A[i][q];
+				A[i][p] = c * aip - s * aiq; A[i][q] = s * aip + c * aiq;
+			}
+			for (i = 0; i < 3; i++) {
+				var api = A[p][i], aqi = A[q][i];
+				A[p][i] = c * api - s * aqi; A[q][i] = s * api + c * aqi;
+			}
+			A[p][q] = 0; A[q][p] = 0;
+			for (i = 0; i < 3; i++) {
+				var vip = V[i][p], viq = V[i][q];
+				V[i][p] = c * vip - s * viq; V[i][q] = s * vip + c * viq;
+			}
+		}
+	}
+	var b = 0;
+	if (A[1][1] < A[b][b]) b = 1;
+	if (A[2][2] < A[b][b]) b = 2;
+	out[0] = V[0][b]; out[1] = V[1][b]; out[2] = V[2][b];
+	var len = Math.sqrt(out[0] * out[0] + out[1] * out[1] + out[2] * out[2]);
+	out[0] /= len; out[1] /= len; out[2] /= len;
+	orientNormal(out);
+	out[3] = A[b][b];
+	if (out.length > 4) out[4] = A[(b + 1) % 3][(b + 1) % 3] < A[(b + 2) % 3][(b + 2) % 3] ? A[(b + 1) % 3][(b + 1) % 3] : A[(b + 2) % 3][(b + 2) % 3];
+	return true;
+}
+
+var M6 = new Float64Array(6), E4 = new Float64Array(5);
+
+/**
+ * Fit a plane to point p and its m neighbours (weights w, p's own weight 1; null: all 1),
+ * on offsets from p.
+ * @param {ArrayLike<number>} X
+ * @param {ArrayLike<number>} Y
+ * @param {ArrayLike<number>} Z
+ * @param {number} stride
+ * @param {number} p - point number.
+ * @param {Uint32Array} nbrs - neighbour point numbers (the first m).
+ * @param {number} m
+ * @param {Float64Array|null} w - w[j] the weight of nbrs[j].
+ * @param {Float64Array} out - [nx, ny, nz, residual, cx, cy, cz]: the unit normal, the RMS distance
+ *   from the plane, and the weighted centroid's offset from p.
+ * @returns {boolean} false (normal 0, residual NaN) when the points do not span a plane: all
+ *   coincident, or on one line (the middle eigenvalue at most 1e-12 of the trace)
+ */
+export function fitPlane(X, Y, Z, stride, p, nbrs, m, w, out) {
+	var o = p * stride, px = X[o], py = Y[o], pz = Z[o];
+	var W = 1, sx = 0, sy = 0, sz = 0, sxx = 0, sxy = 0, sxz = 0, syy = 0, syz = 0, szz = 0;
+	for (var j = 0; j < m; j++) {
+		var q = nbrs[j] * stride, wj = w ? w[j] : 1;
+		var dx = X[q] - px, dy = Y[q] - py, dz = Z[q] - pz;
+		W += wj; sx += wj * dx; sy += wj * dy; sz += wj * dz;
+		sxx += wj * dx * dx; sxy += wj * dx * dy; sxz += wj * dx * dz;
+		syy += wj * dy * dy; syz += wj * dy * dz; szz += wj * dz * dz;
+	}
+	var cx = sx / W, cy = sy / W, cz = sz / W;
+	M6[0] = sxx - sx * cx; M6[1] = sxy - sx * cy; M6[2] = sxz - sx * cz;
+	M6[3] = syy - sy * cy; M6[4] = syz - sy * cz; M6[5] = szz - sz * cz;
+	out[4] = cx; out[5] = cy; out[6] = cz;
+	if (!smallestEigen(M6, E4) || E4[4] <= 1e-12 * (M6[0] + M6[3] + M6[5])) { out[0] = 0; out[1] = 0; out[2] = 0; out[3] = NaN; return false; }
+	out[0] = E4[0]; out[1] = E4[1]; out[2] = E4[2];
+	out[3] = Math.sqrt(Math.max(0, E4[3]) / W);
+	return true;
+}
+
+function options(opts, fn) {
+	opts = opts || {};
+	var k = opts.k === undefined ? 16 : opts.k;
+	checkK(k, "k");
+	checkMaxDistance(opts.maxDistance);
+	return { k: k, maxD2: opts.maxDistance * opts.maxDistance, maxDistance: opts.maxDistance, onProgress: opts.onProgress, fn: fn };
+}
+
+// Fit point p's plane into fit; false with fewer than 3 neighbours or no plane
+function fitAt(index, p, o, P, D, fit) {
+	var co = index.coords, X = co.x, Y = co.y, Z = co.z, st = co.stride, i = p * st;
+	var m = kdNearest(index, X[i], Y[i], Z[i], o.k, o.maxD2, p, P, D);
+	if (m < 3) { fit[0] = 0; fit[1] = 0; fit[2] = 0; fit[3] = NaN; return false; }
+	return fitPlane(X, Y, Z, st, p, P, m, null, fit);
+}
+
+/**
+ * Each point's surface normal and residual, from a plane fitted to it and its neighbours.
+ * @param {object} cols - point columns (x, y, z or a k = 3 positions column).
+ * @param {{k?: number, maxDistance: number, onProgress?: function(number, number)}} opts - k 16.
+ * @returns {{normal: Float32Array, residual: Float32Array}} normal 3 values a point (0, 0, 0 with
+ *   fewer than 3 neighbours); residual NaN there
+ */
+export function pointNormals(cols, opts) {
+	var o = options(opts, "pointNormals");
+	var tick = progress(o.onProgress, cols.count);
+	var index = buildKdTree(cols, "pointNormals"), n = index.count;
+	var normal = new Float32Array(3 * n), residual = new Float32Array(n);
+	var P = new Uint32Array(o.k), D = new Float64Array(o.k), fit = new Float64Array(7);
+	for (var p = 0; p < n; p++) {
+		fitAt(index, p, o, P, D, fit);
+		normal[3 * p] = fit[0]; normal[3 * p + 1] = fit[1]; normal[3 * p + 2] = fit[2];
+		residual[p] = fit[3];
+		tick(p + 1);
+	}
+	return { normal: normal, residual: residual };
+}
+
+/**
+ * The cloud's noise level: the median residual (lower median, finite ones) over up to
+ * 100,000 points spread evenly through it.
+ * @param {object} cols - point columns (x, y, z or a k = 3 positions column).
+ * @param {{k?: number, maxDistance: number}} opts - k 16.
+ * @returns {number} NaN when no sampled point has a plane
+ */
+export function estimateNoise(cols, opts) {
+	var o = options(opts, "estimateNoise");
+	var index = buildKdTree(cols, "estimateNoise");
+	var sample = thinSelection(index.count, NOISE_SAMPLE), res = new Float64Array(sample.length), m = 0;
+	var P = new Uint32Array(o.k), D = new Float64Array(o.k), fit = new Float64Array(7);
+	for (var i = 0; i < sample.length; i++) {
+		// Float32, as pointNormals reports it
+		if (fitAt(index, sample[i], o, P, D, fit)) res[m++] = Math.fround(fit[3]);
+	}
+	if (m === 0) return NaN;
+	var s = res.subarray(0, m).sort();
+	return s[Math.floor((m - 1) / 2)];
+}

package/src/ops/outliers.js

@@ -0,0 +1,50 @@
+// src/ops/outliers.js
+//==========================================================
+// Stray points by PDAL's statistical outlier rule (filters.outlier,
+// method=statistical): each point's mean distance to its k nearest
+// other points; the mean and sample standard deviation (n - 1,
+// accumulated as PDAL does) of those means over the cloud; a point
+// whose mean is above mean + multiplier · sd is an outlier. Returned
+// as a selection for removePoints, as selectSparse.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+import { checkK, progress } from "../index/knn.js";
+import { buildKdTree, kdNearest } from "../index/kdtree.js";
+
+function bad(message) { return new LasError(ERROR_CODES.INVALID_ARGUMENT, message); }
+
+/**
+ * The points whose mean distance to their k nearest other points is above the cloud's
+ * mean of those means plus multiplier standard deviations.
+ * @param {object} cols - point columns (x, y, z or a k = 3 positions column).
+ * @param {{k?: number, multiplier?: number, onProgress?: function(number, number)}} [opts] - k 8, multiplier 2 (PDAL's defaults).
+ * @returns {Uint32Array} ascending point numbers
+ */
+export function selectOutliers(cols, opts) {
+	opts = opts || {};
+	var k = opts.k === undefined ? 8 : opts.k, mult = opts.multiplier === undefined ? 2 : opts.multiplier;
+	checkK(k, "k");
+	if (!(typeof mult === "number" && isFinite(mult))) throw bad("multiplier must be a finite number, not " + String(mult));
+	var tick = progress(opts.onProgress, cols.count);
+	var index = buildKdTree(cols, "selectOutliers"), n = index.count;
+	if (n <= k) { tick(n); return new Uint32Array(0); }
+	var co = index.coords, X = co.x, Y = co.y, Z = co.z, st = co.stride;
+	var P = new Uint32Array(k), D = new Float64Array(k), means = new Float64Array(n);
+	var M1 = 0, M2 = 0;
+	for (var i = 0, o = 0; i < n; i++, o += st) {
+		kdNearest(index, X[o], Y[o], Z[o], k, Infinity, i, P, D);
+		var s = 0;
+		for (var j = 0; j < k; j++) s += Math.sqrt(D[j]);
+		var mean = s / k;
+		means[i] = mean;
+		var delta = mean - M1, dn = delta / (i + 1);
+		M1 += dn; M2 += delta * dn * i;
+		tick(i + 1);
+	}
+	var threshold = M1 + mult * Math.sqrt(M2 / (n - 1)), hits = 0;
+	for (i = 0; i < n; i++) if (means[i] > threshold) hits++;
+	var out = new Uint32Array(hits);
+	for (i = 0, j = 0; i < n; i++) if (means[i] > threshold) out[j++] = i;
+	return out;
+}