Registered scans written as LAS and E57

How the precision is kept

Each point is read from the cloud's position array, which holds 32-bit offsets from the scan's origin. The origin is added and the 4 × 4 registration matrix applied in 64-bit arithmetic. LAS then stores each coordinate as a 32-bit integer multiple of a scale between 0.0001 and 1; E57 stores 64-bit doubles. Either way the exported coordinates start from a 32-bit offset.

Open item. Carry each scan's coordinates in 64-bit from the source file to the writers, so exported LAS and E57 points do not start from 32-bit offsets.

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 pt = (c, M, i, out) => {
  const x = c.pos[i * 3] + c.origin[0], y = c.pos[i * 3 + 1] + c.origin[1], z = c.pos[i * 3 + 2] + c.origin[2];
  out[0] = M[0] * x + M[1] * y + M[2] * z + M[3]; out[1] = M[4] * x + M[5] * y + M[6] * z + M[7]; out[2] = M[8] * x + M[9] * y + M[10] * z + M[11];
};

function bounds(items) {
  const lo = [Infinity, Infinity, Infinity], hi = [-Infinity, -Infinity, -Infinity], p = [0, 0, 0];
  let n = 0;
  for (const { cloud: c, M } of items) for (let i = 0; i < c.n; i++) {
    pt(c, M, i, p); n++;
    for (let a = 0; a < 3; a++) { if (p[a] < lo[a]) lo[a] = p[a]; if (p[a] > hi[a]) hi[a] = p[a]; }
  }
  if (!n) { lo.fill(0); hi.fill(0); }
  return { lo, hi, n };
}

const ext = Math.max(hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]);
const scale = [0.0001, 0.001, 0.01, 0.1, 1].find((s) => ext / s < 2e9) ?? 1;
const offset = lo.map((v) => Math.floor(v / 100) * 100);   // whole hundreds: a round offset keeps the stored integers small

const o = used * rec;
for (let a = 0; a < 3; a++) dv.setInt32(o + a * 4, Math.round((p[a] - offset[a]) / scale), true);

const i = i0 + k;
pt(c, M, i, p);
for (let a = 0; a < 3; a++) { dv.setFloat64(starts[a] + k * 8, p[a], true); if (p[a] < lo[a]) lo[a] = p[a]; if (p[a] > hi[a]) hi[a] = p[a]; }

const f = (v) => (Object.is(v, -0) ? '0' : String(v));

In detail

Method

p = M × (position + origin), row-major 4 × 4 with the last row left out. LAS: X = round((p − offset) ÷ scale), offset = the minimum rounded down to a whole hundred, scale = the finest of 0.0001, 0.001, 0.01, 0.1, 1 with extent ÷ scale below 2e9. E57 1.0: cartesian x, y, z as doubles in data packets, pages of 1024 bytes with a CRC-32C.

Number types

Float32Array positions (pointcloud.js loadCloud), 64-bit origin and matrix arithmetic, signed 32-bit integers in LAS, 64-bit doubles in E57.

Limits

A 32-bit offset holds about 7 significant digits of the distance from the scan's origin. LAS coordinates are rounded to the chosen scale. Units are the files' own; nothing is converted.

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