1. Read his conifer, then match it with a mixture

Back to the tutorials. Code: stats.py, render.py (stage 0) and paint.quantize (final), in ~/work/pixelart-studies/elements/conifers/.

What to look at

Ferrari's only conifers in the Living Worlds index files are in V16, the alpine tarn: subalpine spires at three distances. The mid-distance spire at native (420,30)–(480,130) is the one to study, because it's small enough to count and big enough to have tiers.

Left: his pixels. Right: the same pixels painted by class (black, dark green, dark olive, lit).

Squint at the left and you'll say "a green tree with light on its left". The right panel says something else: the tree is black with light on it, and the light is everywhere, broken into tiny pieces.

Count it

Four classes of his palette indices, then each class's share of the tree and its mean horizontal and vertical run length. This is the whole of stats.py:

CLS = {'black': [62, 61, 60, 71], 'dgreen': [59, 72, 70], 'dolive': [73, 63, 55], 'lit': [58, 54]}

def classify_idx(sub):
    c = np.full(sub.shape, -1)
    for i, (k, v) in enumerate(CLS.items()): c[np.isin(sub, v)] = i
    return c

def runs(c, val):
    L = []
    for row in c:
        m = (row == val).astype(int); d = np.diff(np.r_[0, m, 0])
        s = np.flatnonzero(d == 1); e = np.flatnonzero(d == -1); L += list(e - s)
    return np.mean(L) if L else 0
def vruns(c, val): return runs(c.T, val)

The class lists are specific to V16's palette; I read them off a colour count of the crop. What came out:

V16 conifer	black	dark green	dark olive	lit olive	mean run (h / v)
mid-distance spire	0.47	0.03	0.23	0.27	~1.5 / 1.5 px in every class
near tree, right edge	0.65	0.02	0.24	0.09	lit 1.3 / 1.6
far trees across the tarn	0.53	0.19	0.15	0.13	1.4 / 1.4

The three rows show what changes with distance. The near tree is darker, with its light thinned to edges (how-to 2). The far trees trade dark olive for dark green, which is the haze starting.

His colours matter too. The lit family is olive and ochre, never leaf green: (143,151,35) and (151,163,63) over (79,83,19), with a warm brown (95,71,0) at its dark end. The shadow family runs from black to (0,31,15). My palette pulls every species' lit steps toward olive by a per-species amount (palette.SPECIES_ALB[sp]["olive"]: 0.45 for Douglas-fir, 0.15 for the blue-green Sitka spruce).

Why a threshold fails

A normal quantizer takes each pixel's light, compares it with a threshold, and adds a little dither. A lit pad of sprays sits well above the threshold, so the whole pad comes out as one step: a solid olive shape. My v4 had the right shares and lit runs of 3.7 px against his 1.4. At 1× it read as cut paper.

v1: the crown radius was half his (13% of height against his ~27%), so the tree was a pole with ticks.

v4: shares close, runs 2–3× his. Solid pads.

Draw from a mixture instead

Each foliage pixel draws its step from a three-way mixture: black, dark olive or lit olive. The probabilities are set by the light at that point. Value is carried by the proportions in a neighbourhood, and the family boundary stays hard: a pixel below the lit threshold can never draw a lit step. This is the code, still in the final painter, from paint.quantize:

lit = d > thr                                              # d = direct light at this pixel
v = np.clip((d - thr) / P.get("lit_span", 0.5), 0, 1)
v = np.clip(v + np.where(mark, P.get("mark_bias", 0.35), -P.get("body_bias", 0.15)), 0, 1)
pl = P.get("p_lit", 0.62) * v ** P.get("g_lit", 0.9)                  # P(lit olive, steps 6-7)
pd = P.get("p_dol", 0.6) * (1 - 0.5 * v) * np.clip(v * 3 + 0.3, 0, 1)  # P(dark olive, steps 4-5)
s_lit = np.where(r < pl, np.where(r2 < v * 0.6, 7, 6),
                 np.where(r < pl + pd, np.where(r2 < 0.5, 5, 4), 0))   # otherwise black
# the shadow family: mostly black, with dim flecks in proportion to sky light
sv = np.clip(a / P.get("amb_span", 0.35), 0, 1)
ps = P.get("p_fleck", 0.25) * sv + np.where(mark, 0.08, 0)
s_sh = np.where(r < ps, np.where(r2 < 0.5, 3, 2), np.where(r < ps * 2.2, 1, 0))
step = np.where(lit, s_lit, s_sh)

r and r2 are two uniform random fields per pixel. At near scales they're replaced by per-spray hashes and vertical-column noise (how-tos 2 and 4). mark flags the pixels drawn by stroke marks, which are a bit brighter than the 1-px body pixels between them.

Notice that the mixture has black in the lit family. Glimpses into the dark interior of the crown appear even in full sun. Ferrari's sunlit crowns are full of them.

The mixture, three settings of p_lit / p_dol. The texture is now his; the tiers are still flat bars.

Spurs make the silhouette

The last difference at 1× was the edge. His tiers end in spurs, the needled branch tip running out horizontally past the pad: every 2–4 rows, alternating sides, longer lower down. Mine were round clouds until I gave each branch's outer twig axis its own line of foliage points. In the final geometry that's the spur element (foliage_fast.foliage, the last block of the branch loop):

ns = max(2, int(0.35 * L / step))
su = np.linspace(0.65, 1.0, ns)                    # the outer 35% of the limb
spur.append((bi, _pts_at(pts, su) + rng.normal(0, step * 0.3, (ns, 3)), tang[-1], b["dir"], su))

Two more things matched him: a concave spire (crown_pow 1.25), and ragged branch lengths (len_jitter 0.35).

v10: the copy I stopped at. Shares within 0.03; lit runs 1.7–1.9 px against his 1.4.

Parameters

p_lit 0.62, p_dol 0.6, g_lit 0.9, lit_span 0.5, p_fleck 0.25, mark_bias 0.35. The value plan (lit_frac 0.42) sets thr (how-to 2).

Limits

The mixture gives his texture. It doesn't give his drawing: at 8× his tiers are regular drooping shelves, and his light is organised along them. That's the next page.