v0.6.0: ruimtes (verfemmer: functie, netto m², vloerafwerking, FIBO-wandpanelen, eigen verfkleur, vals plafond, ruimtestaat op de PDF), inrichting (sanitair, keuken, kookeiland, kasten, bed, zithoek, boiler; slepen met snappen op het wandvlak, draaien, kosten), kozijnen met deurrichting, glasdeur en schuifdeuren (inbouw/opbouw, deuren open in de loopmodus) plus dagkanten, gevel stucwerk en wandstukken splitsen met eigen gevel, dak over de hele woning met overkapping, geschilderd plafond, model Amstel als nieuw ontwerp, kosten en prijzen uit kosten/intern.csv en kosten/leveranciers.csv (CostCsv); easter egg verwijderd; overbodige comments opgeschoond (alleen copyright, uitzonderingen en valkuilen blijven)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

js/core/geometry.js

@@ -4,20 +4,8 @@
  * Alle rechten voorbehouden. Gebruik uitsluitend met schriftelijke toestemming.
  * Zie LICENTIE.md.
  */
-// ============================================================
-// core/geometry.js — gedeelde, pure math. Geen DOM, geen THREE-afhankelijkheid
-// behalve shapeAreaWithHoles (die werkt met elk object dat .getPoints()/.holes
-// heeft, dus ook met THREE.Shape). Plain <script> (geen module), zodat dit
-// ook werkt bij rechtstreeks openen van index.html (file://) — daar breken
-// ES-module-imports door browser-CORS.
-//
-// Wordt geladen VOOR wall.js en floor.js: de functies hieronder zijn dus
-// gewoon globaal beschikbaar in beide, zonder duplicatie.
-// ============================================================
+// Plain script, geen ES-module: imports breken bij file:// (CORS).
 
-// Regelwerk-verdeling (h.o.h.): bepaalt hoeveel balken/stijlen er in een
-// gegeven overspanning passen, gegeven een minimale/maximale hart-op-hart-
-// afstand. Gebruikt door wand-stijlen EN vloerbalken (zelfde algoritme).
 function calculateSegmentPositions(spanWidth, minSp, maxSp) {
   if (spanWidth <= 0) return [];
   let numBays = Math.ceil(spanWidth / maxSp);
@@ -35,7 +23,6 @@ function calculateSegmentPositions(spanWidth, minSp, maxSp) {
   return positions;
 }
 
-// Oppervlakte van een simpele polygon (shoelace-formule).
 function polygonArea(points) {
   let area = 0;
   for (let i = 0; i < points.length; i++) {
@@ -46,11 +33,7 @@ function polygonArea(points) {
   return Math.abs(area) / 2;
 }
 
-// Sutherland-Hodgman clip van een (convexe) polygon tegen een horizontale
-// halfvlak-grens. Gebruikt om bijv. de wand-omtrek (het schuine trapezium) te
-// knippen tot losse horizontale banen voor het vochtdoek.
 function clipPolygonYLE(points, yLimit) {
-  // Houdt het deel met y <= yLimit
   const result = [];
   for (let i = 0; i < points.length; i++) {
     const cur = points[i];
@@ -71,7 +54,6 @@ function clipPolygonYLE(points, yLimit) {
   return result;
 }
 function clipPolygonYGE(points, yLimit) {
-  // Houdt het deel met y >= yLimit
   const result = [];
   for (let i = 0; i < points.length; i++) {
     const cur = points[i];
@@ -92,26 +74,17 @@ function clipPolygonYGE(points, yLimit) {
   return result;
 }
 
-// Oppervlakte van een THREE.Shape inclusief aftrek van zijn holes.
 function shapeAreaWithHoles(shape) {
   let area = polygonArea(shape.getPoints());
   (shape.holes || []).forEach(hole => { area -= polygonArea(hole.getPoints()); });
   return area;
 }
 
-// Simpele euclidische afstand — gebruikt door floor.js voor de
-// cirkel-overlapcheck (2D, dus geen 1D-ankerlogica zoals bij wand-openingen).
 function dist2D(a, b) {
   return Math.hypot(a.x - b.x, a.y - b.y);
 }
 
-// Zaagplan: verdeelt stukken (lengtes in mm) over handelslengtes met zo min
-// mogelijk snijverlies. Stukken langer dan de langste handelslengte worden
-// eerst opgeknipt (las/stuik in het werk). Daarna best-fit-decreasing: elk
-// stuk gaat in de staaf waar het het krapst past; tot slot krijgt elke staaf
-// de kortste handelslengte waar zijn stukken nog in passen.
-// Resultaat: [{ stock, cuts: [lengtes], used, waste }]. Zaagsnede-breedte
-// wordt verwaarloosd.
+// Zaagsnede-breedte wordt verwaarloosd.
 function planStockCutting(pieceLengths, stockLengths) {
   const stocks = stockLengths.slice().sort((a, b) => a - b);
   const maxStock = stocks[stocks.length - 1];
@@ -142,7 +115,6 @@ function planStockCutting(pieceLengths, stockLengths) {
   return bars;
 }
 
-// Samenvatting van een zaagplan: aantal staven per handelslengte + totalen.
 function summarizeStockPlan(bars) {
   const byStock = new Map();
   bars.forEach(b => byStock.set(b.stock, (byStock.get(b.stock) || 0) + 1));
@@ -153,25 +125,8 @@ function summarizeStockPlan(bars) {
   };
 }
 
-// Verticale strook [x0, x1] van y = yBottom tot een (evt. schuine, lineaire)
-// bovenrand topYAt(x), MIN een set uitsparingen ({ x0, x1, y0, y1, y1r? }):
-// rechthoeken, of met y1r een schuine bovenkant (lineair van (x0, y1) naar
-// (x1, y1r); schuin bovenin mag, onderin niet). Uitsparingen die over de
-// rand van de strook vallen worden een echte inkeping in de omtrek (i.p.v.
-// een gat dat net binnen de rand wordt afgekapt — dat liet een haarfijn
-// reepje materiaal met zichtbare randlijnen door de opening lopen). Een
-// uitsparing over de volle breedte splitst de strook in losse delen; een
-// uitsparing tot in de (schuine) bovenrand wordt een inkeping in de bovenrand.
-// opts (optioneel):
-//   yCap    — vlakke bovengrens (bijv. bovenkant van een vochtdoek-baan).
-//   extraXs — knikpunten van topYAt (bijv. waar de daklijn yCap kruist), zodat
-//             de bovenrand tussen twee hoekpunten steeds lineair is.
-// Werkwijze: de strook wordt in kolommen geknipt (op alle x-randen, knikken
-// en snijpunten van de lijnen), zodat binnen een kolom elke lijn (onderkant,
-// onder-/bovenkant uitsparing, bovenrand) lineair is en ze elkaar niet
-// kruisen; de cellen tussen twee lijnen zijn vol of leeg, en de randen
-// tussen vol en leeg worden tot lussen aaneengeregen.
-// Resultaat: [{ outer: [{x,y}...] (CCW), holes: [[{x,y}...] (CW)] }].
+// Een uitsparing over de rand wordt een inkeping, geen afgekapt gat (dat liet een haarfijn
+// reepje materiaal met randlijnen door de opening lopen). Schuin (y1r) alleen bovenin.
 function columnMinusRects(x0, x1, yBottom, topYAt, rects, opts) {
   const eps = 1e-9;
   const yCap = (opts && opts.yCap !== undefined) ? opts.yCap : Infinity;
@@ -186,14 +141,12 @@ function columnMinusRects(x0, x1, yBottom, topYAt, rects, opts) {
     });
   const inRect = (x, y) => rs.some(r => x > r.x0 && x < r.x1 && y > r.y0 && y < r.topAt(x));
 
-  // Lijnen (ongeklemd); geklemd tussen yBottom en de bovenrand.
   const raw = [() => yBottom, top];
   rs.forEach(r => raw.push(() => r.y0, r.topAt));
   const clamp = (f) => (x) => Math.min(top(x), Math.max(yBottom, f(x)));
   const lines = raw.map(clamp);
 
   let xs = uniq([x0, x1, ...((opts && opts.extraXs) || []).filter(x => x > x0 + eps && x < x1 - eps), ...rs.flatMap(r => [r.x0, r.x1])]);
-  // Snijpunten van de lijnen (ook met de bovenrand/onderkant) als extra kolomranden.
   const cuts = [];
   for (let i = 0; i < xs.length - 1; i++) {
     const a = xs[i], b = xs[i + 1];
@@ -206,7 +159,6 @@ function columnMinusRects(x0, x1, yBottom, topYAt, rects, opts) {
   }
   xs = uniq(xs.concat(cuts));
 
-  // Per kolom: cellen tussen opeenvolgende (verschillende) lijnen.
   const cols = [];
   for (let i = 0; i < xs.length - 1; i++) {
     const a = xs[i], b = xs[i + 1], m = (a + b) / 2;
@@ -222,27 +174,24 @@ function columnMinusRects(x0, x1, yBottom, topYAt, rects, opts) {
     cols.push({ a, b, cells });
   }
 
-  // Hoekpunten gedeeld via een register (bijna-gelijke punten = hetzelfde punt).
   const verts = [];
   const vid = (x, y) => {
     let k = verts.findIndex(v => Math.abs(v.x - x) < 1e-7 && Math.abs(v.y - y) < 1e-7);
     if (k < 0) { k = verts.length; verts.push({ x, y }); }
     return k;
   };
-  const edges = new Map(); // van -> [naar, ...]
+  const edges = new Map();
   const addEdge = (p, q) => {
     const a = vid(p.x, p.y), b = vid(q.x, q.y);
     if (a === b) return;
     if (!edges.has(a)) edges.set(a, []);
     edges.get(a).push(b);
   };
-  // Onder-/bovenranden binnen een kolom (CCW: onder naar rechts, boven naar links).
   cols.forEach(col => col.cells.forEach((c, k) => {
     if (!c.filled) return;
     if (!(k > 0 && col.cells[k - 1].filled && col.cells[k - 1].hi === c.lo)) addEdge({ x: col.a, y: c.lo.a }, { x: col.b, y: c.lo.b });
     if (!(k < col.cells.length - 1 && col.cells[k + 1].filled && col.cells[k + 1].lo === c.hi)) addEdge({ x: col.b, y: c.hi.b }, { x: col.a, y: c.hi.a });
   }));
-  // Verticale randen op elke kolomgrens: waar links vol en rechts leeg is (of andersom).
   for (let i = 0; i < xs.length; i++) {
     const x = xs[i];
     const left = i > 0 ? cols[i - 1].cells.filter(c => c.filled).map(c => [c.lo.b, c.hi.b]) : [];
@@ -257,7 +206,6 @@ function columnMinusRects(x0, x1, yBottom, topYAt, rects, opts) {
     }
   }
 
-  // Randen aaneenrijgen tot gesloten lussen (collineaire tussenpunten weg).
   const loops = [];
   edges.forEach((list, start) => {
     while (list.length) {
@@ -293,7 +241,6 @@ function columnMinusRects(x0, x1, yBottom, topYAt, rects, opts) {
     return c;
   };
   const outers = polys.filter(p => p.length >= 3 && signedArea(p) > 1e-12).map(p => ({ outer: p, holes: [] }));
-  // Gat bij de kleinste buitenlus die het bevat.
   outers.sort((p, q) => signedArea(p.outer) - signedArea(q.outer));
   polys.filter(p => p.length >= 3 && signedArea(p) < -1e-12).forEach(hole => {
     const mid = { x: (hole[0].x + hole[1].x) / 2, y: (hole[0].y + hole[1].y) / 2 };
@@ -303,11 +250,6 @@ function columnMinusRects(x0, x1, yBottom, topYAt, rects, opts) {
   return outers;
 }
 
-// Omtrek van de vereniging van as-evenwijdige rechthoeken ({x0, x1, z0, z1}),
-// als gesloten lussen van punten {x, z}. Buitenlussen zijn tegen de klok in
-// (positieve oppervlakte in het x/z-vlak), gaten met de klok mee. Collineaire
-// tussenpunten zijn verwijderd. Gesorteerd op oppervlakte (grootste eerst).
-// Gebruikt voor de dakrand (boeidelen/daktrim) over meerdere units heen.
 function rectUnionLoops(rects) {
   const eps = 1e-6;
   const uniq = (arr) => arr.sort((a, b) => a - b).filter((v, i, a) => i === 0 || v - a[i - 1] > eps);
@@ -350,16 +292,11 @@ function rectUnionLoops(rects) {
   return loops.map(pts => ({ pts, area: area(pts) })).sort((a, b) => Math.abs(b.area) - Math.abs(a.area));
 }
 
-// Buitenwaartse normaal (as-evenwijdig, lengte 1) van ribbe a -> b van een
-// lus tegen de klok in (positieve oppervlakte in x/z).
 function rectilinearNormal(a, b) {
   const dx = b.x - a.x, dz = b.z - a.z, len = Math.hypot(dx, dz) || 1;
   return { x: dz / len, z: -dx / len };
 }
 
-// Verschuift een rechthoekige (as-evenwijdige) lus tegen de klok in over
-// afstand d naar buiten. Collineaire tussenpunten (bijv. een unit-hoek midden
-// in een rechte gevel) blijven behouden en schuiven loodrecht mee.
 function offsetRectilinearLoop(pts, d) {
   const n = pts.length;
   return pts.map((p, k) => {
@@ -370,17 +307,12 @@ function offsetRectilinearLoop(pts, d) {
   });
 }
 
-// Gevels: groepeert lijnstukken in de plattegrond tot doorlopende gevels
-// (zelfde as + normaal + gevelvlak, aansluitend of overlappend). segs: [{ axis ('x'|'z'),
-// normal {x, z}, line (positie op de andere as), s0, s1 (s0 < s1) }, ...].
-// Geeft [{ axis, normal, line, s0, s1, segs (op s0 gesorteerd) }].
-// Gebruikt door de woning (latwerk/doek-patroon) en de buitenverlichting.
 function groupFacadeRuns(segs, opts) {
   const lineTol = (opts && opts.lineTol) || 1, gapTol = (opts && opts.gapTol) || 5;
   const runs = [];
   segs.slice().sort((a, b) => a.s0 - b.s0).forEach(sg => {
     const run = runs.find(r => r.axis === sg.axis && Math.abs(r.normal.x - sg.normal.x) < 1e-6 && Math.abs(r.normal.z - sg.normal.z) < 1e-6 &&
-      Math.abs(r.line - sg.line) < lineTol && sg.s0 <= r.s1 + gapTol); // aansluitend of overlappend
+      Math.abs(r.line - sg.line) < lineTol && sg.s0 <= r.s1 + gapTol);
     if (run) { run.segs.push(sg); run.s1 = Math.max(run.s1, sg.s1); }
     else runs.push(Object.assign({}, sg, { s0: sg.s0, s1: sg.s1, segs: [sg] }));
   });