Numbers written into the IFC model

Rounds a number to a given count of decimals before it is written to the file.

round(v, d) = Math.round(v × 10ᵈ) ÷ 10ᵈ, d = 6 by default

The value is multiplied by 10^d, rounded to a whole number and divided again, so the result is the nearest 64-bit number to a d-decimal value; negative zero is returned as 0. Every length, offset and seed point the building tools store passes through it with d = 6, so the stored value keeps 6 decimals of the file unit rather than all its 64-bit digits.

export const round = (v, d = 6) => { const r = Math.round(v * 10 ** d) / 10 ** d; return Object.is(r, -0) ? 0 : r; };

The origin and X direction of an element's placement from a point in millimeters and an angle in degrees.

location = round(mm ÷ unit, 6); X direction = (round(cos θ, 12), round(sin θ, 12), 0), θ = degrees × π ÷ 180

The three coordinates are divided by the file unit and rounded to 6 decimals. The angle arrives in degrees and is converted back to radians, then its cosine and sine are rounded to 12 decimals, so a stored direction is within 5e-13 of a unit vector component.

// ---- placements ----
axis3(x, y, z, angDeg) {
  const a = (angDeg || 0) * D2R;
  const loc = this.point3(round(this.u(x)), round(this.u(y)), round(this.u(z)));
  return this.make('IFCAXIS2PLACEMENT3D', this.H(loc), this.H(this.dir(0, 0, 1)), this.H(this.dir(round(Math.cos(a), 12), round(Math.sin(a), 12), 0)));
}

A 2D point of a profile, axis or outline as it is stored.

(round(x ÷ unit, 6), round(y ÷ unit, 6))

Each coordinate is divided by the file unit and rounded to 6 decimals. Every wall outline, slab outline and site outline point is written this way.

// ---- geometry (mm in) ----
point2mm(x, y) { return this.point2(round(this.u(x)), round(this.u(y))); }

The start height and depth of a swept solid.

position z = round(z₀ ÷ unit, 6); depth = round(depth ÷ unit, 6)

Base height and depth are each rounded to 6 decimals of the file unit. The direction is written as given, without rounding.

extrude(profile, z0, depth, dir = [0, 0, 1]) {
  const pos = this.make('IFCAXIS2PLACEMENT3D', this.H(this.point3(0, 0, round(this.u(z0)))), null, null);
  return this.make('IFCEXTRUDEDAREASOLID', this.H(profile), this.H(pos), this.H(this.dir(...dir)), round(this.u(depth)));
}

A placement with its own Z and X directions, used for sloped parts.

The origin is rounded to 6 decimals of the file unit and each component of the two direction vectors to 12 decimals. The function does not normalize the vectors or check that they are perpendicular; it stores what the caller passes.

/** An IfcAxis2Placement3D at o (mm) with its Z along zDir and X along xDir (unit vectors). */
axisFrame(o, zDir, xDir) {
  const r = (v) => round(v, 12);
  return this.make('IFCAXIS2PLACEMENT3D', this.H(this.point3(round(this.u(o[0])), round(this.u(o[1])), round(this.u(o[2])))), this.H(this.dir(r(zDir[0]), r(zDir[1]), r(zDir[2]))), this.H(this.dir(r(xDir[0]), r(xDir[1]), r(xDir[2]))));
}

Converts a length, area or volume in millimeter units to the value stored in a quantity set.

length = round(mm ÷ unit, 6); area = round(mm² ÷ 10⁶, 6); volume = round(mm³ ÷ 10⁹, 6)

Lengths use the file's length unit. Areas are divided by 1e6 and volumes by 1e9, which gives m² and m³ whatever the file's length unit is, and both are rounded to 6 decimals: 1 mm² for an area and 1000 mm³ for a volume. Counts are stored unchanged.

const conv = (kind, v) => kind === 'length' ? round(this.u(v), 6) : kind === 'area' ? round(v / 1e6, 6) : kind === 'volume' ? round(v / 1e9, 6) : v;   // areas m², volumes m³ (the project's SI units)

Converts a placement matrix from file units to millimeters.

translation × unit in mm; rotation part unchanged

Only the three translation entries are multiplied by the unit factor; one 64-bit multiplication each.

/** A world matrix in file units → mm (translation scaled). */
export function scaleT(M, unitMm) {
  const o = M.slice();
  o[12] *= unitMm; o[13] *= unitMm; o[14] *= unitMm;
  return o;
}

Where an element sits in the axes of its level or site.

M = P⁻¹ × C

Both world matrices are read from the IFC library, scaled to millimeters, and combined with the general 4×4 inverse and product in ifc-util.js. For a model far from the origin the translation of the result is a difference of two large coordinates.

/** A placement's matrix relative to another one's (mm): where `child` sits in `parent`'s axes. */
relMatrix(parentLp, childLp) {
  const P = scaleT(this.api.GetWorldTransformMatrix(this.mid, parentLp), this.unitMm), C = scaleT(this.api.GetWorldTransformMatrix(this.mid, childLp), this.unitMm);
  return mul4(inv4(P), C);
}