DWG object values written and read

Decides what is written when a value is missing or not a number.

A value that is not a finite number (NaN, an infinity, or not a number at all) is replaced by the default, which is 0 unless the caller gives another. Finite values pass through unchanged.

const num = (v, d = 0) => (Number.isFinite(v) ? v : d);

Brings an angle into the range from 0 up to 2π before it is written.

r = a mod 2π; r + 2π when r < 0

The remainder by the 64-bit value of 2π is computed without rounding; adding 2π to a negative remainder rounds once. An angle that is not a number becomes 0.

const rad = (a) => { const t = 2 * Math.PI; let r = (+a || 0) % t; if (r < 0) r += t; return r; };

Writes an arc's center, radius and two angles.

Center and radius are written as given. The two angles go through rad(), so they are stored in [0, 2π).

ENC.ARC = (w, r) => {
  entityCommon(w, r); w.P3(r.center); w.BD(num(r.radius)); w.BT(num(r.thickness)); BEx(w, r.extrusion);
  w.BD(rad(r.startAngle)); w.BD(rad(r.endAngle));
};

Writes a line's two end points.

Start coordinates are written as doubles and end coordinates with the bit writer's default-double call against the start value. The z values are left out when both are 0. No arithmetic is done on the coordinates here.

ENC.LINE = (w, r) => {
  entityCommon(w, r);
  const a = P(r.start), b = P(r.end), flat = !a.z && !b.z;
  w.B(flat ? 1 : 0);
  w.RD(a.x); w.DD(b.x, a.x); w.RD(a.y); w.DD(b.y, a.y);
  if (!flat) { w.RD(a.z); w.DD(b.z, a.z); }
  w.BT(num(r.thickness)); BEx(w, r.extrusion);
};

Writes the vertices of a lightweight polyline.

The first vertex is written as doubles and each later one with the default-double call against the vertex before it. Bulges and widths follow as doubles. No arithmetic is done on them here.

w.RD2(num(v[0].x), num(v[0].y));
for (let k = 1; k < v.length; k++) { w.DD(num(v[k].x), num(v[k - 1].x)); w.DD(num(v[k].y), num(v[k - 1].y)); }

Writes the start and end width at a polyline vertex.

equal widths: one value, −|width|

When the start and end widths are equal and not zero, one value is written with a negative sign, the format's short form. The comparison is exact equality.

const sw = num(r.startWidth), ew = num(r.endWidth, sw);
if (sw && sw === ew) w.BD(-Math.abs(sw)); else { w.BD(sw); w.BD(ew); }

The total length of a linetype's dash pattern.

length = Σ |element length|

The stored pattern length is used when it is a finite number. Otherwise it is the sum of the absolute element lengths, added in order.

w.BD(num(r.patternLength, els.reduce((s, e) => s + Math.abs(num(e.length)), 0)));

The x-axis direction written for a block of text.

x axis = (cos θ, sin θ, 0)

A stored x axis is written as it is. Without one, the direction is Math.cos and Math.sin of the rotation.

const xa = r.xAxis ? P(r.xAxis) : { x: Math.cos(num(r.rotation)), y: Math.sin(num(r.rotation)), z: 0 };

Writes the three scale factors of a block reference in the format's compact form.

The short forms are chosen by exact equality: all three scales 1, all three equal, or x equal to 1. The values themselves are written unchanged.

function insertScale(w, s) {
  const sx = num(s?.x, 1), sy = num(s?.y, 1), sz = num(s?.z, 1);
  if (sx === 1 && sy === 1 && sz === 1) w.BB(3);
  else if (sx === sy && sx === sz) { w.BB(2); w.RD(sx); }
  else if (sx === 1) { w.BB(1); w.DD(sy, 1); w.DD(sz, 1); }
  else { w.BB(0); w.RD(sx); w.DD(sy, sx); w.DD(sz, sx); }
}

Writes a text's insertion point, height, rotation, width factor and oblique angle.

A field equal to its default (elevation 0, rotation 0, oblique 0, width factor 1) is flagged and left out, by exact comparison. A height that is not a finite number is written as 0.2.

/** TEXT data (20.4.3 R2000+), also the start of ATTRIB / ATTDEF. */
function textData(w, r) {
  const ins = P(r.insert), al = r.align ? P(r.align) : null;
  const ha = r.hAlign | 0, va = r.vAlign | 0;
  const hasAlign = !!al && (ha || va);
  const elev = num(ins.z), rot = num(r.rotation), wf = num(r.widthFactor, 1), obl = num(r.oblique), gen = r.generation | 0;
  w.RC((elev ? 0 : 1) | (hasAlign ? 0 : 2) | (obl ? 0 : 4) | (rot ? 0 : 8) | (wf !== 1 ? 0 : 0x10) | (gen ? 0 : 0x20) | (ha ? 0 : 0x40) | (va ? 0 : 0x80));
  if (elev) w.RD(elev);
  w.RD2(ins.x, ins.y);
  if (hasAlign) { w.DD(al.x, ins.x); w.DD(al.y, ins.y); }
  BEx(w, r.extrusion); w.BT(num(r.thickness));
  if (obl) w.RD(obl);
  if (rot) w.RD(rot);
  w.RD(num(r.height, 0.2));
  if (wf !== 1) w.RD(wf);
  w.TV(r.value ?? '');
  if (gen) w.BS(gen);
  if (ha) w.BS(ha);
  if (va) w.BS(va);
}

Writes the numbers kept in an extension record.

Doubles and points are written as given, with a value that is not a number written as 0. Integer values are truncated with | 0, which also wraps anything beyond 32 bits; 64-bit integers go through Math.trunc and BigInt.

case 'pt3': o.RD(+v?.x || 0); o.RD(+v?.y || 0); o.RD(+v?.z || 0); break;
case 'pt2': o.RD(+v?.x || 0); o.RD(+v?.y || 0); break;
case 'dbl': o.RD(+v || 0); break;
case 'i8': case 'bool': o.RC(v | 0); break;
case 'i16': o.RS(v | 0); break;
case 'i32': o.RL(v | 0); break;
case 'i64': o.RLL(typeof v === 'bigint' ? v : BigInt(Math.trunc(+v || 0))); break;

The 4 × 4 matrix written for a multileader's block content when the model gives none.

M = translate(l) · rotate_z(θ) · scale(s)

cos and sin of the rotation are taken once and multiplied by the x and y scales; the location fills the last column. A matrix of 16 numbers supplied with the content is written instead, unchanged.

/** 20.4.86: rotation, then scale, then translation (normal Z) — for a block content given without its matrix. */
function blockMatrix(b) {
  const s = P(b.scale, { x: 1, y: 1, z: 1 }), r = num(b.rotation), l = P(b.location);
  const cs = Math.cos(r), sn = Math.sin(r);
  return [cs * s.x, -sn * s.y, 0, l.x, sn * s.x, cs * s.y, 0, l.y, 0, 0, s.z, l.z, 0, 0, 0, 1];
}

Reads a line's two end points.

Start coordinates are read as doubles and end coordinates with the bit reader's default-double call against the start value; z is 0 when the record flags it as absent. No arithmetic is done on the values here.

const sx = r.RD(), ex = r.DD(sx), sy = r.RD(), ey = r.DD(sy);
let sz = 0, ez = 0;
if (!zzero) { sz = r.RD(); ez = r.DD(sz); }
rec.start = { x: sx, y: sy, z: sz }; rec.end = { x: ex, y: ey, z: ez };

Reads the vertices of a lightweight polyline.

The first vertex is read as doubles and each later one with the default-double call against the vertex before it. Values are stored as read.

let x = r.RD(), y = r.RD();
vs[0] = { x, y, bulge: 0, startWidth: 0, endWidth: 0 };
for (let i = 1; i < n; i++) { x = r.DD(x); y = r.DD(y); vs[i] = { x, y, bulge: 0, startWidth: 0, endWidth: 0 }; }

Turns the north angle of a version 1 geolocation object into a direction vector.

north = (sin a, cos a)

Version 1 objects store north as an angle in radians clockwise from (0, 1), which is turned into a vector with Math.sin and Math.cos. Later versions store the vector, and it is read as it is.

rec.north = { x: Math.sin(a), y: Math.cos(a) };