Resources Numerical accuracy Calculation policy
Writes one NC file per part mark for the shop's machines: the header, the outer contours and the holes.
The part's 64-bit lengths, positions and section sizes are written as text with two decimals, and the skew cut angles with five. Values under 0.005 are written as 0.00. Contour points are plain sums and differences of the part's stored sizes; mitre contours take their end points from the cut plane.
8 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.
Tests bin/test-detailcraft.mjs
How each length and coordinate is written.
text = toFixed(2); |v| < 0.005 → 0.00
Two decimals from toFixed, which rounds the 64-bit value, so a number with a 5 in the third decimal goes up or down depending on its binary value.
const f2 = (v) => (Math.abs(v) < 0.005 ? 0 : v).toFixed(2);The length, section sizes, weight and paint surface written in the header.
plates: weight = t × steel density ÷ 1000 (kg/m²); others: paint surface = perimeter ÷ 1000
Sizes are the part's stored profile values. A plate's weight line is its thickness in millimeters times the steel density divided by 1000; its paint surface is the constant 2.
const per = p.perimeter / 1000;
const nums = isPlate ? [L, p.b, 0, 0, p.t, 0, p.t * STEEL_KG_PER_M3 / 1000, 2]
: k === 'L' ? [L, p.b, p.b, p.t, p.t, 0, p.mass, per]
: k === 'RHS' ? [L, p.h, p.b, p.t, p.t, p.ro, p.mass, per]
: k === 'CHS' ? [L, p.D, p.D, p.t, p.t, 0, p.mass, per]
: [L, p.d, p.bf, p.tf, p.tw, p.r, p.mass, per];
for (const n of nums) lines.push(pad(f2(n)));The web and flange cut angles written in the header for a mitred I-shape.
web = −atan(kv) × 180 ÷ π; flange = atan(ku) × 180 ÷ π
Math.atan of the cut plane's slope, written with five decimals of a degree.
const ang = (c, web) => (!c ? 0 : (web ? -1 : 1) * Math.atan(web ? c.kv : c.ku) * 180 / Math.PI);
const skew = ec ? [ang(ec.start, true), ang(ec.end, true), ang(ec.start, false), ang(ec.end, false)] : [0, 0, 0, 0];
for (const a of skew) lines.push(pad((Math.abs(a) < 0.000005 ? 0 : a).toFixed(5)));The outline of the web face, notched for copes or ending on the mitre cut.
cope corners at (length, depth), (L − length, depth), (L − length, h − depth) …
Corner points are the cope's stored length and depth and differences from L and h. Nothing is computed beyond one subtraction per coordinate.
/**
* The web's outline with copes notched, y up from the side at v = −h/2 (counter-clockwise). x0(y) / x1(y): where the start / end
* face is at height y (square ends: 0 and L; a mitre: its cut face at the web's middle).
*/
function webOutline(L, h, copes, x0 = () => 0, x1 = () => L) {
const cs = (end, side) => copes.find((c) => c.end === end && c.side === side);
const pts = [];
const bs = cs('start', 'bottom'), be = cs('end', 'bottom'), te = cs('end', 'top'), ts = cs('start', 'top');
if (bs) pts.push([0, bs.depth], [bs.length, bs.depth], [bs.length, 0]); else pts.push([x0(0), 0]);
if (be) pts.push([L - be.length, 0], [L - be.length, be.depth], [L, be.depth]); else pts.push([x1(0), 0]);
if (te) pts.push([L, h - te.depth], [L - te.length, h - te.depth], [L - te.length, h]); else pts.push([x1(h), h]);
if (ts) pts.push([ts.length, h], [ts.length, h - ts.depth], [0, h - ts.depth]); else pts.push([x0(h), h]);
return pts;
}Where a flange starts and ends once the copes on its side are cut.
x0 = cope length when cope depth ≥ t, else 0
A cope shortens the flange only when its depth is at least the flange thickness; the comparison has no tolerance.
/** [x0, x1] of a flange (or wall) of thickness t after the copes on its side. */
function flangeSpan(L, copes, side, t) {
const a = copes.find((c) => c.end === 'start' && c.side === side), b = copes.find((c) => c.end === 'end' && c.side === side);
return [a && a.depth >= t ? a.length : 0, b && b.depth >= t ? L - b.length : L];
}The end points of the web and flange contours where a plane cut crosses them.
x = x0 + ku·u + kv·v at the web's middle plane and at each flange's outside face
Each end point is one evaluation of the cut plane. The web's is taken at u = 0 and each flange's at its outside face, as the file header describes.
ak('v', webOutline(L, h, copes, (y) => endX(part, 'start', 0, y - h / 2), (y) => endX(part, 'end', 0, y - h / 2)));
// each flange's outside face: y = w/2 − u from the behind edge (the copes' notches are square, as before)
for (const [face, side, v] of [['o', 'top', h / 2], ['u', 'bottom', -h / 2]]) {
const [x0, x1] = flangeSpan(L, copes, side, tf), sq0 = x0 > 0, sq1 = x1 < L;
const at = (end, y) => endX(part, end, w / 2 - y, v);
ak(face, [[sq0 ? x0 : at('start', 0), 0], [sq1 ? x1 : at('end', 0), 0], [sq1 ? x1 : at('end', w), w], [sq0 ? x0 : at('start', w), w]]);The x and y of each hole in the file's own face coordinates.
web: y = offset + d ÷ 2; flange of an I: y = bf ÷ 2 − offset; plate: y = offset + b ÷ 2
One addition or subtraction turns the stored offset from the section's center into the distance from the face's reference edge.
const holes = part.holes.flatMap((hh) => {
if (isPlate) return [['v', hh.x, hh.y + p.b / 2, hh.d]];
if (k === 'C') {
if (hh.face === 'web') return [['v', hh.x, p.d / 2 - hh.y, hh.d]];
return [[hh.face === 'top' ? 'u' : 'o', hh.x, hh.y + p.bf / 2, hh.d]]; // from the back of the web
}
if (k === 'RHS') {
if (hh.face === 'web') return [['v', hh.x, hh.y + p.h / 2, hh.d], ['h', hh.x, hh.y + p.h / 2, hh.d]];
return [[hh.face === 'top' ? 'o' : 'u', hh.x, p.b / 2 - hh.y, hh.d]];
}
if (k === 'L') return [hh.face === 'web' ? ['u', hh.x, hh.y + p.b / 2, hh.d] : ['v', hh.x, hh.y + p.b / 2, hh.d]];
if (hh.face === 'web') return [['v', hh.x, hh.y + p.d / 2, hh.d]];
return [[hh.face === 'top' ? 'o' : 'u', hh.x, p.bf / 2 - hh.y, hh.d]]; // from the behind (+u) edge
});The header values and block rows read from an NC file.
Each field is turned into a number with Number, so what comes back is the two-decimal text's value, not the model's.
/** A strict reader for what writeNc1 writes (and the common subset others write): { header, blocks }. */
export function readNc1(text) {
const lines = text.split(/\r?\n/).filter((l) => l.trim() !== '' && !l.startsWith('**'));
if (lines[0] !== 'ST') throw new Error(t('nc.read.start'));
const header = [];
let i = 1;
while (i < lines.length && !/^[A-Z]{2}$/.test(lines[i])) header.push(lines[i++].trim());
if (header.length < 20) throw new Error(t('nc.read.fields', { n: header.length, min: 20 }));
const h = {
order: header[0], drawing: header[1], phase: header[2], piece: header[3], steel: header[4], quantity: Number(header[5]),
profile: header[6], code: header[7], length: Number(header[8]), height: Number(header[9]), flangeWidth: Number(header[10]),
flangeThickness: Number(header[11]), webThickness: Number(header[12]), radius: Number(header[13]), kgPerM: Number(header[14]), paintPerM: Number(header[15]),
};
const blocks = [];
let cur = null;
for (; i < lines.length; i++) {
const l = lines[i];
if (/^[A-Z]{2}$/.test(l)) { if (l === 'EN') { blocks.push({ type: 'EN', rows: [] }); cur = null; continue; } cur = { type: l, rows: [] }; blocks.push(cur); continue; }
if (!cur) throw new Error(t('nc.read.outside', { line: l }));
const m = l.match(/^\s+([vohu])\s+(.*)$/);
if (!m) throw new Error(t('nc.read.bad-line', { block: cur.type, line: l }));
const nums = m[2].trim().split(/\s+/).map((s) => Number(s.replace(/[a-z]$/, '')));
if (nums.some((n) => !Number.isFinite(n))) throw new Error(t('nc.read.nan', { block: cur.type, line: l }));
cur.rows.push({ face: m[1], nums });
}
if (!blocks.length || blocks[blocks.length - 1].type !== 'EN') throw new Error(t('nc.read.no-en'));
return { header: h, blocks };
}The arithmetic is 64-bit, but the method or the data sets the accuracy: a solver tolerance, a mesh, a step size, a datum shift, a table. The limit is stated where the result is shown.