@woosh/meep-engine 3.57.0 → 3.58.0

package/src/generation/foliage/SELF_ORGANIZING_FRAMEWORK_BRIEF_2026_10_26.md

@@ -0,0 +1,346 @@
+# A Framework Grown from Shoots
+
+Alex, 2026-10-26: grow the framework from the same shoot demography and light as the twigs (self-organizing), keeping
+the generator graph only for what shoots cannot give. Brief first.
+
+Why: `CROWN_FULLNESS_BRIEF_2026_10_26.md`. The crowns are bare because the authored framework is sparse
+(`BranchSpawnRule.count`). Vigour does not fill them; doubling the counts does. Every bare preset carries a third to
+two-thirds of the leaf a real tree of its size does.
+
+## Today
+
+1. **`tree_skeleton_grow`** builds the framework from the generator graph. `branches[0]` is the trunk, and each
+   `branch_rules` edge spawns `count` branches of one generator along another. The generator graph supplies:
+   - Hermite spines with tropisms (gravitropism, phototropism, plagiotropism, straightness, curl-noise gnarl, nodal
+     kinks);
+   - phyllotaxis, whorls, splits, space colonization toward an authored crown envelope, and BVH avoidance;
+   - dead stubs and scars (`self_pruning`), surface roots, flare lobes;
+   - pipe-model radii.
+2. **`tree_skeleton_grow_shoots`** then grows the twig layer on the finished framework, season by season. The work is
+   done by `shoot_systems_simulate`: a light field, net yield by light, shedding, dynamic girth (`ShootGirth`),
+   collision against the framework, and engulfment. A carrier's age is backed out of its position.
+
+The framework's density, its bough count, its envelope and its age are all authored or backed out. Only the
+periphery is grown.
+
+## Principle
+
+A tree is its shoots. From the seedling on, each season every living axis extends and its buds burst by the
+species' bud demography. Each new shoot is kept as its light pays for it, and the wood thickens with what it carries.
+- **The framework** is the shoots that survived.
+- **Bough spacing** is what self-shading leaves.
+- **The crown's extent** is where the leaders reached in the tree's age.
+- **Natural pruning** is the lower boughs starving.
+
+This is the self-organizing tree of Palubicki et al. (2009, *ACM Trans. Graph.* 28(3): 58): bud fate by local light
+and space, and growth year by year. LIGNUM (Perttunen et al. 1996, *Ann. Bot.* 77: 87-98) grows a whole tree from
+annual units the same way. The simulation already is this, for the periphery; extending it to the whole tree is the
+change.
+
+**What shoots cannot give**, so the generator graph keeps it:
+- **The root system:** surface roots and the flare lobes. These are not shoot growth.
+- **Monocots:** the palm and the fern grow fronds from one apical meristem, with no lateral shoot system. Their
+  presets stay on the graph entirely.
+- **The seed:** the seedling's first leader, its position, and the trunk guide as an initial direction.
+
+## Design
+
+1. **One simulation from the seedling.**
+   - `tree_skeleton_grow` lays the roots and a seed leader.
+   - `shoot_systems_simulate` grows everything else for the tree's `age` seasons: the leader is an order-1 axis, the
+     boughs are its laterals, and so on down the orders. Each preset's `shoot_rules` cover every order from the stem
+     out, not only the periphery.
+   - Carriers, "framework age" and `branch_unit_start_t`'s carrier back-fill go away: every axis records its own units
+     as it grows them.
+2. **The light field grows with the crown.** The voxel grid follows the crown's bounds each season, not a fixed
+   framework box, at the same cell. Cost is still grid cells times 17 sweeps.
+3. **Shoots keep out of all older wood.** Each shoot is tested against wood as thick as it is that season.
+   - That replaces the BVH avoidance and the framework hash: one spatial hash over every living segment, updated
+     incrementally, since each season only adds units and thickens wood.
+   - Engulfment stays: wood that thickening wood grows into dies.
+4. **Natural pruning is shade death.**
+   - A whole bough dies when its shoots cannot pay for themselves (`Rb < 1` everywhere on it). Today that holds for
+     twig axes only.
+   - Its dead wood persists as a stub by the species' `self_pruning`, as the graph's stubs do now, then heals over
+     into a scar (`TreeSkeleton.add_scar`).
+   - The graph's stub and scar code moves to the simulation, driven by deaths rather than an authored `attach_min`.
+5. **Tropisms per axis order.**
+   - The shoot simulation already turns each new unit by its generator's gravitropism, phototropism and zigzag.
+     Plagiotropism and straightness move over from the graph's spine to the unit's heading.
+   - Older wood does not move once grown, except by bending (fork F3).
+6. **Architecture stays sourced data.**
+   - **Excurrent conifers:** a leader whose terminal is longest and whose whorl buds burst every year.
+   - **Sympodial birch:** the apex aborts and the subapical buds take over, already in the rule.
+   - **Decurrent oak:** the order lengths fall with order.
+   - These are the rules' per-order lengths and bud zones. No apical-control constant is added unless a measurement
+     shows the forms do not come out (fork F4).
+7. **The bark mesher, the wind rig and the foliage** keep reading the skeleton as they do. Every branch is now a
+   chain of annual units: more nodes on old boughs, one a year.
+
+## Data per species
+
+What the rules need from the stem out, and what the presets already cite:
+
+| preset | stem and boughs | gap |
+| :--- | :--- | :--- |
+| pine | leader 47.5 cm/yr and shoot counts by branch order [Kellomäki & Kurttio 1991] | the leader rule bears no laterals today; the stem's whorl bud counts are to be found, in KK1991 or elsewhere |
+| spruce | Colin & Houllier 1992 (whorl and interwhorl branches); lengths by order from pine | leader growth borrowed from pine |
+| birch | stem long shoot 26.3 cm [Lintunen et al. 2011, Table A2]; Maillette 1982 orders | stem bud zones as the branches' |
+| maple | stem is Wilson's order 1, leader 30 cm/yr [Wilson 1966; Critchfield 1971] | none known |
+| willow | Remphrey & Pearn 2006 orders | stem rule |
+| oak | Buck-Sorlin & Bell 2000 cover mature crowns' peripheral branches, not the stem or boughs; leader 0.3 m/yr is chosen | a source for oak's leader and bough demography (sapling architecture studies) |
+| hazel | a stool: basal sprouts from the root collar [Grisafi et al. 2024 for the shoots] | the stool's sprout recruitment |
+
+**Targets (acceptance):**
+- whole-tree leaf area within the allometric range at the tree's DBH (`CROWN_FULLNESS_BRIEF`, Forrester et al. 2017,
+  Martin et al. 1998, Repola 2009);
+- FIA crown density 45-51% with transparency near 15% [Randolph 2006];
+- a height-to-diameter ratio in the measured range for the species.
+
+## Decisions (Alex, 2026-10-26)
+
+- **F1:** from the seedling, for the tree's age.
+- **F2:** sapwood carries the leaf: girth from the species' leaf-to-sapwood ratio, with heartwood inside.
+- **F3:** static sag from the beam mechanics.
+- **F4:** no apical control until a measurement asks for it (as recommended; not asked).
+- **F5:** research a *Quercus* stem and bough source; oak keeps its graph framework until then.
+
+## Forks
+
+- **F1 Time.** Simulate from the seedling for the tree's age, or start from a sapling.
+  - Recommended: **from the seedling**. The size then follows from the leader growth and the age, and nothing is
+    backed out.
+  - The preset's input becomes `age` (seasons).
+- **F2 Wood.** The pipe model at `pipe_model_exponent` over Table 7 shoot radii gives an 87 cm DBH oak 8.6 m tall.
+  - Recommended: **sapwood carries the leaf** (Shinozaki et al. 1964). A cross-section's sapwood area is the leaf
+    area it carries over the species' measured leaf-to-sapwood ratio (Norway spruce 0.45 m²/cm², Pokorný & Tomášková
+    2007; red maple and oaks from Martin et al. 1998), and heartwood accrues inside it.
+  - The ratio is sourced, and the DBH then follows from the leaf. It lands in the same pass (`ShootGirth`).
+- **F3 Bending.** Old boughs droop under their own weight; graph spines fake it with authored curvature.
+  - Recommended: **static sag from the existing beam mechanics.** The segment compliance and loads are already
+    computed for the wind joints, so the deflection under self-weight comes from them, applied once per season as the
+    wood grows.
+  - Alternatively, defer, and tropisms alone shape the boughs.
+- **F4 Apical control.** Recommended: none beyond the rules' order lengths at first, then measured. Add a sourced
+  control only if the excurrent and decurrent forms do not emerge.
+- **F5 Oak's stem data.** Recommended: research a sapling or young-tree architecture source for *Quercus* before oak
+  migrates. Until then, oak keeps its graph framework and the brief says so.
+
+## Plan
+
+1. **S0, the gate.** A probe and spec that measure every preset against the targets: leaf area vs allometry, FIA
+   density and transparency, H/D, crown width/height. Run on master as the baseline.
+2. **S1, pine end to end.**
+   - The seed leader plus the whole-tree simulation (light field following the crown, collision against all wood,
+     shade death of boughs). Roots stay on the graph.
+   - Pine first: the best data from the stem out.
+   - Measure against S0; look at it.
+3. **S2, wood from leaf** (F2): sapwood by the leaf-to-sapwood ratio, heartwood, and the H/D check.
+4. **S3, stubs and scars from deaths**, moved off the graph.
+5. **S4, bending** (F3), if taken.
+6. **S5, the other species:** spruce, maple, birch, willow, hazel, then oak once F5 has a source. Each is measured
+   against S0 and looked at.
+7. **S6, removal.**
+   - The graph's crown machinery goes for shoot-grown species (hard break): branch spawn rules above the roots, space
+     colonization, the crown envelope's growth role, BVH avoidance, and the back-filled carrier ages.
+   - Specs are restated from their principle. Tiers come from whorls; collision is "a shoot never grows into older
+     wood".
+   - Mutation-tested.
+
+## Risks, to measure, not assume
+
+- **Cost.** The whole tree as shoots means more axes and seasons. Today spruce is 3.1 s with 40k twig axes. Measure at
+  S1, then decide whether the light field or the hash needs work. There is no preset budget.
+- **Mesh size.** Old boughs get a node a year. Measure node and triangle counts at S1 against today's.
+- **Specs.** Most framework specs restate (tiers, collisions, stubs, seams); the root and monocot specs stand.
+- **The trunk's look.** Flare lobes and bark keep working on any trunk. The trunk guide becomes the seed leader's
+  initial heading plus tropisms.
+
+## S0 baseline (seed 1337, master 7d610267e)
+
+`analysis/tree_leaf_area_targets.js` holds the sourced allometries; the gate probe compares each preset to them at the
+tree's own DBH and height, and reports the DBH a measured tree carrying the preset's leaf would have.
+
+| preset | DBH | height | H/D | leaf | expected at its DBH | leaf implies DBH | side density | transparency |
+| :--- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
+| oak | 87 cm | 8.6 m | 10 | 89 m² | 1,347-2,297 m² (outside every sample) | 19 cm | 0.50 | 0.42 |
+| pine | 73 cm | 10.7 m | 15 | 16 m² | 168-245 m² (outside every sample) | 16 cm | 0.34 | 0.64 |
+| birch | 62 cm | 10.5 m | 17 | 70 m² | 582 m² (outside the sample) | 20 cm | 0.56 | 0.33 |
+| maple | 88 cm | 8.6 m | 10 | 51 m² | 899 m² (outside the sample) | 17 cm | 0.41 | 0.42 |
+| spruce | 69 cm | 10.8 m | 16 | 78 m² | 482-730 m² | 21 cm | 0.33 | 0.31 |
+
+Every tree fails the leaf gate by 6-16x at its own DBH, because both halves are off: the trunks are three to four
+times too thick (S2), and the crowns carry a third to two-thirds of the leaf of a tree as tall (S1). Willow, palm,
+shrub and fern have no allometry. Only oak and fern sit in the FIA density band; no preset is near 15% transparency.
+
+## S1 status (2026-10-26, uncommitted)
+
+**Built:**
+- **The stem from the seed.** The graph lays a seed leader (the first year's shoot) and the roots. A carrier that
+  stops growing before the tree's `ShootGrowthConfig.age` grows on from its tip as an axis of its own order and
+  generator, and is written onto the carrier, so the trunk is one branch from the ground up.
+- **The leader by height.** The stem grows `leader_unit(height)` a year: KK1991 Eq. 6's logistic. KK1991 grow the
+  stem this way because the stem's terminal ratio (1.196) has no bound.
+- **Per-order demography.** `ShootSystemRule.target` is a generator per mother order (the stem's laterals draw the
+  bough generator, the rest twigs); `mean_unit_length` is per order; a new shoot survives at Rb over the gross yield of
+  the unit it grew on, counted at that unit's own length.
+- **Light, ground, crown frame.** The light field is rebuilt round the crown as it grows; no shoot grows into the
+  ground; the crown frame the shoots' phototropism reads follows the living crown.
+- **The pine preset** is one shoot rule from the stem out [KK1991 Tables 3-4, Fig. 2], 30 seasons.
+
+**Measured against the gate (seed 1337):**
+
+| | master | S1 |
+| :--- | ---: | ---: |
+| height | 10.7 m | 12.2 m |
+| DBH | 73 cm | 25 cm |
+| H/D | 15 | 48 |
+| crown width | 5.0 m | 10.9 m |
+| leaf | 16 m² | 279 m² |
+| side density / transparency | 0.34 / 0.64 | 0.57 / 0.33 |
+| nodes | 5,374 | 81,890 |
+
+- **Height and girth.** H/D 48 falls in the 40-55 the open-grown evidence suggests (stand-grown pine runs 52-89;
+  Kellomäki 1984, Hu et al. 2020). The leader's onset in Eq. 6 is refitted to open-grown heights: KK1991's 11.16
+  extrapolates below their 1.1 m smallest tree and takes 15 years to the first metre; 4.34 fits eleven open-grown
+  trees of known age (Kuuluvainen et al. 1988; Sievänen et al. 1997), RMS 1.3 m, 11.1 m at 30 years against 11.4 m.
+- **Leaf over the forest allometry.** 279 m² against 36-63 m² for a forest pine of DBH 25 cm; but the target is
+  forest-grown and this tree carries its crown to the ground.
+- **Against an open-grown checkpoint** (Kuuluvainen et al. 1988, Table 3: age 8, 2.73 m tall, crown 1.70 m wide,
+  1.38 kg of needles, 110.6 m of shoots, 9.4 branches a whorl), the seedling pine at about 2 m: crown 1.3-1.8 m wide;
+  18-23 m of shoots and 0.27-0.34 kg of needles; 7-16 living boughs.
+- **Other presets** moved with the shared changes: oak 89 → 80 m², maple 51 → 56, willow 233 → 249, shrub 63 → 71.
+- **Specs:** 12 fail, all reading pine's old structure (inter-whorl branches, graph tiers and stubs, the graph trunk's
+  L/D bound of 26, its righting reflex). The stem leans 0.16 where the graph's trunk held 0.08.
+
+**Two measured defects remain, both forks:**
+
+- **F6, the stem's whorl.** The stem bursts KK1991's 3.99 + 0.022 L daughters, and the shedding then keeps each at
+  Rb / yield ≈ 0.45, with Rb = 1.867 measured on a branch (Niinemets & Lukjanova 2003). So about one bough survives
+  a year, against 9.4 living branches a whorl on open-grown trees (Kuuluvainen et al. 1988) and 5-6 in young stands
+  (Kellomäki 1984). KK1991's counts are living shoots already.
+- **F7, the boughs never slow.** A bough's first shoot is 0.570 of the stem's (27 cm under a 47.5 cm leader), and each
+  terminal 0.995 of the last, so a bough grows ~27 cm a year for its life: 5-6 m boughs at 25 years and a crown 10.9 m
+  wide. KK1991 say so themselves and cap a branch's length by a stand-grown fit (Eq. 9, Bmax 142 ± 44 cm, Kellomäki
+  et al. 1988). Light does not bind: bough tips see 0.8-0.96 of open sky in the young tree, median 0.81 at 30 years,
+  so shoot length by light (Niinemets & Lukjanova 2003, Fig. 3B) would barely shorten them. Drawing KK1991's
+  terminal ratios with their measured spread (cv 44-58%) was tried and reverted: independent ratios make a
+  heavy-tailed random walk (crowns 2.4-4.6 m wide across three seeds at the same age), which KK1991's model is not.
+
+## Decisions on F6 and F7 (Alex, 2026-10-26: "parametric, principled, broadly general, one code path; you choose")
+
+- **F6: full light keeps every shoot the bud demography gives.** Rb at saturation is the gross yield of the unit a
+  shoot grows on (`shoot_expected_yield` at that unit's length), not a per-species constant; it falls to 1 at the
+  compensation light and below it as before, so a new shoot survives at `Rb(Q) / yield`, 1 in full light. This is
+  what maple's net counts and the shrub's gross yield already did by hand, made the rule; `ShootGrowthConfig.vigour`
+  goes. The per-species Rb measurements become cross-checks.
+- **F7: Borchert-Honda apical control** (Palubicki et al. 2009, *ACM TOG* 28(3): 58, after Borchert & Honda 1984).
+  Each season the light each axis's tip receives is summed down every subtree to the carrier; it flows back up, and
+  at each node the continuing axis takes a share weighted `λ` and the laterals `1 − λ`. A shoot's unit is its
+  demographic mean length times its vigour per unit of its own light. At `λ = 0.5` that ratio is 1 everywhere, so a
+  species with no fitted `λ` grows as before on the same code path. Pine's `λ` is fitted to the open-grown crown of
+  Kuuluvainen et al. (1988, Table 3): 1.70 m wide at 2.73 m tall. The stem keeps its height-driven leader.
+
+## After F6 and F7 (seed 1337, uncommitted)
+
+Built as decided, plus two fixes the stem's lean exposed:
+- **Phototropism follows the light field.** A shoot turns towards where the field grows brighter (its gradient), not
+  away from the crown frame's centre: that pushed a lopsided crown's leader further off, a feedback that leaned the
+  stem 0.15. `shoot_outward3` is gone; the crown frame still follows the grown crown for the foliage and its shading.
+- **Zigzag kinks a unit, not the course.** An axis's heading carries its tropisms; each unit is kinked off it by the
+  generator's zigzag. Accumulated into the heading, the zigzag was a random walk.
+
+| | master | S1 now | target |
+| :--- | ---: | ---: | :--- |
+| height | 10.7 m | 10.9 m | 11.4 m at 30 years, open-grown |
+| DBH, H/D | 73 cm, 15 | 15 cm, 70 | 40-55 open-grown (estimate); 52-89 stands |
+| crown width | 5.0 m | 7.3 m | unknown for an open-grown 11 m pine |
+| leaf | 16 m² | 70 m² | 15-25 m² for a forest pine of DBH 15 cm |
+| side density / transparency | 0.34 / 0.64 | 0.44 / 0.54 | 0.45-0.51 / 0.15 |
+| stem lean | | 0.004-0.020 over 7 seeds | spec: under 0.08 |
+
+At the open-grown checkpoint (Kuuluvainen et al. 1988, Table 3) the 12-year pine, 2.6-3.5 m tall, has a crown
+0.59-0.64 of its height (0.62) and 56-107 m of shoots (110.6 m at 2.73 m).
+
+**Other presets** under F6 (full light keeps every shoot): oak 80 → 110 m² and density 0.47 (in band), maple 56 → 84 m²
+and 0.46 (in band), birch 74 → 61, willow 249 → 236, spruce 81 → 84, shrub 71 → 42 (its partial-light Rb now ramps to
+each unit's own yield, not to the yield at its mean length).
+
+**Specs: 15 fail.** Pine's old structure: inter-whorl branches, graph tiers and stubs, the graph trunk's L/D bound of
+26 and its crookedness, the conical spire, a plagiotropic trunk's knocked-out buds, branch crossings (shoots do not yet
+keep out of each other's wood, design 3), bark relief on boughs, preset traits. Oak: the wind spec compares a leafy and
+a bare oak, which now grow different wood (no leaves, so full light everywhere, so every shoot kept), and one oak spec
+timed out at 60 s under load.
+
+## S1 finished: shoots keep out of older wood, specs restated (2026-10-27, uncommitted)
+
+**Shoots keep out of all older wood** (design 3), in `ShootWoodHash` beside `ShootFrameworkHash`:
+- **The hash.** Every grown annual unit is added once under the cells its line crosses (0.1 m, about a twig's unit;
+  measured against 0.25 and 0.05 m). A query reads each unit's place and radius as they are, padded by the thickest
+  wood, so thickening needs no re-adding. Exact pre-filters: a unit nowhere as thick as the probe needs, a padded box
+  test, and each cell's thickest living unit, refreshed once a season.
+- **Blocked buds.** A new unit does not grow into the ground, framework wood, or older shoot wood it does not join. A
+  blocked bud turns by the golden angle round its node, as the plagiotropic knockout already did; a blocked terminal
+  waits a season.
+- **Junctions.** One wood with: its mother either side of where it grew and over its crotch (nearer her axis than her
+  radius); its grandmother where it grew at its mother's base; a carrier's extension and the carrier's laterals by its
+  tip; siblings' first units within the collar they share (out of the mother's wood, at least half way, as the
+  interpenetration spec always held siblings).
+- **Engulfed and buried.** A shoot whose line thicker wood (or as thick and older), compared where they meet, has
+  grown into dies. So does a lateral whose tip the wood its mother grew since has closed over: one that grew out of
+  wood already there, as on a carrier the graph laid at its full girth, is not buried. A carrier its parent has grown
+  over dies with its twigs; a graph branch the thickening buries is dead, an occluded knot, not a stub.
+- **Leaves pay.** A lateral of a generator that bears no leaves (no foliage rule) does not grow. Under F6 a crown that
+  casts no shade kept every bud and grew by its gross yield every year (an oak with `foliage_rules: []` took 92 s). Every
+  preset's shoot generators bear leaves, so no preset changes.
+- **Plagiotropism and straightness** turn a shoot's course as they turn the graph's spines (design 5); a stem is a
+  trunk and takes neither, nor knocks out its buds.
+
+**Measured (seed 1337):**
+
+| preset | leaf | side density | transparency | skeleton |
+| :--- | ---: | ---: | ---: | ---: |
+| pine | 62 m² | 0.43 | 0.57 | 1.4 s |
+| oak | 102 m² | 0.49 (in band) | 0.39 | 0.5 s |
+| maple | 81 m² | 0.45 (in band) | 0.37 | |
+| spruce | 52 m² | 0.30 | 0.31 | 2.7 s |
+| birch | 58 m² | 0.54 | 0.35 | |
+
+Pine: 10.8 m, DBH 15 cm, H/D 73, crown 7.3 m wide; 78k nodes, 641k triangles. The open-grown checkpoint still holds
+(crown 0.54-0.66 of height at 12 years, 0.62 measured). Stem lean 0.001-0.011 over seven seeds.
+
+**Specs.** Restated from their principle:
+- pine's traits: the graph lays only roots, one shoot rule grows the stem and all on it;
+- the spire is the leader's newest unit and what grows on it (the trunk's unit record);
+- the trunk's apex is no thicker than a current shoot of its newest unit's length;
+- per-unit slenderness for any branch the shoots grew on past its generator's length; sweep only for trunks the
+  graph grew;
+- a split fork is the graph's: same depth and generator, not a shoot rule's;
+- tiers come from a whorl: the graph's whorled rules, or a shoot's buds all under its terminal bud;
+- spruce's twigs fan in from whorl and inter-whorl boughs; the pine's stem bears its boughs and its boughs the twigs;
+- stubs are dead graph wood that sticks out of the bark, grown without the twig layer; pine grows none yet (S3);
+- foliage collection and the wind rig read the same oak, grown in the shade of its own leaves;
+- interpenetration: every child has a crotch; shoots are held to "no line inside other wood", spurs aside; a twig on a
+  carrier the graph laid at full girth is not buried;
+- bark relief compares every consecutive pair of trunk rings of one vertex count; the youngest bark is on any shoot;
+- senescence follows the crown's mean dryness, the most dried card bounding it;
+- the tiers spec grows twelve conifers with their foliage and has 180 s.
+New: `tree_skeleton_grow_seedling.spec.js` (leader by height, one stem from the ground, height at age, no shoot in the
+ground, carriers growing on, apical control), `ShootWoodHash.spec.js`, survival (`shoot_survival`), dead wood bears no
+shoots, a leafless generator grows no laterals.
+
+**Mutation testing**: 23 of 28 mutants killed. Survivors, each measured:
+- **Blocked buds and extensions, the sibling collar for blocking** (three): at season's end engulfment kills whatever
+  grew through older wood, so the final trees cannot tell. The blocking is kept for what it changes: without it the
+  pine's crown is 8.7 m wide against 7.3, and spruce carries 33 m² against 39.
+- **A carrier buried during the simulation**: no preset has a buried carrier that grows twigs (spruce's one starts
+  inside its mother's wood, so its buds are blocked). "Dead wood bears no shoots" would catch it.
+- **The light field following the crown**: without it the pine's upper crown sees open sky and carries 71 m² against
+  62. No spec reads the shading.
+
+**Open, measured:**
+- **Pine's crown is see-through:** transparency 0.57 against FIA's 0.15. Its leaf is 4.5x a forest pine's of its DBH,
+  so S2's girth from leaf will move DBH, not the crown.
+- **No open-grown target for crown width** at 11 m.
+- **Cost:** spruce's skeleton 2.7 s, most of it the engulfment pass; the gate's spruce 4.8 s against master's 3.8.
+- **Mesh size:** 5k → 78k nodes for the pine.

package/src/generation/foliage/analysis/crown_opacity_measure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"crown_opacity_measure.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/analysis/crown_opacity_measure.js"],"names":[],"mappings":"AAmdA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,4CAbW,OAAO,8CAA8C,EAAE,QAAQ,GAAC,IAAI,WACpE,OAAO,8CAA8C,EAAE,QAAQ,GAAC,IAAI,SACpE,SAAS,GAAC,IAAI;IAEE,gBAAgB,EAAhC,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,WAAW,GAA5B,MAAM;IAEW,kBAAkB,GAAnC,MAAM;IACW,mBAAmB,GAApC,MAAM;SACN,YAAY,GACV,YAAY,CA8IxB;0BAjoByB,uDAAuD;6BAEpD,mBAAmB"}
+{"version":3,"file":"crown_opacity_measure.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/analysis/crown_opacity_measure.js"],"names":[],"mappings":"AA6bA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,4CAbW,OAAO,8CAA8C,EAAE,QAAQ,GAAC,IAAI,WACpE,OAAO,8CAA8C,EAAE,QAAQ,GAAC,IAAI,SACpE,SAAS,GAAC,IAAI;IAEE,gBAAgB,EAAhC,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,WAAW,GAA5B,MAAM;IAEW,kBAAkB,GAAnC,MAAM;IACW,mBAAmB,GAApC,MAAM;SACN,YAAY,GACV,YAAY,CA8IxB;0BA1mByB,uDAAuD;6BAEpD,mBAAmB"}

package/src/generation/foliage/analysis/crown_opacity_measure.js

@@ -1,3 +1,4 @@
+import { tri2_rasterize_barycentric } from "../../../core/geom/2d/triangle/tri2_rasterize_barycentric.js";
 import { assert } from "../../../core/assert.js";
 import { typed_array_value_denormalize } from "../../../core/collection/array/typed/typed_array_value_denormalize.js";
 import { convex_hull_monotone_2d } from "../../../core/geom/2d/convex-hull/convex_hull_monotone_2d.js";
@@ -203,15 +204,16 @@ function raster_geometry(
     raster, projected, positions, uvs, index, triangle_count,
     atlas, alpha_channel, alpha_scale, leaf_transmittance, crown_base
 ) {
-    const width = raster.width;
-    const height = raster.height;
-    const T = raster.transmittance;
-    const T_foliage = raster.foliage_transmittance;
-    const flags = raster.flags;
-    const is_foliage = uvs !== null;
-    const atlas_w = is_foliage ? atlas.width : 0;
-    const atlas_h = is_foliage ? atlas.height : 0;
-    const blocked = 1.0 - leaf_transmittance;
+    const v = RASTER_VISITOR;
+    v.raster = raster;
+    v.uvs = uvs;
+    v.atlas = atlas;
+    v.atlas_w = uvs !== null ? atlas.width : 0;
+    v.atlas_h = uvs !== null ? atlas.height : 0;
+    v.alpha_channel = alpha_channel;
+    v.alpha_scale = alpha_scale;
+    v.blocked = 1.0 - leaf_transmittance;
+    v.crown_base = crown_base;
 
     for (let t = 0; t < triangle_count; t++) {
         let i0, i1, i2;
@@ -225,110 +227,86 @@ function raster_geometry(
             i2 = t * 3 + 2;
         }
 
-        let x0 = projected[i0 * 2], y0 = projected[i0 * 2 + 1];
-        let x1 = projected[i1 * 2], y1 = projected[i1 * 2 + 1];
-        let x2 = projected[i2 * 2], y2 = projected[i2 * 2 + 1];
-
-        let area = (x1 - x0) * (y2 - y0) - (y1 - y0) * (x2 - x0);
-        if (!(Math.abs(area) > 0)) {
-            // edge-on: a card has no thickness
-            continue;
-        }
-        if (area < 0) {
-            // counter-clockwise, so the interior is where all three edge functions are positive
-            let s = i1; i1 = i2; i2 = s;
-            s = x1; x1 = x2; x2 = s;
-            s = y1; y1 = y2; y2 = s;
-            area = -area;
-        }
-        const inv_area = 1.0 / area;
-
-        // a point on an edge belongs to the triangle that edge runs up through (or left along) in
-        const own_0 = (y2 - y1) > 0 || ((y2 - y1) === 0 && (x2 - x1) < 0);
-        const own_1 = (y0 - y2) > 0 || ((y0 - y2) === 0 && (x0 - x2) < 0);
-        const own_2 = (y1 - y0) > 0 || ((y1 - y0) === 0 && (x1 - x0) < 0);
-
         const h0 = positions[i0 * 3 + 1];
         const h1 = positions[i1 * 3 + 1];
         const h2 = positions[i2 * 3 + 1];
         if (Math.max(h0, h1, h2) < crown_base) {
             continue;
         }
+        v.i0 = i0;
+        v.i1 = i1;
+        v.i2 = i2;
+        v.h0 = h0;
+        v.h1 = h1;
+        v.h2 = h2;
         // only a triangle across the crown base is cut per fragment: one wholly above keeps every fragment, where an
         // interpolated height could round below a base it sits on
-        const cut_at_base = Math.min(h0, h1, h2) < crown_base;
-
-        const col_lo = Math.max(0, Math.ceil(Math.min(x0, x1, x2) - 0.5));
-        const col_hi = Math.min(width - 1, Math.floor(Math.max(x0, x1, x2) - 0.5));
-        const row_lo = Math.max(0, Math.ceil(Math.min(y0, y1, y2) - 0.5));
-        const row_hi = Math.min(height - 1, Math.floor(Math.max(y0, y1, y2) - 0.5));
-
-        for (let row = row_lo; row <= row_hi; row++) {
-            const cy = row + 0.5;
-
-            // Each edge function is linear along the row, `e(cx) = a - dy * cx`, and bounds cx on one side: the row's
-            // span, widened by a pixel each way so the exact tests below keep their say on the edges
-            let x_lower = -Infinity;
-            let x_upper = Infinity;
-            let dy = y2 - y1;
-            let a = (x2 - x1) * (cy - y1) + dy * x1;
-            if (dy > 0) x_upper = Math.min(x_upper, a / dy); else if (dy < 0) x_lower = Math.max(x_lower, a / dy); else if (a < 0) continue;
-            dy = y0 - y2;
-            a = (x0 - x2) * (cy - y2) + dy * x2;
-            if (dy > 0) x_upper = Math.min(x_upper, a / dy); else if (dy < 0) x_lower = Math.max(x_lower, a / dy); else if (a < 0) continue;
-            dy = y1 - y0;
-            a = (x1 - x0) * (cy - y0) + dy * x0;
-            if (dy > 0) x_upper = Math.min(x_upper, a / dy); else if (dy < 0) x_lower = Math.max(x_lower, a / dy); else if (a < 0) continue;
-
-            const span_lo = Math.max(col_lo, Math.ceil(x_lower - 0.5) - 1);
-            const span_hi = Math.min(col_hi, Math.floor(x_upper - 0.5) + 1);
-
-            for (let col = span_lo; col <= span_hi; col++) {
-                const cx = col + 0.5;
-
-                const e0 = (x2 - x1) * (cy - y1) - (y2 - y1) * (cx - x1);
-                if (e0 < 0 || (e0 === 0 && !own_0)) continue;
-                const e1 = (x0 - x2) * (cy - y2) - (y0 - y2) * (cx - x2);
-                if (e1 < 0 || (e1 === 0 && !own_1)) continue;
-                const e2 = (x1 - x0) * (cy - y0) - (y1 - y0) * (cx - x0);
-                if (e2 < 0 || (e2 === 0 && !own_2)) continue;
-
-                const l0 = e0 * inv_area;
-                const l1 = e1 * inv_area;
-                const l2 = e2 * inv_area;
-
-                if (cut_at_base && l0 * h0 + l1 * h1 + l2 * h2 < crown_base) continue;
-
-                const k = row * width + col;
-
-                if (!is_foliage) {
-                    T[k] = 0.0;
-                    flags[k] |= FLAG_DRAWN;
-                    continue;
-                }
-
-                if (T_foliage[k] === 0.0) {
-                    // an opaque leaf is already here: nothing behind or in front of it changes the pixel
-                    continue;
-                }
-
-                const u = l0 * uvs[i0 * 2] + l1 * uvs[i1 * 2] + l2 * uvs[i2 * 2];
-                const v = l0 * uvs[i0 * 2 + 1] + l1 * uvs[i1 * 2 + 1] + l2 * uvs[i2 * 2 + 1];
-                scratch_position[0] = u * atlas_w - 0.5;
-                scratch_position[1] = v * atlas_h - 0.5;
-                atlas.sampleChannelBilinearArray(scratch_sample, 0, scratch_position, 0, alpha_channel);
-                const alpha = clamp(scratch_sample[0] * alpha_scale, 0.0, 1.0);
-                if (alpha <= 0.0) continue;
-
-                const pass = 1.0 - alpha * blocked;
-                T[k] *= pass;
-                T_foliage[k] *= pass;
-                flags[k] |= FLAG_DRAWN | FLAG_FOLIAGE;
-            }
-        }
+        v.cut_at_base = Math.min(h0, h1, h2) < crown_base;
+
+        tri2_rasterize_barycentric(
+            raster.width, raster.height,
+            projected[i0 * 2], projected[i0 * 2 + 1],
+            projected[i1 * 2], projected[i1 * 2 + 1],
+            projected[i2 * 2], projected[i2 * 2 + 1],
+            v
+        );
     }
 }
 
+/**
+ * What one pixel of a triangle does to the raster: bark makes it opaque, a leaf passes what its alpha does not cover.
+ */
+const RASTER_VISITOR = {
+    /** @type {CrownRaster|null} */
+    raster: null,
+    /** @type {Float32Array|null} */
+    uvs: null,
+    /** @type {Sampler2D|null} */
+    atlas: null,
+    atlas_w: 0,
+    atlas_h: 0,
+    alpha_channel: 0,
+    alpha_scale: 1,
+    blocked: 1,
+    crown_base: -Infinity,
+    i0: 0, i1: 0, i2: 0,
+    h0: 0, h1: 0, h2: 0,
+    cut_at_base: false,
+    visit(col, row, l0, l1, l2) {
+        if (this.cut_at_base && l0 * this.h0 + l1 * this.h1 + l2 * this.h2 < this.crown_base) return;
+
+        const raster = this.raster;
+        const k = row * raster.width + col;
+
+        const uvs = this.uvs;
+        if (uvs === null) {
+            raster.transmittance[k] = 0.0;
+            raster.flags[k] |= FLAG_DRAWN;
+            return;
+        }
+
+        const T_foliage = raster.foliage_transmittance;
+        if (T_foliage[k] === 0.0) {
+            // an opaque leaf is already here: nothing behind or in front of it changes the pixel
+            return;
+        }
+
+        const i0 = this.i0, i1 = this.i1, i2 = this.i2;
+        const u = l0 * uvs[i0 * 2] + l1 * uvs[i1 * 2] + l2 * uvs[i2 * 2];
+        const v = l0 * uvs[i0 * 2 + 1] + l1 * uvs[i1 * 2 + 1] + l2 * uvs[i2 * 2 + 1];
+        scratch_position[0] = u * this.atlas_w - 0.5;
+        scratch_position[1] = v * this.atlas_h - 0.5;
+        this.atlas.sampleChannelBilinearArray(scratch_sample, 0, scratch_position, 0, this.alpha_channel);
+        const alpha = clamp(scratch_sample[0] * this.alpha_scale, 0.0, 1.0);
+        if (alpha <= 0.0) return;
+
+        const pass = 1.0 - alpha * this.blocked;
+        raster.transmittance[k] *= pass;
+        T_foliage[k] *= pass;
+        raster.flags[k] |= FLAG_DRAWN | FLAG_FOLIAGE;
+    }
+};
+
 /**
  * Marks the foliated part of the view: the morphological closing of the foliage's pixels by a ball of `radius_px`,
  * so a gap narrower than the ball's diameter is a microhole within the foliage and a wider one is a large gap

package/src/generation/foliage/analysis/foliage_measure_leaf_area.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"foliage_measure_leaf_area.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/analysis/foliage_measure_leaf_area.js"],"names":[],"mappings":"AAkBA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,oDATW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,wCAAwC,EAAE,oBAAoB,UACrE,OAAO,gCAAgC,EAAE,iBAAiB,UAC1D,OAAO,mCAAmC,EAAE,kBAAkB,GAAC,IAAI,UAEnE,OAAO,uDAAuD,EAAE,SAAS,GAEvE,eAAe,CAsI3B;;;;;WA3Ka,MAAM;;;;aACN,YAAY;;;;;kBACZ,YAAY;;;;;0BAEZ,MAAM;;;;2BAEN,MAAM"}
+{"version":3,"file":"foliage_measure_leaf_area.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/analysis/foliage_measure_leaf_area.js"],"names":[],"mappings":"AAYA;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,oDATW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,wCAAwC,EAAE,oBAAoB,UACrE,OAAO,gCAAgC,EAAE,iBAAiB,UAC1D,OAAO,mCAAmC,EAAE,kBAAkB,GAAC,IAAI,UAEnE,OAAO,uDAAuD,EAAE,SAAS,GAEvE,eAAe,CAsI3B;;;;;WA3Ka,MAAM;;;;aACN,YAAY;;;;;kBACZ,YAAY;;;;;0BAEZ,MAAM;;;;2BAEN,MAAM"}

package/src/generation/foliage/analysis/foliage_measure_leaf_area.js

@@ -5,14 +5,8 @@ import { tri2_rasterize_coverage } from "../../../core/geom/2d/triangle/tri2_ras
 import { tri2_signed_area } from "../../../core/geom/2d/triangle/tri2_signed_area.js";
 import { tri3_area } from "../../../core/geom/3d/triangle/tri3_area.js";
 import { StandardAttributes } from "../../../shade/renderer/geometry/StandardAttributes.js";
-import { TreeLODConfig } from "../config/TreeLODConfig.js";
 import { tree_mesh_build_foliage } from "../mesh/tree_mesh_build_foliage.js";
 
-/**
- * Every card the tree has: the full set, before any LOD decimates it or scales it up to compensate.
- * @type {TreeLODConfig}
- */
-const ALL_CARDS = new TreeLODConfig();
 
 const SCRATCH_TRIANGLE = new Float64Array(6);
 
@@ -72,7 +66,7 @@ export function foliage_measure_leaf_area(skeleton, attachments, config, cutout,
 		crown_leaf_area_index: 0.0
 	};
 
-	const geometry = tree_mesh_build_foliage(skeleton, attachments, config, ALL_CARDS, cutout);
+	const geometry = tree_mesh_build_foliage(skeleton, attachments, config, cutout);
 	if (geometry === null) {
 		return result;
 	}

package/src/generation/foliage/analysis/tree_crown_opacity.js

@@ -47,7 +47,7 @@ export function tree_crown_opacity(asset, {
 
     const level = asset.lods[lod];
     const foliage = level.foliage_geometry;
-    const atlas = foliage !== null ? asset.foliage_material.texture_albedo.image.source : null;
+    const atlas = foliage !== null ? level.foliage_material.texture_albedo.image.source : null;
 
     return crown_opacity_measure(level.bark_geometry, foliage, atlas, {
         microhole_radius,