las-laz-js 0.4.0 → 0.6.1

package/src/index/grid.js

@@ -0,0 +1,198 @@
+// src/index/grid.js
+//==========================================================
+// The voxel neighbour index: a sorted voxel grid on flat typed
+// arrays. Point numbers are counting-sorted by cell into `order`
+// (stable, so a cell's points stay ascending); an open-addressing
+// hash table (linear probing, power-of-two capacity) maps each
+// occupied cell's key to its `start` and `length` in `order`.
+// Coordinates are referenced, not copied: x / y / z columns, or a
+// k = 3 positions column (Kirra's kadCloud layout) read with a
+// stride of 3. About 6 bytes per point at 16 points per cell.
+// The grid only prunes: queries (query.js) distance-check every
+// candidate in Float64, so their results are exact.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+import { columnsOf, countOf } from "../ops/columns.js";
+
+var MAX_POINTS = 4294967295;
+var MAX_CELLS = 9007199254740992;   // 2^53: keys stay exact integers
+var EMPTY = -1;
+
+function bad(message) { return new LasError(ERROR_CODES.INVALID_ARGUMENT, message); }
+
+/**
+ * The coordinates of point columns: x / y / z (stride 1), else a k = 3
+ * positions column (stride 3, y and z as offset views of it).
+ * Point i's x is coords.x[i * coords.stride].
+ * @param {object} cols - point columns.
+ * @param {string} fn - the calling function's name, for the message.
+ * @returns {{x: ArrayLike<number>, y: ArrayLike<number>, z: ArrayLike<number>, stride: number}}
+ */
+export function coordsOf(cols, fn) {
+	var count = countOf(cols);
+	var k = Object.create(null);
+	columnsOf(cols).forEach(function (c) { k[c.name] = c.k; });
+	if (k.x === 1 && k.y === 1 && k.z === 1) return { x: cols.x, y: cols.y, z: cols.z, stride: 1 };
+	if (k.positions === 3 || (count === 0 && k.positions === 1)) {
+		var p = cols.positions;
+		return { x: p, y: p.subarray(1), z: p.subarray(2), stride: 3 };
+	}
+	throw bad(fn + " needs x, y, z columns or a k = 3 positions column");
+}
+
+/**
+ * Refuse a point count the index cannot number (order is a Uint32Array).
+ * @param {number} n
+ */
+export function checkPointCount(n) {
+	if (n > MAX_POINTS) throw new LasError(ERROR_CODES.TOO_MANY_POINTS, "the neighbour index takes at most 4,294,967,295 points, not " + n);
+}
+
+// murmur3's 32-bit finaliser: every input bit reaches the low bits the mask keeps
+function fmix32(h) {
+	h ^= h >>> 16; h = Math.imul(h, 0x85EBCA6B);
+	h ^= h >>> 13; h = Math.imul(h, 0xC2B2AE35);
+	return (h ^ (h >>> 16)) >>> 0;
+}
+
+/**
+ * The home slot of a cell key (an integer below 2^53) in a table of mask + 1 slots.
+ * @param {number} key
+ * @param {number} mask
+ * @returns {number}
+ */
+export function hashKey(key, mask) {
+	var lo = key % 4294967296, hi = (key - lo) / 4294967296;
+	return fmix32(lo ^ fmix32(hi)) & mask;
+}
+
+function nextPow2(n) {
+	var p = 16;
+	while (p < n) p *= 2;
+	return p;
+}
+
+/**
+ * Build the grid over coordinates.
+ * @param {{x, y, z, stride}} coords - from coordsOf.
+ * @param {number} count - points.
+ * @param {number} [cellSize] - cell edge; omitted: about 16 points per cell.
+ * @param {boolean} [xy] - ignore Z (nz = 1).
+ * @returns {object} PointIndex
+ */
+export function buildGrid(coords, count, cellSize, xy) {
+	if (cellSize !== undefined && !(typeof cellSize === "number" && cellSize > 0 && isFinite(cellSize))) throw bad("cellSize must be a positive finite number, not " + String(cellSize));
+	var X = coords.x, Y = coords.y, Z = coords.z, st = coords.stride;
+
+	// 1. Bounds
+	var lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity];
+	for (var i = 0, o = 0; i < count; i++, o += st) {
+		var a = X[o], b = Y[o], c = xy ? 0 : Z[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");
+		if (a < lo[0]) lo[0] = a; if (a > hi[0]) hi[0] = a;
+		if (b < lo[1]) lo[1] = b; if (b > hi[1]) hi[1] = b;
+		if (c < lo[2]) lo[2] = c; if (c > hi[2]) hi[2] = c;
+	}
+	if (count === 0) { lo = [0, 0, 0]; hi = [0, 0, 0]; }
+	var ext = [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]];
+	if (cellSize === undefined) {
+		var prod = 1, d = 0;
+		ext.forEach(function (e) { if (e > 0) { prod *= e; d++; } });
+		cellSize = d === 0 ? 1 : Math.pow(16 * prod / count, 1 / d);
+	}
+	var nx = Math.floor(ext[0] / cellSize) + 1, ny = Math.floor(ext[1] / cellSize) + 1, nz = Math.floor(ext[2] / cellSize) + 1;
+	if (nx * ny * nz > MAX_CELLS) throw bad("cellSize too small for this extent: " + nx + " × " + ny + " × " + nz + " cells is more than 2^53");
+	var inv = 1 / cellSize, x0 = lo[0], y0 = lo[1], z0 = lo[2];
+	function keyOf(o) {
+		var cx = Math.floor((X[o] - x0) * inv); if (cx >= nx) cx = nx - 1;
+		var cy = Math.floor((Y[o] - y0) * inv); if (cy >= ny) cy = ny - 1;
+		var cz = 0;
+		if (!xy) { cz = Math.floor((Z[o] - z0) * inv); if (cz >= nz) cz = nz - 1; }
+		return (cx * ny + cy) * nz + cz;
+	}
+
+	// 2. Count points per cell into the hash table
+	var cap = nextPow2(2 * Math.min(nx * ny * nz, Math.ceil(count / 16)));
+	var mask = cap - 1, used = 0;
+	var keys = new Float64Array(cap).fill(EMPTY), length = new Uint32Array(cap);
+	function grow() {
+		var oldK = keys, oldL = length;
+		cap *= 2; mask = cap - 1;
+		keys = new Float64Array(cap).fill(EMPTY); length = new Uint32Array(cap);
+		for (var s = 0; s < oldK.length; s++) {
+			if (oldK[s] === EMPTY) continue;
+			var h = hashKey(oldK[s], mask);
+			while (keys[h] !== EMPTY) h = (h + 1) & mask;
+			keys[h] = oldK[s]; length[h] = oldL[s];
+		}
+	}
+	for (i = 0, o = 0; i < count; i++, o += st) {
+		var key = keyOf(o), h = hashKey(key, mask);
+		while (keys[h] !== EMPTY && keys[h] !== key) h = (h + 1) & mask;
+		if (keys[h] === EMPTY) {
+			if (2 * (used + 1) > cap) {
+				grow();
+				h = hashKey(key, mask);
+				while (keys[h] !== EMPTY) h = (h + 1) & mask;
+			}
+			keys[h] = key; used++;
+		}
+		length[h]++;
+	}
+
+	// 3. Prefix sums give each cell's start; place point numbers (stable)
+	var start = new Uint32Array(cap), run = 0;
+	for (var s = 0; s < cap; s++) { start[s] = run; run += length[s]; }
+	var order = new Uint32Array(count);
+	for (i = 0, o = 0; i < count; i++, o += st) {
+		var k2 = keyOf(o), h2 = hashKey(k2, mask);
+		while (keys[h2] !== k2) h2 = (h2 + 1) & mask;
+		order[start[h2]++] = i;
+	}
+	for (s = 0; s < cap; s++) start[s] -= length[s];
+
+	return { count: count, cellSize: cellSize, min: [x0, y0, z0], nx: nx, ny: ny, nz: nz, order: order, keys: keys, start: start, length: length, mask: mask, coords: coords };
+}
+
+/**
+ * Build a neighbour index over point columns.
+ * @param {object} cols - point columns with x, y, z, or a k = 3 positions column.
+ * @param {{cellSize?: number}} [opts] - cellSize omitted: about 16 points per cell.
+ * @returns {object} PointIndex { count, cellSize, min, nx, ny, nz, order, keys, start, length, mask, coords }
+ */
+export function buildIndex(cols, opts) {
+	var coords = coordsOf(cols, "buildIndex");
+	checkPointCount(cols.count);
+	return buildGrid(coords, cols.count, opts ? opts.cellSize : undefined, false);
+}
+
+/**
+ * The hash-table slot of cell (ix, iy, iz), or -1 when the cell is empty or outside the grid.
+ * @param {object} index - PointIndex.
+ * @returns {number}
+ */
+export function lookup(index, ix, iy, iz) {
+	if (ix < 0 || iy < 0 || iz < 0 || ix >= index.nx || iy >= index.ny || iz >= index.nz) return -1;
+	var key = (ix * index.ny + iy) * index.nz + iz, keys = index.keys, mask = index.mask;
+	var h = hashKey(key, mask);
+	while (keys[h] !== EMPTY) {
+		if (keys[h] === key) return h;
+		h = (h + 1) & mask;
+	}
+	return -1;
+}
+
+/**
+ * Refuse an index that is not self-consistent.
+ * @param {object} index - PointIndex.
+ * @param {string} fn - the calling function's name, for the message.
+ */
+export function checkIndex(index, fn) {
+	var ok = index !== null && typeof index === "object" && index.order instanceof Uint32Array && index.order.length === index.count && index.coords;
+	if (ok && index.count > 0) {
+		var need = (index.count - 1) * index.coords.stride + 1;
+		ok = index.coords.x.length >= need && index.coords.y.length >= need && index.coords.z.length >= need;
+	}
+	if (!ok) throw bad(fn + ": index is not self-consistent (rebuild it with buildIndex)");
+}

package/src/index/query.js

@@ -0,0 +1,329 @@
+// src/index/query.js
+//==========================================================
+// Queries on a PointIndex (grid.js). The grid only prunes: every
+// candidate is distance-checked in Float64 against the stored
+// coordinates, "within" is inclusive (<=) and ties go to the lowest
+// point number, so each answer equals a plain scan of the points.
+// Cell ranges and cell distances are widened by a millionth of a
+// cell so float rounding can never skip a cell holding an answer.
+// When a query would visit more cells than the hash table has
+// slots (a cell size far below the query's reach, or a query far
+// outside the cloud), it walks the occupied slots instead.
+//==========================================================
+
+import { LasError, ERROR_CODES } from "../errors.js";
+import { checkIndex, lookup as lookupCell } from "./grid.js";
+
+var EPS = 1e-6;   // in cells
+
+function bad(message) { return new LasError(ERROR_CODES.INVALID_ARGUMENT, message); }
+
+function fin(v) { return typeof v === "number" && isFinite(v); }
+
+// [x, y, z] as Numbers; with xy, [x, y] or [x, y, anything]
+function checkPoint(p, xy, name) {
+	var ok = Array.isArray(p) && (p.length === 3 || (xy && p.length === 2)) && fin(p[0]) && fin(p[1]) && (xy || fin(p[2]));
+	if (!ok) throw bad(name + " must be [x, y, z]" + (xy ? " or [x, y]" : "") + " of finite numbers");
+	return [p[0], p[1], xy ? 0 : p[2]];
+}
+
+function checkPositive(v, name, optional) {
+	if (optional && v === undefined) return;
+	if (!(fin(v) && v > 0)) throw bad(name + " must be a positive finite number, not " + String(v));
+}
+
+function dims(index) { return [index.nx, index.ny, index.nz]; }
+
+// Inclusive cell range on one axis covering [a, b], clamped; lo > hi when empty
+function cellRange(index, axis, a, b) {
+	var n = dims(index)[axis], inv = 1 / index.cellSize, m = index.min[axis];
+	var lo = Math.floor((a - m) * inv - EPS), hi = Math.floor((b - m) * inv + EPS);
+	return [Math.max(0, lo), Math.min(n - 1, hi)];
+}
+
+// Squared distance from q to the box of cell (ix, iy, iz), the box widened by EPS cells
+function cellDist2(index, ix, iy, iz, q, xy) {
+	var cs = index.cellSize, g = cs * EPS, m = index.min, c = [ix, iy, iz], s = 0;
+	for (var a = 0; a < (xy ? 2 : 3); a++) {
+		var lo = m[a] + c[a] * cs - g, hi = m[a] + (c[a] + 1) * cs + g;
+		var d = lo - q[a] > 0 ? lo - q[a] : (q[a] - hi > 0 ? q[a] - hi : 0);
+		s += d * d;
+	}
+	return s;
+}
+
+function decode(index, key) {
+	var iz = key % index.nz, t = (key - iz) / index.nz, iy = t % index.ny;
+	return [(t - iy) / index.ny, iy, iz];
+}
+
+/**
+ * Call fn(slot, ix, iy, iz) for every occupied cell in an inclusive cell box.
+ * Walks the table instead when the box has more cells than the table has slots.
+ * @param {object} index - PointIndex.
+ * @param {number[]} lo - [ix, iy, iz] low corner.
+ * @param {number[]} hi - [ix, iy, iz] high corner.
+ * @param {function} fn
+ */
+export function visitBox(index, lo, hi, fn) {
+	if (lo[0] > hi[0] || lo[1] > hi[1] || lo[2] > hi[2]) return;
+	var cells = (hi[0] - lo[0] + 1) * (hi[1] - lo[1] + 1) * (hi[2] - lo[2] + 1), keys = index.keys;
+	if (cells > keys.length) {
+		for (var s = 0; s < keys.length; s++) {
+			if (keys[s] < 0) continue;
+			var c = decode(index, keys[s]);
+			if (c[0] >= lo[0] && c[0] <= hi[0] && c[1] >= lo[1] && c[1] <= hi[1] && c[2] >= lo[2] && c[2] <= hi[2]) fn(s, c[0], c[1], c[2]);
+		}
+		return;
+	}
+	for (var ix = lo[0]; ix <= hi[0]; ix++) {
+		for (var iy = lo[1]; iy <= hi[1]; iy++) {
+			for (var iz = lo[2]; iz <= hi[2]; iz++) {
+				var slot = lookupCell(index, ix, iy, iz);
+				if (slot >= 0) fn(slot, ix, iy, iz);
+			}
+		}
+	}
+}
+
+/**
+ * Every point within `radius` of a point (inclusive), as a selection.
+ * @param {object} index - PointIndex from buildIndex.
+ * @param {number[]} point - [x, y, z]; with xy, [x, y] is enough.
+ * @param {number} radius - > 0.
+ * @param {{xy?: boolean}} [opts] - xy: measure in XY only.
+ * @returns {Uint32Array} ascending point numbers
+ */
+export function pointsInRadius(index, point, radius, opts) {
+	checkIndex(index, "pointsInRadius");
+	var xy = !!(opts && opts.xy);
+	var q = checkPoint(point, xy, "point");
+	checkPositive(radius, "radius");
+	if (index.count === 0) return new Uint32Array(0);
+	var rx = cellRange(index, 0, q[0] - radius, q[0] + radius), ry = cellRange(index, 1, q[1] - radius, q[1] + radius);
+	var rz = xy ? [0, index.nz - 1] : cellRange(index, 2, q[2] - radius, q[2] + radius);
+	var r2 = radius * radius, co = index.coords, X = co.x, Y = co.y, Z = co.z, st = co.stride, order = index.order;
+	var hits = [];
+	visitBox(index, [rx[0], ry[0], rz[0]], [rx[1], ry[1], rz[1]], function (s, ix, iy, iz) {
+		if (cellDist2(index, ix, iy, iz, q, xy) > r2) return;
+		for (var j = index.start[s], e = j + index.length[s]; j < e; j++) {
+			var p = order[j], o = p * st;
+			var dx = X[o] - q[0], dy = Y[o] - q[1], dz = xy ? 0 : Z[o] - q[2];
+			if (dx * dx + dy * dy + dz * dz <= r2) hits.push(p);
+		}
+	});
+	return Uint32Array.from(hits).sort();
+}
+
+/**
+ * The nearest point (lowest number on a tie), or -1 when none is within maxDistance.
+ * @param {object} index - PointIndex from buildIndex.
+ * @param {number[]} point - [x, y, z]; with xy, [x, y] is enough.
+ * @param {{maxDistance?: number, xy?: boolean}} [opts] - maxDistance omitted: unlimited.
+ * @returns {number}
+ */
+export function nearestPoint(index, point, opts) {
+	checkIndex(index, "nearestPoint");
+	var xy = !!(opts && opts.xy);
+	var q = checkPoint(point, xy, "point");
+	var maxD = opts ? opts.maxDistance : undefined;
+	checkPositive(maxD, "maxDistance", true);
+	if (index.count === 0) return -1;
+	var maxD2 = maxD === undefined ? Infinity : maxD * maxD;
+	var n = dims(index), cs = index.cellSize, inv = 1 / cs, m = index.min, axes = xy ? 2 : 3;
+	var c = [0, 0, 0];
+	for (var a = 0; a < axes; a++) c[a] = Math.min(n[a] - 1, Math.max(0, Math.floor((q[a] - m[a]) * inv)));
+	var co = index.coords, X = co.x, Y = co.y, Z = co.z, st = co.stride, order = index.order;
+	var best = -1, bd = Infinity, visited = 0, budget = index.keys.length;
+	// How far the query lies outside the grid on each axis (0 inside)
+	var out = [0, 0, 0];
+	for (a = 0; a < axes; a++) {
+		var gl = m[a], gh = m[a] + n[a] * cs;
+		out[a] = Math.max(0, (q[a] < gl ? gl - q[a] : q[a] > gh ? q[a] - gh : 0) - cs * EPS);
+	}
+
+	function cell(ix, iy, iz) {
+		visited++;
+		var s = lookupCell(index, ix, iy, iz);
+		if (s < 0 || cellDist2(index, ix, iy, iz, q, xy) > Math.min(bd, maxD2)) return;
+		for (var j = index.start[s], e = j + index.length[s]; j < e; j++) {
+			var p = order[j], 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 && (d < bd || (d === bd && p < best))) { bd = d; best = p; }
+		}
+	}
+	// Every grid cell at Chebyshev distance r (in the axes used) from c
+	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;
+			// interior columns: only the two z faces
+			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; }
+
+	for (var r = 0; ; r++) {
+		ring(r);
+		if (visited > budget) return nearestByScan(index, q, xy, maxD2, best, bd);
+		// Unvisited points lie beyond a face of the cells c - r .. c + r on some axis a, and
+		// inside the grid on the others: a lower bound on their squared distance
+		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] - (m[a] + (c[a] - r) * cs)) + rest);
+			if (c[a] + r < n[a] - 1) bound2 = Math.min(bound2, gap(m[a] + (c[a] + r + 1) * cs - q[a]) + rest);
+		}
+		if (bound2 === Infinity) break;
+		if (best >= 0 && bd < bound2) break;
+		if (bound2 > maxD2) break;
+	}
+	return best;
+}
+
+// The occupied cells in order of distance, for queries a ring search would make slow
+function nearestByScan(index, q, xy, maxD2, best, bd) {
+	var keys = index.keys, cand = [];
+	for (var s = 0; s < keys.length; s++) {
+		if (keys[s] < 0) continue;
+		var c = decode(index, keys[s]), cd = cellDist2(index, c[0], c[1], c[2], q, xy);
+		if (cd <= maxD2 && cd <= bd) cand.push([cd, s]);
+	}
+	cand.sort(function (u, v) { return u[0] - v[0]; });
+	var co = index.coords, X = co.x, Y = co.y, Z = co.z, st = co.stride, order = index.order;
+	for (var i = 0; i < cand.length; i++) {
+		if (cand[i][0] > bd) break;
+		s = cand[i][1];
+		for (var j = index.start[s], e = j + index.length[s]; j < e; j++) {
+			var p = order[j], 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 && (d < bd || (d === bd && p < best))) { bd = d; best = p; }
+		}
+	}
+	return best;
+}
+
+/**
+ * Every point near a ray: within radius + growth · t of its axis, where t >= 0 is the
+ * point's distance along it (growth 0: a cylinder, as an orthographic view's pick ray;
+ * growth > 0: a cone, as a perspective camera's, growth = tan of the half-angle).
+ * The snap rules (front-most, priorities) are the caller's: pick from t and d.
+ * @param {object} index - PointIndex from buildIndex.
+ * @param {number[]} origin - [x, y, z].
+ * @param {number[]} direction - [x, y, z], any length > 0.
+ * @param {{radius: number, growth?: number, maxT?: number}} opts - maxT omitted: unlimited.
+ * @returns {{points: Uint32Array, t: Float64Array, d: Float64Array}} points ascending; t, d parallel
+ */
+export function pointsNearRay(index, origin, direction, opts) {
+	checkIndex(index, "pointsNearRay");
+	var o = checkPoint(origin, false, "origin");
+	var dir = checkPoint(direction, false, "direction");
+	var len = Math.sqrt(dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2]);
+	if (!(len > 0 && isFinite(len))) throw bad("direction must not be zero");
+	var u = [dir[0] / len, dir[1] / len, dir[2] / len];
+	opts = opts || {};
+	checkPositive(opts.radius, "radius");
+	var growth = opts.growth === undefined ? 0 : opts.growth;
+	if (!(fin(growth) && growth >= 0)) throw bad("growth must be a finite number >= 0, not " + String(growth));
+	checkPositive(opts.maxT, "maxT", true);
+	var radius = opts.radius, maxT = opts.maxT;
+	var points = [], ts = [], ds = [];
+	var co = index.coords, X = co.x, Y = co.y, Z = co.z, st = co.stride, order = index.order;
+
+	function check(s) {
+		for (var j = index.start[s], e = j + index.length[s]; j < e; j++) {
+			var p = order[j], q = p * st;
+			var vx = X[q] - o[0], vy = Y[q] - o[1], vz = Z[q] - o[2];
+			var t = vx * u[0] + vy * u[1] + vz * u[2];
+			if (t < 0 || (maxT !== undefined && t > maxT)) continue;
+			var cx = vy * u[2] - vz * u[1], cy = vz * u[0] - vx * u[2], cz = vx * u[1] - vy * u[0];
+			var d = Math.sqrt(cx * cx + cy * cy + cz * cz);
+			if (d <= radius + growth * t) { points.push(p); ts.push(t); ds.push(d); }
+		}
+	}
+
+	if (index.count > 0) walk();
+	var idx = points.map(function (_, i) { return i; }).sort(function (a, b) { return points[a] - points[b]; });
+	return {
+		points: Uint32Array.from(idx, function (i) { return points[i]; }),
+		t: Float64Array.from(idx, function (i) { return ts[i]; }),
+		d: Float64Array.from(idx, function (i) { return ds[i]; })
+	};
+
+	function walk() {
+		var cs = index.cellSize, m = index.min, n = dims(index);
+		var lo = [m[0], m[1], m[2]], hi = [m[0] + n[0] * cs, m[1] + n[1] * cs, m[2] + n[2] * cs];
+		// No point has a t beyond the far side of the grid's bounding sphere
+		var half = 0, dc = 0;
+		for (var a = 0; a < 3; a++) { var e = (hi[a] - lo[a]) / 2, w = (lo[a] + hi[a]) / 2 - o[a]; half += e * e; dc += w * w; }
+		var T = Math.sqrt(dc) + Math.sqrt(half);
+		if (maxT !== undefined && maxT < T) T = maxT;
+		var R = radius + growth * T + cs * EPS;
+		// Clip [0, T] to where the ray is within R of the grid's box (slab method)
+		var t0 = 0, t1 = T;
+		for (a = 0; a < 3; a++) {
+			if (u[a] === 0) {
+				if (o[a] < lo[a] - R || o[a] > hi[a] + R) return;
+				continue;
+			}
+			var ta = (lo[a] - R - o[a]) / u[a], tb = (hi[a] + R - o[a]) / u[a];
+			if (ta > tb) { var sw = ta; ta = tb; tb = sw; }
+			if (ta > t0) t0 = ta;
+			if (tb < t1) t1 = tb;
+		}
+		if (t0 > t1) return;
+		// Many more cells along the way than occupied cells: test each occupied cell once
+		var across = 2 * R / cs + 1;
+		if (((t1 - t0) / cs + 1) * across * across > index.keys.length) return scanCells();
+		var seen = new Set();
+		for (var t = t0; t <= t1; t += cs) {
+			var t2 = Math.min(t + cs, t1), rr = radius + growth * t2;
+			var bl = [0, 0, 0], bh = [0, 0, 0];
+			for (a = 0; a < 3; a++) {
+				var pa = o[a] + t * u[a], pb = o[a] + t2 * u[a];
+				var r = cellRange(index, a, Math.min(pa, pb) - rr, Math.max(pa, pb) + rr);
+				bl[a] = r[0]; bh[a] = r[1];
+			}
+			visitBox(index, bl, bh, function (s) {
+				if (seen.has(s)) return;
+				seen.add(s);
+				check(s);
+			});
+			if (t2 >= t1) break;
+		}
+	}
+
+	// A cell can hold an answer only if its centre is near enough: every point is
+	// within hd of the centre, so its t and d differ from the centre's by at most hd
+	function scanCells() {
+		var cs = index.cellSize, m = index.min, keys = index.keys, hd = cs * Math.sqrt(3) / 2 + cs * EPS;
+		for (var s = 0; s < keys.length; s++) {
+			if (keys[s] < 0) continue;
+			var c = decode(index, keys[s]);
+			var vx = m[0] + (c[0] + 0.5) * cs - o[0], vy = m[1] + (c[1] + 0.5) * cs - o[1], vz = m[2] + (c[2] + 0.5) * cs - o[2];
+			var tc = vx * u[0] + vy * u[1] + vz * u[2];
+			if (tc + hd < 0 || (maxT !== undefined && tc - hd > maxT)) continue;
+			var cx = vy * u[2] - vz * u[1], cy = vz * u[0] - vx * u[2], cz = vx * u[1] - vy * u[0];
+			if (Math.sqrt(cx * cx + cy * cy + cz * cz) - hd > radius + growth * Math.max(0, tc + hd)) continue;
+			check(s);
+		}
+	}
+}
+
+export { checkPoint, checkPositive, cellRange, cellDist2, decode };

package/src/index.js

@@ -6,7 +6,7 @@
 //==========================================================
 
 /** Library version, matches package.json. */
-export var VERSION = "0.4.0";
+export var VERSION = "0.6.1";
 
 export { LasError, ERROR_CODES } from "./errors.js";
 export { openLas, LasReader } from "./LasReader.js";
@@ -16,7 +16,14 @@ export { parseCrs } from "./format/LasCrs.js";
 export { POINT_FORMATS, formatHasRgb } from "./format/PointFormats.js";
 export { decodeRecords, DEFAULT_FIELDS, FIELD_TYPES } from "./read/decodeRecords.js";
 export { makeKeep, countKept } from "./filter/filters.js";
-export { dedupe } from "./filter/dedupe.js";
+export { dedupe, dedupeSelection } from "./filter/dedupe.js";
+export { buildIndex } from "./index/grid.js";
+export { pointsInRadius, nearestPoint, pointsNearRay } from "./index/query.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 { MemorySource } from "./io/MemorySource.js";
 export { BlobSource } from "./io/BlobSource.js";
 export { NodeFileSource } from "./io/NodeFileSource.js";