Landscape IFC export

const R = (v, d = 6) => { if (!Number.isFinite(v)) return '0.'; let s = (Math.abs(v) < 0.5 * 10 ** -d ? 0 : v).toFixed(d).replace(/(\.\d*?)0+$/, '$1'); if (!s.includes('.')) s += '.'; return s === '-0.' ? '0.' : s; };

const first = elements.find((e) => e.at);
const ox = first ? Math.round(first.at.x / 100) * 100 : 0, oy = first ? Math.round(first.at.y / 100) * 100 : 0;
const siteLP = w.add('IFCLOCALPLACEMENT($,' + WCS + ')');

const place = w.add('IFCAXIS2PLACEMENT3D(' + w.pt([(at.x - ox) * k, (at.y - oy) * k, (at.z || 0) * k]) + ',' + Z + ',' + (rot ? w.dir([Math.cos(rot), Math.sin(rot), 0]) : X) + ')');
const lp = w.add('IFCLOCALPLACEMENT(' + siteLP + ',' + place + ')');

const circle = (r) => w.once('IFCCIRCLEPROFILEDEF(.AREA.,$,$,' + R(r) + ')');
const polygon = (pts) => {
  const ring = pts.map((p) => w.pt([p.x * k, p.y * k]));
  ring.push(ring[0]);
  return w.add('IFCARBITRARYCLOSEDPROFILEDEF(.AREA.,$,' + w.add('IFCPOLYLINE((' + ring.join(',') + '))') + ')');
};
const extrude = (profile, z0, z1) => w.add('IFCEXTRUDEDAREASOLID(' + profile + ',' + w.add('IFCAXIS2PLACEMENT3D(' + w.pt([0, 0, z0 * k]) + ',$,$)') + ',' + Z + ',' + R(Math.max(1e-4, (z1 - z0) * k)) + ')');

if (b.kind === 'mesh' && b.indices?.length >= 3) {   // LD.7: a freeform mesh, 1-based indices
  const pts = [];
  for (let i = 0; i < b.positions.length; i += 3) pts.push('(' + R(b.positions[i] * k) + ',' + R(b.positions[i + 1] * k) + ',' + R(b.positions[i + 2] * k) + ')');
  const tris = [];
  for (let i = 0; i < b.indices.length; i += 3) tris.push('(' + (b.indices[i] + 1) + ',' + (b.indices[i + 1] + 1) + ',' + (b.indices[i + 2] + 1) + ')');
  return [w.add('IFCTRIANGULATEDFACESET(' + w.add('IFCCARTESIANPOINTLIST3D((' + pts.join(',') + '),$)') + ',$,$,(' + tris.join(',') + '),$)')];

const qs = Object.entries(props).filter(([, q]) => q && Number.isFinite(q.v)).map(([qk, q]) => {
  const f = q.kind === 'area' ? k * k : q.kind === 'volume' ? k * k * k : q.kind === 'length' ? k : 1;
  const T = { area: 'IFCQUANTITYAREA', volume: 'IFCQUANTITYVOLUME', length: 'IFCQUANTITYLENGTH', count: 'IFCQUANTITYCOUNT' }[q.kind] || 'IFCQUANTITYCOUNT';
  return w.add(T + '(' + S(qk) + ',$,$,' + R(q.v * f) + ',$)');
});

/** Elements for every plant, bed and hedge (plants on the ground: `zAt(x, y)` gives the surface elevation). */
export function plantingElements(ls, index, units, { zAt = null, lang = 'en', which = null } = {}) {
  const k = unitM(units), show = which || ls.show || 'mature', out = [];
  const ground = (x, y) => { const z = zAt ? zAt(x, y) : null; return Number.isFinite(z) ? z : 0; };
  const typeOf = (sp) => ({
    key: 'plant-' + sp.key, cls: 'IfcGeographicElementType', predefined: 'VEGETATION', name: `${displayName(sp, lang)} (${sp.botanical})`,
    psets: { CadCraft_Plant: { BotanicalName: sp.botanical, CommonName: displayName(sp, lang), PlantType: sp.type, Form: sp.form, Foliage: sp.foliage,
      MatureHeight: sp.size.mature.h, MatureSpread: sp.size.mature.s, PlantingHeight: sizeOf(sp, 'plant').h, PlantingSpread: sizeOf(sp, 'plant').s,
      Container: sp.container, HardinessZone: sp.zone ? `${sp.zone.min}-${sp.zone.max}` : '', WaterNeed: sp.water, Light: sp.light.join(', '), Library: 'plants', SpeciesKey: sp.key } },
  });
  const bodyOf = (sp) => {   // in project units: trunk + crown for a tree, one round mass otherwise
    const z = sizeOf(sp, show), h = z.h / k, r = z.s / 2 / k;
    if (sp.type === 'tree') return { kind: 'cylinders', parts: [{ r: Math.max(0.05 / k, r * 0.08), z0: 0, z1: h * 0.4 }, { r, z0: h * 0.4, z1: h }] };
    return { kind: 'cylinders', parts: [{ r, z0: 0, z1: Math.max(0.02 / k, h) }] };
  };
  for (const p of ls.plants) {
    const sp = index.get(p.key);
    if (!sp) continue;
    out.push({ cls: 'IfcGeographicElement', predefined: 'VEGETATION', name: displayName(sp, lang), tag: p.id, at: { x: p.x, y: p.y, z: Number.isFinite(p.z) ? p.z : ground(p.x, p.y) },
      body: bodyOf(sp), type: typeOf(sp), psets: { CadCraft_Planting: { Source: 'plant', ShownSize: show, Label: p.label || '' } } });
  }
  for (const b of ls.beds) {
    const f = bedFill(b, index, units);
    const cx = b.pts.reduce((v, q) => v + q.x, 0) / b.pts.length, cy = b.pts.reduce((v, q) => v + q.y, 0) / b.pts.length;
    const zs = b.pts.map((q) => ground(q.x, q.y)), z = zs.reduce((a, v) => a + v, 0) / zs.length;
    let h = 0, wsum = 0;
    for (const m of b.mix) { const sp = index.get(m.key); if (sp) { h += m.pct * sizeOf(sp, show).h; wsum += m.pct; } }
    const counts = {};
    for (const [key, n] of Object.entries(f.counts)) counts[(index.get(key)?.botanical || key) + ' Count'] = n;
    // i18n-ignore: IFC file data (ObjectType), English like every library item
    out.push({ cls: 'IfcGeographicElement', predefined: 'VEGETATION', name: b.name, objectType: 'Planting bed', tag: b.id, at: { x: cx, y: cy, z },
      body: { kind: 'prism', pts: b.pts.map((q) => ({ x: q.x - cx, y: q.y - cy })), z0: 0, z1: Math.max(0.02, wsum ? h / wsum : 0.3) / k },
      psets: { CadCraft_PlantingBed: { Source: 'bed', PlantCount: f.pts.length, Spacing: bedSpacingM(b, index), Pattern: b.pattern, Mix: b.mix.map((m) => `${index.get(m.key)?.botanical || m.key} ${m.pct}%`).join('; '), Area: f.area * k * k, ...counts } } });
  }
  for (const hd of ls.hedges) {
    const sp = index.get(hd.key);
    if (!sp) continue;
    const f = hedgeFill(hd, index, units), z = sizeOf(sp, show), half = (z.s / 2 + (hd.rows === 2 ? hd.rowGap / 2 : 0)) / k;
    const a = offsetLine(hd.pts, half), b = offsetLine(hd.pts, -half).reverse();
    const o = hd.pts[0], g = ground(o.x, o.y);
    out.push({ cls: 'IfcGeographicElement', predefined: 'VEGETATION', name: hd.name, objectType: 'Hedge', tag: hd.id, at: { x: o.x, y: o.y, z: g },
      body: { kind: 'prism', pts: [...a, ...b].map((q) => ({ x: q.x - o.x, y: q.y - o.y })), z0: 0, z1: z.h / k },
      type: typeOf(sp), psets: { CadCraft_Hedge: { Source: 'hedge', PlantCount: f.pts.length, Rows: hd.rows, Length: f.length * k, Spacing: f.spacing * k } } });
  }
  return out;
}