Drawn floors: outline, openings and quantities

The signed area of a polygon.

A = ½ Σ (xᵢ yᵢ₊₁ − yᵢ xᵢ₊₁)

The sum uses the corners' own plan coordinates, not coordinates measured from the first corner, so its terms grow with the floor's distance from the story's origin and cancel in the sum.

const area = (p) => { let s = 0; for (let i = 0; i < p.length; i++) { const a = p[i], b = p[(i + 1) % p.length]; s += a[0] * b[1] - a[1] * b[0]; } return s / 2; };

The total length of the outline's edges.

P = Σ |pᵢ₊₁ − pᵢ|

A 64-bit sum of Math.hypot edge lengths added in order.

const perim = (p) => p.reduce((s, a, i) => { const b = p[(i + 1) % p.length]; return s + Math.hypot(b[0] - a[0], b[1] - a[1]); }, 0);

A yes or no on whether two segments properly cross.

cross when o(a, b, c) × o(a, b, d) < 0 and o(c, d, a) × o(c, d, b) < 0

Each orientation is the sign of a 64-bit cross product with no tolerance and no exact arithmetic, so a nearly collinear case is decided by rounding. A product of exactly zero, an end touching the other segment, counts as not crossing.

function crosses(a, b, c, d) {
  const o = (p, q, r) => Math.sign((q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]));
  return o(a, b, c) * o(a, b, d) < 0 && o(c, d, a) * o(c, d, b) < 0;
}

Refuses an outline with fewer than 3 corners, one that crosses itself, or one with almost no area.

refuse when |A| < 10 000 mm²

The area limit is 10 000 mm², an absolute value. Self-crossing is tested on every pair of edges that are not neighbors.

export function polyProblem(points) {
  if (!points || points.length < 3) return 'model.err.fl.shape';
  if (selfCrossing(points) || Math.abs(area(points)) < 10000) return 'model.err.fl.shape';   // under 0.01 m²
  return null;
}

The even-odd test used to check that an opening lies in its floor.

A ray is cast along x and crossings are counted; the crossing's x comes from one division by the edge's height, which is never zero for an edge the test accepts. No tolerance: a point on the boundary can fall either way.

function inPoly(p, poly) {
  let c = false;
  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
    const a = poly[i], b = poly[j];
    if ((a[1] > p[1]) !== (b[1] > p[1]) && p[0] < (b[0] - a[0]) * (p[1] - a[1]) / (b[1] - a[1]) + a[0]) c = !c;
  }
  return c;
}

The outline's points written as text in the file's length unit, and read back.

text = round(x ÷ unit, 3) , round(y ÷ unit, 3)

Each coordinate is converted to the file's unit and rounded to 3 decimals. In a file whose unit is the millimeter that is 0.001 mm; in a file in meters it is 1 mm. The floor's outline, and the area reported for it, are rebuilt from this text.

const ptsText = (p) => p.map((q) => round(q[0], 3) + ',' + round(q[1], 3)).join(';');
const ptsOf = (s) => String(s || '').split(';').map((x) => x.split(',').map(Number)).filter((q) => q.length === 2 && q.every(Number.isFinite));

The slab quantities, gross and net of the openings.

net area = A − Σ |hole|; volume = area × thickness

Hole areas are made positive and added, then subtracted once from the gross area; volumes are that area times the thickness. The model writer stores areas and volumes rounded to 6 decimals of a square or cubic meter.

const hArea = holes.reduce((s, h) => s + Math.abs(area(h.points)), 0), A = Math.abs(area(pts));
w.upsertQto(f.id, 'Qto_SlabBaseQuantities', [['Width', 'length', f.thickness], ['Perimeter', 'length', perim(pts)], ['GrossArea', 'area', A], ['NetArea', 'area', A - hArea], ['GrossVolume', 'volume', A * f.thickness], ['NetVolume', 'volume', (A - hArea) * f.thickness]]);