Point cloud positions and read-in values

How the precision is kept

Positions are read and decoded in 64-bit, thinned in Float64Arrays, and then stored as 32-bit offsets from a whole-unit origin. Everything that later reads a point back (pointAt, slices, snapping) therefore works with 32-bit offsets, while the origin and the size of the cloud stay 64-bit.

Open item. Keep the offsets in 64-bit (or split the cloud into tiles with their own origin) where a distance or a position taken from the points has to be better than the 32-bit step.

6 calculations in 1 source file. The code is read from the released app when this page loads. It is the calculation people run, not a copy kept for this page.

const origin = box.min.map((v) => Math.floor(v));
const pos = new Float32Array(n * 3);
for (let k = 0; k < n; k++) { pos[k * 3] = keep.x[k] - origin[0]; pos[k * 3 + 1] = keep.y[k] - origin[1]; pos[k * 3 + 2] = keep.z[k] - origin[2]; }

export const pointAt = (cloud, i) => [cloud.pos[i * 3] + cloud.origin[0], cloud.pos[i * 3 + 1] + cloud.origin[1], cloud.pos[i * 3 + 2] + cloud.origin[2]];

export function sliceOf(cloud, { axis = 'z', at, thick }) {
  const a = AX[axis] ?? 2, c = at - cloud.origin[a], h = Math.abs(thick) / 2;
  const out = [];
  for (let k = 0; k < cloud.n; k++) if (Math.abs(cloud.pos[k * 3 + a] - c) <= h) out.push(k);
  return Uint32Array.from(out);
}

/** Intensities as read → 0–65535: whole numbers in that range stay as they are; others are stretched from lowest to highest. */
function intensities(f, n) {
  let lo = Infinity, hi = -Infinity, whole = true;
  for (let k = 0; k < n; k++) { const v = f[k]; if (v < lo) lo = v; if (v > hi) hi = v; if (whole && v !== Math.round(v)) whole = false; }
  const out = new Uint16Array(n);
  if (whole && lo >= 0 && hi <= 65535) { for (let k = 0; k < n; k++) out[k] = f[k]; return out; }
  const span = hi - lo || 1;
  for (let k = 0; k < n; k++) out[k] = Math.round((f[k] - lo) / span * 65535);
  return out;
}

function recordDecoder(fmt, L, scale, offset) {
  const [sx, sy, sz] = scale, [ox, oy, oz] = offset, ext = fmt >= 6, ca = COLOR_AT[fmt] ?? -1;
  const colorOk = ca >= 0 && ca + 6 <= L;
  return (dv, o, keep, box, classCounts) => {
    const x = dv.getInt32(o, true) * sx + ox, y = dv.getInt32(o + 4, true) * sy + oy, z = dv.getInt32(o + 8, true) * sz + oz;
    const c = ext ? dv.getUint8(o + 16) : dv.getUint8(o + 15) & 31;
    box.add(x, y, z);
    classCounts.set(c, (classCounts.get(c) || 0) + 1);
    if (!keep.want()) return;
    const i = dv.getUint16(o + 12, true);
    if (colorOk) keep.put(x, y, z, dv.getUint16(o + ca, true), dv.getUint16(o + ca + 2, true), dv.getUint16(o + ca + 4, true), i, c);
    else keep.put(x, y, z, 0, 0, 0, i, c);
  };
}

export function cloudSummary(cloud) {
  const classes = [...cloud.classCounts.entries()].sort((a, b) => a[0] - b[0]).map(([c, n]) => ({ c, name: className(c) || t('pc.class.other', { c }), n }));
  return { read: cloud.read, kept: cloud.n, size: [0, 1, 2].map((a) => cloud.max[a] - cloud.min[a]), classes };
}

In detail

Method

LAS integer coordinates are scaled and offset in 64-bit; the kept points are stored as Float32Array offsets from origin = floor of the lowest corner of everything read.

Number types

Keeper holds x, y, z in Float64Array; the stored cloud holds pos as Float32Array(3n) relative to origin (64-bit numbers); intensities are read into a Float32Array and finish to Uint16; the bounds (min, max) are 64-bit numbers over every point read, not only the kept ones.

Tolerances

None in these functions; sliceOf compares with <= against half the thickness and the nearest-point search in PlanGrid uses the radius as given.

Limits

A kept position is only as exact as a 32-bit number: for an offset between 512 and 1024 units the step is 2^-14 unit (about 6.1e-5), so a point can move by up to half of that. Larger clouds, measured in a far corner of the box, have a larger step.

Approach: 32-bit step, flagged

One step stores or exchanges 32-bit values that reach a number a person reads. It is listed here with its open item, and the step is either moved to 64-bit or the app will warn where the number is read.

Every policy that takes this approach