350 lines
20 KiB
JavaScript
350 lines
20 KiB
JavaScript
/*!
|
|
* Tectum
|
|
* Copyright © 2026 Machiel Heinen.
|
|
* Alle rechten voorbehouden. Gebruik uitsluitend met schriftelijke toestemming.
|
|
* Zie LICENTIE.md.
|
|
*/
|
|
|
|
// Light-versie (modelpagina's): hetzelfde model en dezelfde berekeningen als de configurator, met een beperkte set
|
|
// keuzes. Keuzes worden altijd opnieuw toegepast op een schone kopie van het model, zodat terug naar de
|
|
// oorspronkelijke keuze precies het model geeft. Een keuze die de indeling breekt (ramen en deuren die niet meer
|
|
// passen, binnenwanden of inrichting buiten de unit, ruimtes die verdwijnen) wordt geweigerd (check).
|
|
window.LightModel = (() => {
|
|
const LIM = UnitModel.LIMITS;
|
|
// Kaders (mm) als het model of de pagina niets opgeeft; altijd binnen UnitModel.LIMITS. Per model te
|
|
// beperken met FRAMES, per pagina met mount-optie frames (zelfde vorm).
|
|
const DEFAULT_FRAME = { width: [2400, LIM.long], depth: [2400, LIM.long], height: [2400, LIM.eave] };
|
|
const FRAMES = {
|
|
// amstel: { units: { A: { width: [9000, 13000], depth: null } }, height: [2600, 3000] }
|
|
};
|
|
const STEP = 50;
|
|
// Helling (graden) bij een andere dakvorm dan die van het model.
|
|
const PITCH = { lessenaar: 10, zadel: 30, wolf: 35 };
|
|
const FACADES = { rabat: 'Hout', fels: 'Felsplaten', stuc: 'Stucwerk', steen: 'Steenstrips' };
|
|
const STONES = ['K490', 'K915', 'K911', 'K764', 'K518', 'K706'];
|
|
const LIGHTING = { geen: 'Geen', spots: 'Spots in de dakrand', gevel: 'Gevellampen' };
|
|
// Punten tot zo ver van de oost- of zuidrand van een unit horen bij die gevel en schuiven mee.
|
|
const BAND = 450;
|
|
|
|
const clone = HouseModel.clone;
|
|
const rectMap = (st) => Object.fromEntries(HouseModel.unitRects(st).map(r => [r.id, r]));
|
|
const houseRoof = (st) => !!(st.settings.roof.house.enabled && st.settings.roof.house.form);
|
|
|
|
// Alle gevel-overrides van het model (per wand en per wandstuk): het "accent".
|
|
function accents(st) {
|
|
const out = [];
|
|
st.units.forEach(u => Object.entries(u.unit.walls).forEach(([side, ws]) => {
|
|
if (u.facade.walls[side]) out.push({ get: () => u.facade.walls[side], set: (v) => { if (v) u.facade.walls[side] = v; else delete u.facade.walls[side]; } });
|
|
(ws.splits || []).forEach(sp => { if (sp && sp.facade) out.push({ get: () => sp.facade, set: (v) => { sp.facade = v || null; } }); });
|
|
}));
|
|
return out;
|
|
}
|
|
const colorOf = (o) => o.type === 'steen' ? o.stone : o.type === 'stuc' ? o.stuc : o.type === 'fels' ? o.fels : null;
|
|
|
|
function frameOf(key, override) {
|
|
const f = Object.assign({}, FRAMES[key] || {}, override || {});
|
|
const clampR = (r, lim) => r && [Math.max(1000, Math.min(lim, r[0])), Math.min(lim, r[1])];
|
|
return {
|
|
unit: (id) => {
|
|
const u = (f.units || {})[id] || {};
|
|
const pick = (k, lim) => u[k] === null ? null : clampR(u[k] || DEFAULT_FRAME[k], lim);
|
|
return { width: pick('width', LIM.long), depth: pick('depth', LIM.long) };
|
|
},
|
|
height: clampR(f.height || DEFAULT_FRAME.height, LIM.eave)
|
|
};
|
|
}
|
|
|
|
// Model inladen: schone basis, oorspronkelijke dakvormen en de keuzes zoals het model ze heeft.
|
|
function create(key, opts) {
|
|
const def = HouseModel.MODELS[key];
|
|
if (!def) throw new Error(`onbekend model "${key}"`);
|
|
const base = def.create();
|
|
const forms = Object.fromEntries(base.units.map(u => [u.id, UnitModel.roofForm(u.unit)]));
|
|
if (houseRoof(base)) forms.house = Object.assign({}, base.settings.roof.house.form);
|
|
const f = base.settings.facade, acc = accents(base).map(a => a.get());
|
|
const covering = (base.units.find(u => RoofModel.COVERINGS[u.roof.covering] && RoofModel.COVERINGS[u.roof.covering].sloped) || base.units[0]).roof.covering;
|
|
const choices = {
|
|
units: Object.fromEntries(base.units.map(u => {
|
|
const fl = u.unit.floor.floor;
|
|
return [u.id, { width: fl.width, depth: fl.depth, low: forms[u.id].low, high: highOf(forms[u.id]), type: forms[u.id].type, cut: cutOf(forms[u.id]), dir: forms[u.id].dir || null, ridge: forms[u.id].ridge || null }];
|
|
})),
|
|
house: forms.house ? { low: forms.house.low, high: highOf(forms.house), type: forms.house.type, cut: cutOf(forms.house), dir: forms.house.dir || null, ridge: forms.house.ridge || null } : null,
|
|
covering: RoofModel.COVERINGS[covering] ? covering : 'dakleer',
|
|
facade: { type: f.type, rabat: f.rabatColor, cladding: base.settings.cladding, stuc: f.stucColor, fels: f.felsColor, stone: f.stone },
|
|
accent: acc.length ? { type: acc[0].type, color: colorOf(acc[0]) } : null,
|
|
// Trasraam: alleen geen of steen; een cementplaat-trasraam van het model wordt geen.
|
|
trasraam: (() => {
|
|
const t = base.settings.trasraam, stone = WallModel.isStoneFinish(t.finish) && t.finish !== 'cementplaat';
|
|
return { on: !!t.enabled && stone, finish: stone ? t.finish : null, height: t.height };
|
|
})(),
|
|
lighting: { mode: base.settings.lighting.mode, direction: base.settings.lighting.direction, indoor: base.settings.lighting.indoor !== false },
|
|
// Boeidelen (aan = boeidelen, uit = daktrim) met kleur; een model met beide houdt zijn eigen indeling tot je kiest.
|
|
fascia: { on: base.units.some(u => u.roof.fascia !== false), color: RoofModel.FASCIA_COLORS[base.settings.roof.fasciaColor] ? base.settings.roof.fasciaColor : 'antraciet' },
|
|
// Zetwerk: één kleur voor de afdekker op het trasraam en het ventilatierooster onder de boeidelen.
|
|
trim: WallModel.isTrimColor(base.settings.roof.ventColor) ? base.settings.roof.ventColor : 'antraciet'
|
|
};
|
|
const model = { key, label: def.label, base, forms, hasAccent: acc.length > 0, frame: frameOf(key, opts && opts.frames), initial: clone(choices) };
|
|
const st = build(model, choices);
|
|
model.reference = issuesOf(st, HouseModel.computeParts(st, { skip3D: true }));
|
|
return model;
|
|
}
|
|
|
|
// Wolfseind als verhouding tussen goot (0) en nok (1), zoals de configurator: schaalt mee met goot en nok.
|
|
const WOLF_CUT = 0.6;
|
|
const cutOf = (form) => form.type !== 'wolf' ? null
|
|
: form.cutRatio > 0 ? form.cutRatio : form.cut ? (form.cut - form.low) / Math.max(1, form.high - form.low) : WOLF_CUT;
|
|
|
|
// Nok (of hoge kant) als keuze; null = afgeleid (plat dak, of een andere dakvorm dan die van het model).
|
|
const RISE_MIN = 300;
|
|
const highOf = (form) => form.type === 'plat' ? null : form.high;
|
|
|
|
// Dakvorm bij een keuze (c: type, low, high, cut, dir, ridge): dezelfde vorm als het model houdt richting en
|
|
// dakhoogte boven de goot, een andere krijgt de helling uit PITCH over de korte kant (lessenaar hoog aan de noord-
|
|
// of westgevel, nok in de lengte). Een gekozen richting (c.dir, c.ridge) en nok (c.high) gaan voor.
|
|
function formFor(orig, c, W, D) {
|
|
const { type, low } = c;
|
|
const dir = (f) => {
|
|
if (type === 'lessenaar') f.dir = c.dir || orig.dir || (W >= D ? 'voor' : 'links');
|
|
if (UnitModel.hasRidge(type)) f.ridge = c.ridge || orig.ridge || (W >= D ? 'x' : 'z');
|
|
return f;
|
|
};
|
|
let f;
|
|
if (type === orig.type) {
|
|
f = dir(Object.assign({}, orig, { low }));
|
|
f.high = type === 'plat' ? low : Math.min(LIM.ridge, orig.high + (low - orig.low));
|
|
} else {
|
|
f = { type, low, high: low };
|
|
if (type === 'plat') return f;
|
|
dir(f);
|
|
const gable = UnitModel.gableOf(f), span = gable === 'voor' || gable === 'achter' ? W : D;
|
|
const run = UnitModel.hasRidge(type) ? span / 2 : span;
|
|
f.high = Math.round(Math.min(LIM.ridge, low + Math.tan(PITCH[type] * Math.PI / 180) * run));
|
|
}
|
|
if (type !== 'plat' && c.high > 0) f.high = Math.round(Math.min(LIM.ridge, Math.max(low + RISE_MIN, c.high)));
|
|
if (type === 'wolf') { f.cutRatio = c.cut > 0 ? c.cut : cutOf(orig) || WOLF_CUT; delete f.cut; }
|
|
return f;
|
|
}
|
|
// Helling (graden) van een dakvorm over zijn overspanning (W/D: maten van de unit of de woning).
|
|
function pitchOf(f, W, D) {
|
|
if (f.type === 'plat') return 0;
|
|
const gable = UnitModel.gableOf(f), span = gable === 'voor' || gable === 'achter' ? W : D;
|
|
return Math.atan((f.high - f.low) / ((UnitModel.hasRidge(f.type) ? span / 2 : span) || 1)) * 180 / Math.PI;
|
|
}
|
|
function houseSize(st) {
|
|
const xs = HouseModel.unitRects(st);
|
|
return [Math.max(...xs.map(r => r.x1)) - Math.min(...xs.map(r => r.x0)), Math.max(...xs.map(r => r.z1)) - Math.min(...xs.map(r => r.z0))];
|
|
}
|
|
// Dakvorm zoals build hem toepast: per unit (id), of over de hele woning (id null; maten uit de gebouwde st).
|
|
// Met pitch: de helling in graden.
|
|
function formOf(model, ch, id, st) {
|
|
const [W, D] = id ? [ch.units[id].width, ch.units[id].depth] : houseSize(st);
|
|
const f = formFor(id ? model.forms[id] : model.forms.house, id ? ch.units[id] : ch.house, W, D);
|
|
return Object.assign(f, { pitch: pitchOf(f, W, D) });
|
|
}
|
|
|
|
// Unit van een punt (woningcoördinaten): de rechthoek waar het punt het diepst in ligt.
|
|
function ownerOf(rects, x, z) {
|
|
let best = null, depth = -1;
|
|
Object.values(rects).forEach(r => {
|
|
const d = Math.min(x - r.x0, r.x1 - x, z - r.z0, r.z1 - z);
|
|
if (d > -1 && d > depth) { best = r.id; depth = d; }
|
|
});
|
|
return best;
|
|
}
|
|
|
|
// Na een maatwijziging: binnenwanden (woningcoördinaten) schuiven mee met hun unit; een eindpunt tegen de oost- of
|
|
// zuidgevel van een gewijzigde unit schuift mee met die gevel (de wand rekt mee). Inrichting staat al t.o.v. de
|
|
// noordwesthoek (of de oostgevel) van zijn unit; staat een stuk tegen de oost- of zuidgevel, dan schuift het mee.
|
|
function follow(st, before, after) {
|
|
const shift = (id, x, z) => {
|
|
const b = before[id], a = after[id];
|
|
let dx = a.x0 - b.x0, dz = a.z0 - b.z0;
|
|
if (a.W !== b.W && x >= b.x1 - BAND) dx = a.x1 - b.x1;
|
|
if (a.D !== b.D && z >= b.z1 - BAND) dz = a.z1 - b.z1;
|
|
return { x: Math.round(x + dx), z: Math.round(z + dz) };
|
|
};
|
|
st.interiorWalls.forEach(iw => {
|
|
if (iw.seam) return;
|
|
[['x1', 'z1'], ['x2', 'z2']].forEach(([kx, kz]) => {
|
|
const id = ownerOf(before, iw[kx], iw[kz]);
|
|
if (!id) return;
|
|
const p = shift(id, iw[kx], iw[kz]);
|
|
iw[kx] = p.x; iw[kz] = p.z;
|
|
});
|
|
});
|
|
st.fixtures.forEach(f => {
|
|
const b = before[f.unitId], a = after[f.unitId];
|
|
if (!b || !a) return;
|
|
const r = f.rot * Math.PI / 180, c = Math.abs(Math.cos(r)), s = Math.abs(Math.sin(r));
|
|
const ex = c * f.w / 2 + s * f.d / 2, ez = s * f.w / 2 + c * f.d / 2;
|
|
if (f.anchor !== 'oost' && a.W !== b.W && f.x + ex >= b.W - BAND) f.x += a.W - b.W;
|
|
if (a.D !== b.D && f.z + ez >= b.D - BAND) f.z += a.D - b.D;
|
|
});
|
|
}
|
|
|
|
// Keuzes toepassen op een schone kopie van het model.
|
|
function build(model, ch) {
|
|
const st = clone(model.base);
|
|
const before = rectMap(st);
|
|
st.units.forEach(u => {
|
|
const c = ch.units[u.id], fl = u.unit.floor.floor;
|
|
fl.width = c.width; fl.depth = c.depth;
|
|
UnitModel.clampSize(fl);
|
|
});
|
|
const after = rectMap(st);
|
|
follow(st, before, after);
|
|
|
|
// Dakvorm en hoogte; binnenwanden gaan evenveel mee omhoog of omlaag als de goot.
|
|
const lift = {};
|
|
if (model.forms.house) {
|
|
st.settings.roof.house.form = formOf(model, ch, null, st);
|
|
st.units.forEach(u => { lift[u.id] = ch.house.low - model.forms.house.low; });
|
|
} else {
|
|
// Alleen opnieuw opbouwen wat afwijkt van het model; de rest blijft precies zoals het model het heeft.
|
|
st.units.forEach(u => {
|
|
const c = ch.units[u.id], c0 = model.initial.units[u.id], fl = u.unit.floor.floor;
|
|
lift[u.id] = c.low - model.forms[u.id].low;
|
|
if (['type', 'low', 'high', 'cut', 'dir', 'ridge', 'width', 'depth'].every(k => c[k] === c0[k])) return;
|
|
UnitModel.applyRoofForm(u.unit, formFor(model.forms[u.id], c, fl.width, fl.depth));
|
|
});
|
|
}
|
|
st.interiorWalls.forEach(iw => {
|
|
if (iw.seam) return;
|
|
const id = ownerOf(after, (iw.x1 + iw.x2) / 2, (iw.z1 + iw.z2) / 2), dh = id ? lift[id] : 0;
|
|
if (!dh) return;
|
|
const w = iw.wall.wall;
|
|
['heightAll', 'heightLeft', 'heightRight'].forEach(k => { if (w[k] > 0) w[k] += dh; });
|
|
});
|
|
|
|
if (ch.covering !== model.initial.covering) st.units.forEach(u => { u.roof.covering = ch.covering; });
|
|
const fc = ch.facade, F = st.settings.facade;
|
|
Object.assign(F, { type: fc.type, rabatColor: fc.rabat, stucColor: fc.stuc, felsColor: fc.fels, stone: fc.stone });
|
|
st.settings.cladding = fc.cladding;
|
|
Object.assign(st.settings.trasraam, { enabled: ch.trasraam.on }, ch.trasraam.on ? { finish: ch.trasraam.finish, height: ch.trasraam.height } : {});
|
|
if (model.hasAccent && JSON.stringify(ch.accent) !== JSON.stringify(model.initial.accent)) {
|
|
const a = ch.accent;
|
|
accents(st).forEach(o => o.set(a ? Object.assign({ type: a.type }, a.type === 'steen' ? { stone: a.color } : a.type === 'stuc' ? { stuc: a.color } : a.type === 'fels' ? { fels: a.color } : {}) : null));
|
|
}
|
|
Object.assign(st.settings.lighting, { mode: ch.lighting.mode, direction: ch.lighting.direction, indoor: ch.lighting.indoor });
|
|
st.settings.trasraam.capColor = st.settings.roof.ventColor = ch.trim;
|
|
if (ch.fascia.on !== model.initial.fascia.on) st.units.forEach(u => { u.roof.fascia = ch.fascia.on; });
|
|
st.settings.roof.fasciaColor = ch.fascia.color;
|
|
return st;
|
|
}
|
|
|
|
// Wat er aan de indeling schort: per opening (verschoven, ingeklemd, te hoog voor de wand of in geen enkel
|
|
// wandstuk meer), binnenwand buiten de units, inrichting door een gevel, verdwenen ruimtes en overlappende units.
|
|
// check vergelijkt met het model zelf, zodat wat daar al zo is geen keuze blokkeert.
|
|
function issuesOf(st, parts) {
|
|
const out = new Set();
|
|
parts.overlaps.forEach(p => out.add('units ' + p.join('+')));
|
|
parts.rects.forEach(r => { if (r.error) out.add('units ' + r.id); });
|
|
const ops = (key, config, placed) => config.openings.forEach(o => {
|
|
if (o.type === 'schoorsteen') return;
|
|
const W = config.wallWidth;
|
|
const want = o.anchor === 'right' ? W - o.offset - o.w : o.anchor === 'middle' ? (W - o.w) / 2 + o.offset : o.offset;
|
|
if (o.overflowing || Math.abs(o.x - want) > 2) out.add(`opening ${key}.${o.id} plek`);
|
|
if (o.h < o.rawH - 2 || o.hR < o.rawHR - 2 || o.y < o.rawY - 2) out.add(`opening ${key}.${o.id} hoogte`);
|
|
if (placed && !placed.has(o.id)) out.add(`opening ${key}.${o.id} kwijt`);
|
|
});
|
|
// Gevelopeningen staan t.o.v. de hele wand en worden daarna over de wandstukken verdeeld (UnitModel.wallPieces).
|
|
st.units.forEach(su => {
|
|
const pu = parts.units.find(u => u.id === su.id);
|
|
Object.entries(su.unit.walls).forEach(([side, ws]) => {
|
|
const w = pu && pu.walls.find(x => x.side === side);
|
|
ops(`${su.id}-${side}`, WallModel.configFromState(ws), new Set(w ? w.pieces.flatMap(p => p.config.openings.map(o => o.id)) : []));
|
|
});
|
|
});
|
|
parts.interior.forEach(p => ops(`bw${p.id}${p.seamUnit || ''}`, p.config));
|
|
const inside = (r, x, z, m) => r && x >= r.x0 + m && x <= r.x1 - m && z >= r.z0 + m && z <= r.z1 - m;
|
|
st.interiorWalls.filter(iw => !iw.seam).forEach(iw => {
|
|
if (![[iw.x1, iw.z1], [iw.x2, iw.z2]].every(([x, z]) => parts.rects.some(r => inside(r, x, z, -1)))) out.add(`indeling bw${iw.id}`);
|
|
});
|
|
parts.fixtures.forEach(it => {
|
|
const r = parts.rects.find(q => q.id === it.unitId);
|
|
if (it.corners.some(c => !inside(r, c.x, c.z, 100))) out.add(`indeling fx${it.id}`);
|
|
});
|
|
return { keys: out, rooms: parts.rooms.rooms.length };
|
|
}
|
|
|
|
// null = in orde, anders een melding voor de klant.
|
|
function check(model, st, parts) {
|
|
const now = issuesOf(st, parts), ref = model.reference;
|
|
const added = [...now.keys].filter(k => !ref.keys.has(k));
|
|
if (now.rooms < ref.rooms) added.push('indeling ruimtes');
|
|
if (!added.length) return null;
|
|
if (added.some(k => k.startsWith('units'))) return 'De units komen dan over elkaar heen.';
|
|
if (added.some(k => k.startsWith('opening'))) return 'De ramen en deuren van dit model passen dan niet meer.';
|
|
return 'De indeling van dit model past dan niet meer.';
|
|
}
|
|
|
|
// Grootste of kleinste maat tussen een geldige (ok) en een gevraagde waarde (want) die nog past; rekent zonder 3D.
|
|
function fit(model, ch, setter, ok, want) {
|
|
let good = ok, bad = want;
|
|
while (Math.abs(bad - good) > STEP) {
|
|
const mid = Math.round((good + bad) / 2 / STEP) * STEP;
|
|
if (mid === good || mid === bad) break;
|
|
const c = clone(ch);
|
|
setter(c, mid);
|
|
const st = build(model, c);
|
|
if (check(model, st, HouseModel.computeParts(st, { skip3D: true }))) bad = mid; else good = mid;
|
|
}
|
|
return good;
|
|
}
|
|
|
|
// Kerncijfers voor de klant: geen uren, zaagstukken of inkoop.
|
|
function summary(st, parts) {
|
|
const totals = HouseModel.computeTotals(parts);
|
|
const cost = CostModel.compute(parts, totals);
|
|
const d = HouseModel.computeDimensions(parts, st.settings.groundLevel);
|
|
return {
|
|
price: cost.summary.inclBtw, kg: totals.totalKg, units: st.units.length,
|
|
lengthX: d.lengthX, lengthZ: d.lengthZ, height: d.height, brutoM2: d.brutoM2, leefbaarM2: d.leefbaarM2, inhoudM3: d.inhoudM3
|
|
};
|
|
}
|
|
|
|
// De keuzes in woorden (voorblad van de PDF): [onderwerp, tekst].
|
|
// Lessenaar: hoge kant; zadel/wolf: richting van de nok (UnitModel.RIDGES).
|
|
const SIDES = { voor: 'Noord', achter: 'Zuid', links: 'West', rechts: 'Oost' };
|
|
const SIDE_NAMES = { voor: 'noord', achter: 'zuid', links: 'west', rechts: 'oost' };
|
|
const ROOF_NAMES = { plat: 'plat dak', lessenaar: 'lessenaardak', zadel: 'zadeldak', wolf: 'wolfsdak' };
|
|
const cap = (t) => t.charAt(0).toUpperCase() + t.slice(1);
|
|
function colorName(type, key) {
|
|
if (type === 'steen') return `steen ${key}`;
|
|
const list = type === 'rabat' ? WallModel.RABAT_COLORS : type === 'stuc' ? WallModel.STUC_COLORS : WallModel.FELS.COLORS;
|
|
return list[key] ? list[key].label.toLowerCase() : '';
|
|
}
|
|
function describe(model, ch, st) {
|
|
const fc = ch.facade, ids = Object.keys(ch.units), multi = ids.length > 1;
|
|
const facade = (type, color) => [FACADES[type].toLowerCase(), type === 'rabat' ? fc.cladding : null, colorName(type, color)].filter(Boolean).join(', ');
|
|
const perUnit = (fn) => {
|
|
const vals = ids.map(id => fn(ch.units[id], id));
|
|
return !multi || vals.every(v => v === vals[0]) ? vals[0] : ids.map((id, i) => `unit ${id}: ${vals[i]}`).join(', ');
|
|
};
|
|
const sloped = ch.house ? ch.house.type !== 'plat' : ids.some(id => ch.units[id].type !== 'plat');
|
|
const nok = (f) => f.type === 'plat' ? '' : `, ${f.type === 'lessenaar' ? 'hoge kant' : 'nok'} ${nl(f.high / 1000)} m`;
|
|
const way = (f) => f.type === 'lessenaar' ? ` (hoog aan de ${SIDE_NAMES[f.dir]}kant)` : UnitModel.hasRidge(f.type) ? ` (nok ${UnitModel.RIDGES[f.ridge].toLowerCase()})` : '';
|
|
const rows = [
|
|
['Dakvorm', cap(ch.house ? `${ROOF_NAMES[ch.house.type]}${way(formOf(model, ch, null, st))} over de hele woning`
|
|
: perUnit((u, id) => ROOF_NAMES[u.type] + way(formOf(model, ch, id))))],
|
|
['Hoogte', cap(ch.house ? `goot ${nl(ch.house.low / 1000)} m${nok(formOf(model, ch, null, st))}` : perUnit((u, id) => `goot ${nl(u.low / 1000)} m${nok(formOf(model, ch, id))}`))],
|
|
['Dakbedekking', (RoofModel.COVERINGS[sloped ? ch.covering : 'dakleer'] || RoofModel.COVERINGS.dakleer).label],
|
|
['Gevel', cap(facade(fc.type, ({ rabat: fc.rabat, stuc: fc.stuc, fels: fc.fels, steen: fc.stone })[fc.type]))]
|
|
];
|
|
const tr = ch.trasraam;
|
|
rows.push(['Trasraam', tr.on ? `Steen ${tr.finish}, ${nl(tr.height / 1000)} m hoog` : 'Geen']);
|
|
rows.push(['Dakrand', ch.fascia.on ? `Boeidelen ${RoofModel.FASCIA_COLORS[ch.fascia.color].label.toLowerCase()}` : 'Daktrim']);
|
|
const trimUse = trimUses(ch);
|
|
if (trimUse) rows.push(['Zetwerk', `${WallModel.TRIM_COLORS[ch.trim].label} (${trimUse})`]);
|
|
if (model.hasAccent) rows.push(['Accentgevel', ch.accent ? cap(facade(ch.accent.type, ch.accent.type === 'rabat' ? fc.rabat : ch.accent.color)) : 'Geen']);
|
|
rows.push(['Buitenverlichting', LIGHTING[ch.lighting.mode] + (ch.lighting.mode === 'gevel' ? ` (${LightingModel.DIRECTIONS[ch.lighting.direction].toLowerCase()})` : '')]);
|
|
rows.push(['Binnenverlichting', ch.lighting.indoor ? 'Inbouwspots in het plafond' : 'Geen']);
|
|
return rows;
|
|
}
|
|
const nl = (n) => n.toLocaleString('nl-NL', { minimumFractionDigits: 2, maximumFractionDigits: 2 });
|
|
// Waar de zetwerk-kleur voor geldt (leeg: nergens).
|
|
const trimUses = (ch) => [ch.trasraam.on ? 'afdekker trasraam' : null, ch.fascia.on ? 'ventilatierooster' : null].filter(Boolean).join(' en ');
|
|
|
|
return { DEFAULT_FRAME, FRAMES, STEP, PITCH, SIDES, formOf, FACADES, STONES, LIGHTING, trimUses, create, build, check, fit, summary, describe, colorName };
|
|
})();
|