IFC geometry handed to the apps

How the precision is kept

The placement matrices are 64-bit: the file's placement, a scale by the length unit, an axis turn and a shift to the first element's center. The vertex data itself is returned as the mesh's interleaved Float32Array, in the file's length unit. Code that measures from these vertices (ifc-util.js productTriangles reads them) starts from 32-bit positions.

Open item. Offer the positions in a Float64Array beside the 32-bit buffer, and have measuring code read that one.

4 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.

GetGeometry(mid, gid) {
  const mesh = this.geometry(mid).mesh(gid);
  const { vertices, indices } = mesh ? mesh.interleaved() : { vertices: new Float32Array(0), indices: new Uint32Array(0) };
  return {
    GetVertexData: () => vertices, GetVertexDataSize: () => vertices.length,
    GetIndexData: () => indices, GetIndexDataSize: () => indices.length,
    delete() {},
  };
}

flatMesh(mid, id) {
  const geo = this.geometry(mid);
  const C = this.ensureC(mid);
  const pcs = geo.pieces(id);
  return {
    expressID: id,
    geometries: new Vector(pcs.map((p) => ({ color: p.color, flatTransformation: mul(C, this.toYupMetres(mid, p.matrix)), geometryExpressID: p.geomId }))),
    delete() {},
  };
}

ensureC(mid) {
  const m = this.m(mid);
  if (m.C) return m.C;
  m.C = I4();
  if (!m.toOrigin) return m.C;
  const geo = this.geometry(mid);
  for (const p of geo.products()) {
    const pcs = geo.pieces(p);
    if (!pcs.length) continue;
    // move the first element's centre to the origin (metres, Y up), as models far from it lose float precision
    const b = geo.mesh(pcs[0].geomId).bounds();
    if (!b) continue;
    const c = [(b.min[0] + b.max[0]) / 2, (b.min[1] + b.max[1]) / 2, (b.min[2] + b.max[2]) / 2];
    const w = mul(this.toYupMetres(mid, pcs[0].matrix), [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, c[0], c[1], c[2], 1]);
    m.C = translation(-w[12], -w[13], -w[14]);
    break;
  }
  return m.C;
}

toYupMetres(mid, matrix) { const u = this.geometry(mid).g.lengthUnit; return mul(YUP, mul(scaling(u), matrix)); }

In detail

Method

flat transformation = C × Y-up × scale(length unit) × placement. C moves the center of the first element's box to the origin when the model was opened with COORDINATE_TO_ORIGIN, or is the matrix given by the caller.

Number types

Matrices as arrays of sixteen 64-bit numbers; vertices as a Float32Array of x y z nx ny nz; indices as a Uint32Array.

Limits

The 32-bit rounding applies to each geometry's coordinates before its placement matrix, so a geometry stored far from its own origin loses more than one stored near it.

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