Painting land from above: a field guide by The aerial student
The working thread
Friday 25 September 2026, 20:44 (PDT), for 3 h 1 min. 296 steps, 106 images looked at.
This is the student's own thread: the brief it was given, what it wrote, each step it took, and every image it opened, shown as it saw it (possibly downscaled). Some of these images were later overwritten in the study folder, so this is the only place they survive. The raw record is the transcript.
The brief
A painting study: how land looks from above and far away, and how to say that in Mark Ferrari's painterly pixel-art language, built from oblique aerial photographs.
Target views:
- an iso view: about 30° down, orthographic, looking over a landscape from about 50 m to 2 km across;
- a far view: a high oblique over a valley or range, a few km across.
Subjects: forested mountain slopes, a river valley with meadows, a glacial cirque with a tarn and snow, scree and cliff bands, a coastline, and a village-scale clearing with a few huts and a fire. Frame 320×180 native (also try 640×360), shown 3× with nearest neighbour; a limited palette.
Your primary evidence is oblique aerial photography: photos taken from aircraft, drones or high viewpoints at roughly 20–45° down, the angle our iso camera uses, not straight-down map tiles. Straight-down orthophotos are secondary, useful only for measuring what things are and how big they are.
- A fast, working fetcher is at ~/work/pixelart-studies/tools/imgfetch.py (
python3 imgfetch.py "oblique aerial forested valley" -n 12 -o refs/valley --sheet,-f queries.txtfor many). Openverse is primary; Wikimedia Commons is a slow fallback. - Look at the photos yourself with the Read tool. Save what you use to refs/.
What to study in the photos, and measure (for the measuring approach, see ~/work/pixelart-studies/pedagogy/observation/ and transfer/measure/ratios.json):
- How a forest reads from above: crown clumping, gaps, edges, shadows as the texture.
- How slopes read by tone and shadow when the silhouettes are gone.
- How rivers, meadows, scree and snow read as shapes.
- How haze and depth work looking down.
- What scale each thing reads at. Then learn the translation into Ferrari's language: read ~/work/pixelart-studies/SYNTHESIS.md (the scaffold plus its portfolio of fine techniques), and study how Ferrari and other masters handle top-down and high views where you can find them (his colour-cycling scenes at effectgames.com canvascycle; classic top-down and isometric pixel-art landscapes).
The method is a portfolio of fine techniques, not one general program. Develop specific, tested techniques for far and iso: a crown-clump canopy stroke with its cast shadows, a slope-tone ramp, a river ribbon with its bank light, a scree fan from above, snow fields read by shadowed hollows, huts and fires legible at small scale. Each is proven by a focused study: photo | your pixels | the nearest master analogue, at 8×. Then compose them into scene plates, each judged beside an oblique photo of similar framing.
Deliverables in ~/work/pixelart-studies/aerial/:
- NOTES.md: what the photos taught (with numbers), each technique with its study image, and what fails;
- the code;
- studies/;
- sheets sweeping subject × distance/scale × light/hour × seed;
- refs/ with sources.tsv.
Look at every image you make, and iterate until you'd proudly show it. Work only in ~/work/pixelart-studies/ (read freely there, write in aerial/). Resources: nice -n 10, at most 4 threads. Don't optimize for speed.
The thread
Bash: Survey pixelart studies workspace
cd ~/work/pixelart-studies && ls && ls aerial 2>/dev/null; ls tools pedagogy pedagogy/observation transfer transfer/measure 2>/dev/null | head -80; wc -l SYNTHESIS.md
# output:
SYNTHESIS.md
aerial
forest-floor
grass
massing
moodboards
pedagogy
rock
shared
sky
snow
tools
transfer
water
pedagogy:
analysis
atelier
master-copy
observation
shared
pedagogy/observation:
LESSONS.md
__pycache__
blockin.py
compare_stats.py
contact.py
ferrari
ferrari_contours.py
fetch_refs.py
out
palette_card.py
pix.py
refs
sheets.py
studies
studies_profiles.py
tarn.py
tarn_v1_first_attempt.py
translate_studies.py
tools:
imgfetch.py
transfer:
__pycache__
boxes.py
contact.py
fetch_refs.py
gridview.py
lib
mapview.py
measure
measure_ratios.py
measure_subjects.py
notes_figs
plates
refs
run1.py
runmany.py
scratch
sheets
studies
study.py
subjects
transfer/measure:
atlas_pairs.png
atlas_subjects.png
ratios.json
subjects.json
107 SYNTHESIS.mdBash: Read synthesis and observation lessons
cd ~/work/pixelart-studies && cat SYNTHESIS.md && ls -la aerial && cat pedagogy/observation/LESSONS.md | head -150
# output:
# Painter core: one method (draft 1)
Synthesized by the integrator from the four pedagogy arms (`pedagogy/{atelier,master-copy,analysis,observation}`) and, secondarily, the seven topic studies.
Each rule is tagged:
- **[shown]**: a student implemented it and it visibly works in their sheets.
- **[measured]**: a student measured it in Ferrari's pixels or in photos.
- **[mine]**: my inference, not yet built by anyone.
This isn't a committee of special strengths. The arms converged on one machine independently, and the draft describes that machine.
## The convergence
Working alone, all four arms landed on the same architecture:
- **Paint indices, not colours.**
- Master copy found that Ferrari's index map is literally a form map: indices are bins of surface direction, and "the palette is the light". The same index image serves morning and afternoon. [measured]
- Atelier paints in "step space" along one material ramp. [shown]
- Sky found that two of Ferrari's hour pairs are identical pixels. [measured]
- Analysis found that value is the structure and colour is temperature and distance. [measured]
- **Two light families that never touch.** Atelier's terminator rule [shown], analysis's three-value picture plan with every mass kept inside its group [measured], and rock's lit and shadow groups [shown] are the same idea at two scales.
- **Dither mixes only adjacent steps of one ramp.** All four arms use it. Ordered 2×2 dither suits hard or precise things (rock, sky seams, water rows); random or diffusion dither suits organic texture (lawns, foam). Master copy measured this [measured]; analysis cites Ferrari's GDC talk for the same split.
- **The medium's own geometry.** Contours are clean runs (1:1, 2:1, 4-4-4 flats), measured on Ferrari's crests by analysis and atelier [measured]. Atelier redraws every major contour by snapping edges to clean ratios [shown]. Masses meet level ground or water in a dead-flat run with a 1-px darker contact line [measured: analysis, observation].
- **Clean runs are for narrow forms; mass boundaries are where texture ends.** David's correction (2026-09-25): the clean-run rule came from the *grass strokes*. It applies to anything narrow, drawn as a line: blades, cracks, joints, twigs, conifer spires, stems, a snowline drawn as a stroke. A 1–2 px form must be a clean run of 1:1, 2:1 or 4-4-4 steps, or it reads as noise [measured: analysis, atelier; the runs they found on crests are this rule too, since a crest line against the sky is drawn as a stroke]. A *mass outline* isn't drawn as a line. A textured mass (grass mound, foliage, scrub, scree) ends in a fringe: blade tips break its top, dark holes open along the crest with lit peaks just behind, and the form turns through mark density [measured: master copy C2 and C3, "far crest has dark holes (40%)"; C4, "the silhouette against the water is not an edge but a fringe"]. **Failure seen:** master copy's final painter drew its hillock boundary as a clean contour and gBash: Read rest of lessons and transfer layout
cd ~/work/pixelart-studies && sed -n 150,400p pedagogy/observation/LESSONS.md; head -c 3000 transfer/measure/ratios.json; echo; ls transfer/lib transfer/studies transfer/plates transfer/refs | head -60; ls shared moodboards pedagogy/master-copy pedagogy/shared | head -80 # output: The primitives these studies produced (`clean_profile`, `majority_clean`, clustered dither, horizontal-run resampling, stroke blades) are what `tarn.py` uses. ## 5. The method (`tarn.py`) **Stage 1, observe.** A small scene model at 320×180: - a signed-distance granite corestone: a rounded box, tapered toward a dome, tilted, with broad weathering dents, optionally split by a joint, and sunk 22–36% into the bank; - a bank heightfield with 3–4 m hummocks and 1 m tussocks; - a near bank and a promontory lip, and the tarn out to a far shore 70–110 m away with conifers (mark-painted, heights in metres) and three layers of faceted peaks. Light model: sun at 4.5°; sun colour warm orange; sky fill violet; bounce from lit grass, arriving from below and away from the sun; soft shadows (grass visibility tested from the blade tops); AO; blade translucency when back-lit. The water is a rippled Fresnel mirror that ray-traces the scene again. Output is a G-buffer: material, depth, normal, sun visibility, n·l, bounce, AO, height above ground, what each water pixel reflects, and the wind-lines. **Palette, 31 colours.** Every entry comes from the light model evaluated at a *canonical light state*, so the palette is the observation, quantised deliberately: - grass lit family: crest, tan, ochre, dark-green gap; - grass shadow family: dark olive, darker olive, black; plus one mid tone for reflections; - rock: contact, core, bounce shadow, sky-lit half, lit, rim; - sky: 8 colours spaced evenly along the path from 35° down to the horizon; - far: 4 colours, k-means of the mountains; - water: 4 colours, the sky ramp darkened as Fresnel predicts; - one accent (sun disk and glitter when back-lit, otherwise the hottest grass tip). **Stage 2, translate.** Each material is painted with its study's vocabulary: sky bands with checker strips; faceted mountains; mark-painted trees and far bank; water reflections as horizontal runs one step darker, checker for mirrored sky, light and dark waterlines, solid wind-lines; emergent sedge in the shallows (r19) with broken dark reflections; rock by ramp coordinate with fall-line flecks, rim and contact. Grass is painted last: stippled family choice from the light amount, crest bands on sun-facing tops, then 1-px blades far to near, depth-tested so near tips overlap the water and the boulder's foot. Blade length is set by projecting 0.3 m blades, which is how distance changes the grass from stroke to stipple, as observed. **Parameters.** Size (1.1 / 1.9 / 2.9 m); light direction (sun azimuth −105°, 170°, +105°, −14° relative to the view, so left and right are raking side-light); distance (5.5, 10, 40 m); seed (boulder shape, dents, joint, sink depth, shoreline, bank position, tree density, peaks, ripples). ## 6. Honest comparison **Against the photos, what carries over:** - The dusk notan: sky and water light, land dark. - The boulder's plateau-and-cliff light, with a core band, a warm bounce-lit shadow side, a sky-lit viol
Bash: Look at shared refs and transfer code sizes
cd ~/work/pixelart-studies && ls shared/refs shared/scenes | head -50; ls transfer/*.md transfer/studies transfer/sheets 2>/dev/null | head -40; wc -l transfer/lib/*.py transfer/*.py; cat tools/imgfetch.py | head -60
# output:
shared/refs:
ferrari_alpine_tarn_dusk.png
ferrari_mossy_forest_pool.png
ferrari_snow_forest_boulders.webp
shared/scenes:
SCENES.md
tarn_dusk.json
(eval):1: no matches found: transfer/*.md
107 transfer/lib/camera.py
130 transfer/lib/canvas.py
143 transfer/lib/geom.py
181 transfer/lib/light.py
196 transfer/lib/measure.py
89 transfer/lib/noise.py
97 transfer/lib/paint.py
170 transfer/lib/prims.py
31 transfer/lib/scene.py
129 transfer/lib/tech_blocks.py
67 transfer/lib/tech_grass.py
161 transfer/lib/tech_ground.py
195 transfer/lib/tech_logs.py
47 transfer/lib/tech_sky.py
366 transfer/lib/tech_sprites.py
149 transfer/lib/tech_water.py
9 transfer/boxes.py
12 transfer/contact.py
36 transfer/fetch_refs.py
11 transfer/gridview.py
32 transfer/mapview.py
137 transfer/measure_ratios.py
88 transfer/measure_subjects.py
15 transfer/run1.py
31 transfer/runmany.py
75 transfer/study.py
2704 total
#!/usr/bin/env python3
"""imgfetch: fast, polite reference-image sourcing (Wikimedia Commons + Openverse).
python3 imgfetch.py "cinder cone scoria slope" -n 12 -o refs/cinder
python3 imgfetch.py -f queries.txt -n 8 -o refs # one query per line; subdir per query
options: --src commons,openverse --width 1200 --sheet (writes <out>/_sheet.jpg)
Writes images plus <out>/sources.tsv (file, title, license, author, page url).
Cached: files already present are skipped. Handles 429/5xx with Retry-After backoff.
Parallel downloads (4 workers) with a shared per-host rate limiter (~3 req/s; Wikimedia's media
host is kept to 1 per 2 s and slows further on any 429, since it throttles hard per IP after bursts).
Openverse (mostly Flickr-hosted CC images) is the primary source because it stays fast.
"""
import argparse, concurrent.futures as cf, json, os, re, sys, threading, time, urllib.error, urllib.parse, urllib.request
UA = "pixelart-studies-imgfetch/1.0 (research; contact: local)"
_locks = {}; _last = {}; _glock = threading.Lock()
SLOW_HOSTS = {"upload.wikimedia.org": 2.0} # Wikimedia media host: ~1 req/s or it 429s
def _throttle(host, min_gap=0.34):
min_gap = SLOW_HOSTS.get(host, min_gap)
with _glock:
lk = _locks.setdefault(host, threading.Lock())
with lk:
dt = time.time() - _last.get(host, 0)
if dt < min_gap:
time.sleep(min_gap - dt)
_last[host] = time.time()
def get(url, tries=4, timeout=25):
host = urllib.parse.urlparse(url).netloc
if host == "upload.wikimedia.org":
tries = 2 # fail fast; other sources fill in
for i in range(tries):
_throttle(host)
try:
req = urllib.request.Request(url, headers={"User-Agent": UA})
return urllib.request.urlopen(req, timeout=timeout).read()
except urllib.error.HTTPError as e:
if e.code == 429:
with _glock:
Bash: Start background oblique aerial reference fetch
mkdir -p ~/work/pixelart-studies/aerial/refs && cd ~/work/pixelart-studies/aerial/refs && cat > queries.txt <<'EOF' aerial view forested mountain slope drone forest canopy oblique aerial conifer forest hillside aerial river valley meadow drone river meadow valley aerial view alpine valley river glacial cirque tarn aerial cirque lake snow mountain from above alpine tarn from above scree slope from above cliff bands mountain aerial talus fan mountain aerial coastline cliffs drone rocky coast forest aerial view coast beach forest aerial village clearing forest drone hut clearing forest campfire from above aerial view mountain range haze aerial valley haze mountains drone view pine forest shadows aerial view snowfield mountain EOF nohup nice -n 10 python3 ../../tools/imgfetch.py -f queries.txt -n 14 -o . --sheet > fetch.log 2>&1 & echo started # output: started
Bash: Read scenes and master-copy lessons
cd ~/work/pixelart-studies && cat shared/scenes/SCENES.md | head -60; head -80 pedagogy/master-copy/LESSONS.md; ls pedagogy/master-copy/ref pedagogy/master-copy/crops | head # output: # Sample scene specs These are the kinds of scenes a painter will be asked to paint. A "scene spec" says what is where, and what the light and camera are, in the terms a world simulation knows. It is not a picture. You decide how to turn it into one. Feel free to change them, add your own, or define your own spec format; the scene-spec JSON files beside this document are one possible shape. Target frame: 640×360 native pixels, shown upscaled 3× with nearest neighbour. Limited palette per scene: think Amiga, 32–64 colours, ramps chosen deliberately. Cameras the painter must handle: - **iso**: about 30° down, orthographic. - **landscape**: 8–15° down, perspective, with a horizon and sky. - **close**: scene-scale, one person is ~20–30 px tall. ## 1. Alpine tarn at dusk (landscape camera) - A small lake, 40 m across, in a glacial cirque at 2,000 m. Its far shore is a granite headwall 150 m high. - A talus apron, blocks 0.3–3 m, fans from gullies in the headwall down to the water. - Snow lies in the gullies and in patches on ledges. - A near shore of grass and sedge hummocks, some boulders 1–2 m, and a stand of spruce on the right. - Two distant ridges behind the headwall; the farthest is 8 km away. - Sun low in the west, behind the camera's left shoulder, warm; sky pink to violet; still air, so the water mirrors. ## 2. Snowy forest path (close camera) - Old spruce and fir forest, trunks 0.6–1.2 m thick. - 40 cm of fresh snow; a trodden path winding away through a gap. - Rounded boulders, 0.5–2 m, capped with snow. - Snow falling lightly; overcast. - A distant rock spire seen through the gap. ## 3. Mossy forest pool (close camera) - An ancient broadleaf tree with a buttressed, twisted trunk. - Moss-covered rocks, a small spring pool, and a 40 cm waterfall where it spills. - Ferns and broad-leafed plants in the foreground. - Dappled light through the canopy. ## 4. Hillside pasture, midday (iso camera) - A convex grassy hillside, 25° slope, with a few limestone outcrops breaking through. - Scattered hawthorn and birch. - A stream in a small gully with gravel bars. - A flock of 12 sheep. - Sun high, from the south-east. ## 5. Scree slope and cliff band (landscape camera) - Bedded sandstone and shale in a cliff band 30 m high, with ledges. - Below it, a scree cone: fine at the apex, coarse at the toe. - Pines rooted on the ledges and at the scree edge. - A goat trail crosses the scree. - Morning light from the east, cool shadows. ## 6. Coast (iso camera) - A shingle and sand cove between two rocky headlands. - Waves breaking; wet sand band; rock pools; kelp at the tideline. - Dune grass behind the beach. - Afternoon. # Master copies after Mark Ferrari: a boulder at a tarn, at dusk Everything here was made by programs in `src/`. Each copy is shown beside Ferrari's original: the top row is the whole crop at 3×, the bottom row an 8× detail (the red box). The deliverable painter is `src/tarn.py`, and its parameter sheets are in `out/sheet_*`.nice -n 10 python3 study_canopy.py # etc., one per study nice -n 10 python3 plates.py [name ...] [--big] # 4 worker processes nice -n 10 python3 sheets.py [scale|light|seed|far] ``` Scenes are built once and cached in `cache/` (delete a file there after changing its builder; the cache key is only the builder's name and keyword arguments). --- ## 1. What the photos taught (numbers) All numbers are CIE L\* (0-100) and chroma C\*, measured on the photos in `refs/` with `measure_photos.py` / `measure_haze.py`. Crown detection draws its circles onto `measure/crowns_*.png`; I checked each by eye before trusting a number. ### Forest from above (the photos at 20-45 deg down) - **Conifers stay upright spires even from above.** At 30-45 deg down you still see each crown's side: a lit cap on top and on the sun side, the shade side and the gap below dark. Crowns are elongated vertically on screen: the high-pass autocorrelation length y/x is **1.25-1.5** for dense conifer stands (Alsek, Deer Mountain near); broadleaf canopy is isotropic or wider than tall (**0.4-0.8**). - **Spacing / lit-cap radius is 2.2-2.9 in every canopy photo** (2.3-2.5 for closed stands, 2.7-2.9 for open ones). The dark seams between crowns are narrow: the lit fraction of the high-passed canopy is **0.35-0.56**. So a forest from above is *mostly lit caps with narrow dark seams*, not dark with lit dots. - **The value range lives inside the stroke.** Lit cap vs gap, per canopy: dawn near 19 vs 1, overcast near 53 vs 30, sunlit broadleaf 70 vs 24 (46 L\* inside a single crown), while the squinted mass is flat. The same rule the pedagogy arms found for grass. - **The terrain is read through the canopy's value.** On Deer Mountain and the NRCS slopes the forest on slopes turned from the sun is one or two value steps darker than on sun-facing slopes; that, plus meadow gaps and tracks, is how a forested hillside keeps its shape. - **Lone trees stand up by their shadows.** On the NRCS meadow photo each tree's shadow is a pool about as long as the tree on the ground, flattened by the view (x0.5 at 30 deg down). ### Slopes, rock, snow - **Rock from above is two families that take two different colours.** Sawtooth (Idaho): lit granite L\*85 warm (hue 67 deg), shaded faces L\*51 **blue** (hue 245, C\* 16): 33 L\* apart and a hue flip, because the shadow is lit by the sky. Each facet inside a family is nearly flat. - **Snow is flat in the light; all its drawing is in the shade.** Shaded snow on Sawtooth is L\*76, still lighter than *lit* shaded rock and 25 above shaded rock. Lit snow is one value. The shapes of the shadowed hollows are what say "snow field" (Neve Glacier, North Cascades B&W, Marcus Merlon). - **Scree is sorted**: fine at the apex, blocks at the toe (Isfjorden cones, Canyon de Chelly); it is striped along the fall line by debris channels; from far away only texture density says "scree". - **Cliff bands** (Isfjorden, North Cascades): risers are planes, each ledge a lighter line (often snow) with a dark line under it, gullies cut through as dark slots. ### Water - **Water from above is a dark mirror.** Looking steeply down (Cosumnes, near) the river is L\*23, darker than both canopy (53) and a sunlit field (68), and nearly colourless (C\* 3). At grazing angles farther up the same river it is sky: L\*45, C\* 32, sky hue. The tarn on Sawtooth is L\*46 blue. Fresnel predicts 2-5% reflectance at 30-40 deg down and 15-20% at 10-15 deg. - **The coast is zoned by depth**, not by distance from shore: turquoise over sand where shallow, dark over rock and kelp, deep blue beyond; surf is broken white crests parallel to the depth contours with a lace of foam thinning landward (Ocean Coast, Costa Brava, Hailing Island). ### Haze looking down (Blue Ridge, high oblique) From the bottom of the frame (near) to the far land, per image row: - black point (p5 L\*) rises **0.5 -> 48**; the value range (p95-p5) collapses **45 -> 9**; - b\* goes **0 -> -14** (blue); median L\* 2 -> 52. Far masses become two flat values (lit / shade) close together, lifted and blue. This is also exactly Ferrari's depth-band behaviour (master copy: the lit colour holds, the shadow shifts). ### Scale: what reads at what size (at 30 deg down, 320x180) | thing | reads as | at | |---|---|---| | a conifer | tiered spur strokes (spire, drooping tiers, tip highlight) | crown >= 5 px (<= 1.3 m/px for a 7 m crown) | | a conifer | lit arrowhead over dark notch (spire mark) | crown 3-5 px | | a forest | a lit surface with 1x2 lit-head/dark-stem dashes | crown < 3 px | | a hut | two roof planes + shadow + one lit eave wall | >= 8 px long (<= 0.6 m/px) | | a hut | a 2-value blob with a shadow | 4-8 px | | a fire | 1-2 px flame + ember ring; smoke plume | any; at dusk its glow pool 3-6 px | | a river | ribbon with lip + far-edge light | >= 3 px wide; below that a 1-px light line | | scree blocks | stones (light top row, dark bottom + shadow) | block >= 1.6 px | --- ## 2. How Ferrari handles high views He never painted a true iso or aerial scene; the nearest high views are **V02 Mountain Fortress** (rivers seen from high up), **V11AM Approaching Storm** (a river valley below), **V14 Mountain Storm** (far forest lowlands), **V16/V16PM Mirror Pond** (conifers), **V19 Mountain Stream** (blockfield, rock planes with snow ledges), **V17 Ice Wind** (snow), **V29 / V07** (surf), **V01 Island Fires**, **V15 Harbor Town**. What transfers: - far forest = **one flat tone plus a sparse stipple of a second** (V14), not individual trees; - rivers from high up = the **lightest thing on the land**, sky colours in flat bands, meanders foreshortened into long horizontal runs with short vertical steps (V02); - rock = planes of flat colour with a 1-2 px lit lip, snow on ledges as bright strips (V19); - snow = sky-violet shade shapes on flat light (V17); - surf = white-to-blue 3-step dashes, diffusion dithered (V29, V07); - fire = 3-4 colour ramp, smoke as a dithered drifting column (V01); - buildings = flat planes, 1-px light ridge line, black openings (V15). --- ## 3. The techniques (each with its study image) The scaffold is thin (`lib/painter.py`): G-buffer from the heightfield (`lib/terrain.py`, ray marcher, sun shadows, concavity, flow) -> index canvas of (material, step, depth band) (`lib/canvas.py`) -> palette computed from a light state (`lib/pal.py`) with a palette budget (merge the closest rarely used colours until <= 64). Everything else is a technique. ### T1 crown-clump canopy stroke with cast shadows -- `studies/canopy.png` Trigger: forest; the regime is chosen by crown width in pixels. - **>= 5 px (sprite)** `tech_canopy.conifer_sprite`: two layers. 1. The *lit-cap gradient* from the photos: light available falls from the top of the crown to the base, by stand density (`occl` = neighbours within 2 crown widths): a lone tree stays lit to the ground, a stand tree only at the top. 2. *Ferrari's strokes* on top: 1-px spire, tiers of spurs every 2-3 rows that droop at the ends, the sun-side spur tip a highlight, the tier notches one step darker. Per-tree tone: +-1 step from species variation and from **the slope under the tree** (n.sun relative to flat ground), which is what lets the terrain read through the forest. - **3-5 px (spire mark)** `spire_mark`: lit tip and sun-side lit column over a dark body, notches every 2 rows. - **< 3 px (canopy surface)** `canopy_height` + `paint_canopy_surface`: every crown is rasterised as a cone/dome bump on the terrain, the surface is ray-marched and lit like ground; the shade side of a crown is the reflected-light step (the photos: only 20-25% of the canopy is dark); sunlit apices get the highlight with the pixel under it a step down; pits between crowns are the darkest step. Below ~2.5 px the bumps are smoothed away and marks become a blue-noise stipple of 1x2 lit-head / darker-stem dashes at density 0.13 (Ferrari V14: flat tone plus sparse stipple). - **Far, no instances** (`stand_only` in `painter.py`): the forest is the cover field raised by tree height and painted as the canopy surface, so a few-km view never touches individual trees. - **Cast shadows** of instanced trees: an ellipse from the base away from the sun, length h\*cot(alt), width the crown; it moves the ground under it into its **shadow family keeping its texture** (`Canvas.to_shadow`), not to a flat dark. Measured on my plates with the photo statistic: spacing/radius **2.2-2.5** (photos 2.2-2.9), elongation y/x **1.44-1.75** (photos 1.25-1.5: mine slightly too vertical), lit fraction **0.54-0.56** (photos 0.35-0.56). ### T2 slope-tone ramp -- visible in every plate; `tech_ground.py` Trigger: open ground with no silhouettes (meadow, dry grass, rock, scree, snow at any scale). - Step coordinate from n.l in the lit family, from sky view in the shadow family, with a **hard jump at the terminator** (no dither across it). - **Posterised into planes**: `flat_bands` holds each step flat and dithers only a narrow seam (Bayer 4x4 for rock and snow, blue noise for organic ground). - **Cavity and spur tone**: gullies (concavity below -2.5 x metres per pixel) one step down in both families; spurs one step up in the light. At a few km this is what draws the mountain (`range_far`). - Grain: isotropic stipple of +-1 step at 11% for meadow/sand/soil; sparse fall-line flecks for rock. ### T3 river ribbon with its bank light -- `studies/river.png` Trigger: water level above ground (`tech_water.paint_water`). - Every water pixel traces its reflected ray through the terrain + canopy: land in the mirror -> step 1 (the far bank's trees hang down into the water as a dark band); sky -> step 2-4 by Fresnel (x1.8 stylisation) and sky elevation, posterised in flat bands. - Marks: the lowest water row (the near bank's lip) the darkest step; the top row (far waterline) one step lighter; 2-5 px horizontal streaks one step lighter (density by flow); glint when the sun mirrors toward the camera. - Banks: a 1.5 px bare-soil strip along the channel (the cut bank), gravel point bars only on the inside of bends (curvature sign). - The water ramp is built from the sky colours, not an albedo (`pal.water_ramp`); the body colour was set between the measured tarn (L\*46) and the steep river (L\*23). ### T4 scree fan from above -- `studies/scree.png` Trigger: scree cover; `apron` (1 apex -> 0 toe) from the subject. - Clast size grows toward the toe (0.12 m -> 2.5 m, `size ~ (1-apron)^1.6`); matrix stipple density grows with it. - Blocks >= 1.6 px are instanced sprites (`stone_sprite`): a flat lit top row with 45-deg ends, a mid body, a dark bottom row, the sun-side end lighter, and a one-row cast shadow shifted to the shade side. Coverage 0 at the apex -> ~70% at the toe. - Debris channels: fall-line grooves one step down with a lit levee beside them. - First attempt (Voronoi cells shaded as stones everywhere) read as cobbled paving; replaced by sprites on a quiet matrix. ### T5 cliff bands -- `studies/cliff_snow.png` (top) Trigger: rock with ledges (`extras['ledge']` from the subject's terraced height). - Risers: slope tone, with **planar facets stretched along the fall line** (`landform.facets`, cells elongated 3:1) so rock breaks into flutes, not bricks (isotropic facets read as a brick wall). - Each ledge: snow strip (lit 4 / shade 2, front edge one step down) or a lit rock lip; the first riser pixel under it one step down. ### T6 snow fields read by shadowed hollows -- `studies/cliff_snow.png` (bottom) Trigger: snow cover (`tech_rock.paint_snow`). - Lit snow: two flat values only (glare on sun-facing, lit elsewhere), a half step for concave hollows the sun still reaches; shadowed snow: core just past the terminator, reflected light deeper in (the blue shapes do the drawing). - The downhill edge a darker lip; rocks poke through as isolated pixels along the edge (4%). ### T7 huts and fires legible at small scale -- `studies/huts_fire.png` Trigger: hut and fire objects (`tech_objects.py`). - Huts are rasterised from their planes by point splatting into the index canvas: two roof planes (lit / shade), gables, walls, a black door; marks: eave line one step down, 1-px ridge highlight. - The cast shadow (convex hull of the hut's projection along the sun) goes in first, moving the ground into its shadow family. - A trodden-soil apron around each hut and footpaths along a minimum spanning chain. - Fire: ember ring + 1-2 px flame of the hottest colours; smoke drifting downwind as sparse light pixels thinning with height; at dusk a dithered glow pool of the fire ramp's low steps. ### T8 coast -- `studies/coast.png` Trigger: sea level (`tech_water.paint_sea`). - Shallow ramp by depth (0-4 m) in flat bands with Bayer seams; deep water beyond with sparse glints. - Surf: crests where depth crosses 0.6 / 1.4 / 2.4 m (+ a slow wave), broken by noise; foam lace landward of each crest with density falling as (1 - d)^2; the trough below each crest one step down. - Swash: a white edge on the water line; wet sand: a darker band just above it. ### T9 aerial perspective looking down -- `plates/range_far*.png`, `sheets/sheet_far.png` Trigger: perspective camera. - Depth bands by ray distance with **dithered seams** (threshold x 6% of distance). - Palette per band mixes toward the light's haze colour (0 / 22 / 45 / 68%), which lifts the black point and compresses the range as measured (Blue Ridge: p5 0.5 -> 48, range 45 -> 9). - **Band collapse**: in band 2 a material keeps its two family tones plus the darkest accent; in band 3 lit/shade only (Ferrari's far masses; also what keeps the palette inside 64). --- ## 4. Plates and sheets Plates (`plates/`): forest slope, river valley, cirque (iso and far), headwall + scree, coast, village (day and dusk), range (afternoon and evening), each beside an oblique photo with similar framing, box-downsampled to 320x180 and shown 3x. 640x360 versions: `plates/*_640.png`. Sheets (`sheets/`): `sheet_scale` (subject x 5 scales; the canopy hand-off from spur strokes to spire marks to canopy surface), `sheet_light` (subject x morning/noon/afternoon/evening/overcast: the same index canvas re-lit by the palette), `sheet_seed` (subject x 4 seeds), `sheet_far`. --- ## 5. What fails (honest list) - **Forested slope plate**: at 1.3 m/px the forest reads as an even texture. The photo reads by the terrain: a ridge crest against the far valley, meadow gaps, a track. The slope-under-the-tree tone helps a little; what is missing is composition (a crest, a road) and a stronger terrain shadow on the canopy. My crowns are also ~15% too vertical (y/x 1.44-1.75 vs 1.25-1.5). - **Cirque iso**: the headwall geometry is convincing, the cirque floor is not: a flat saturated meadow where the photos show pale rock with sparse trees and snow. Snow cover is too low and speckled at far scale (the snow mask is thresholded noise, not accumulation physics). - **Headwall/scree plate**: the scree apron barely reaches the frame; the talus cones only read in the dedicated study (`talus_cone` subject). In the cirque the apron is too shallow and loses to meadow. - **Range far**: my range is more alpine (rock-dominated) than the photo it is judged against; the meadows above the treeline are underrepresented. The dithered band seams are visible as faint rings on flat valley floors. - **Cirque far**: needed a 1.8 km world so the edge of the world is off-frame; far snow is salt-and-pepper. - **River**: the valley edges are straighter than any photo; the forest walls are too uniform. - **Water at iso** is still darker and flatter than Ferrari would paint it (he makes water the lightest land thing at distance; physics says a steep view gives a dark mirror; I compromised). - **Deep sea** is one flat colour with glints; Ferrari bands it. - Rock colour is a neutral violet-grey everywhere; the photos' warm lit / blue shade hue flip is only partly carried by the palette (shade steps are cooler, lit ones not warm enough). - Everything is Python; a far plate takes ~60 s mostly in erosion and the ray marcher.n</pre></details><details class="step"><summary><code>Bash: Find local Ferrari canvascycle data</code></summary><pre>cd ~/work/pixelart-studies && find . -iname "*LBM*" -o -iname "*canvascycle*" | head -30; ls pedagogy/master-copy/src pedagogy/master-copy/ref | head -60 # output: ./sky/refs/contact_ferrari_canvascycle.png ./grass/tools/lbm2png.py ./rock/refs/lbm2png.py pedagogy/master-copy/ref: lw native.png pedagogy/master-copy/src: __pycache__ c1_sky_rock.py c2_mound.py c3_bank.py c4_water.py c5_boulder.py compare.py cropinfo.py fl.py lw2png.py lwload.py pair.py palsheet.py runs.py sheets.py strandstats.py tarn.py zoom.py</pre></details><details class="step"><summary><code>Bash: List Living Worlds scene files</code></summary><pre>cd ~/work/pixelart-studies && ls pedagogy/master-copy/ref/lw; cat pedagogy/master-copy/src/lw2png.py | head -50; find . -name "*.json" -path "*lw*" | head; find . -iname "*.png" | grep -i -E "V[0-9]+|ferrari" | head -40 # output: V01.json V01.png V02.json V02.png V09.json V09.png V11AM.json V11AM.png V13.json V13.png V14.json V14.png V16.json V16.png V16PM.json V16PM.png V19.json V19.png V19PM.json V19PM.png V29PM.json V29PM.png V30.json V30.png """Convert Living Worlds LBM.json (JS object literal) to PNG (base palette, no cycling).""" import sys, re, json, glob, os import numpy as np from PIL import Image for f in glob.glob('ref/lw/*.json'): t=open(f).read() t=re.sub(r'([{,])\s*([A-Za-z_]+)\s*:', r'\1"\2":', t).replace("'",'"') d=json.loads(t) w,h=d['width'],d['height'] pal=np.array(d['colors'],dtype=np.uint8) px=np.array(d['pixels'],dtype=np.int32).reshape(h,w) Image.fromarray(pal[px]).save(f.replace('.json','.png')) print(f,w,h,len(np.unique(px)),'cycles',len(d.get('cycles',[]))) ./pedagogy/master-copy/ref/lw/V19PM.json ./pedagogy/master-copy/ref/lw/V30.json ./pedagogy/master-copy/ref/lw/V01.json ./pedagogy/master-copy/ref/lw/V29PM.json ./pedagogy/master-copy/ref/lw/V16.json ./pedagogy/master-copy/ref/lw/V19.json ./pedagogy/master-copy/ref/lw/V16PM.json ./pedagogy/master-copy/ref/lw/V02.json ./pedagogy/master-copy/ref/lw/V14.json ./pedagogy/master-copy/ref/lw/V11AM.json ./grass/refs/ferrari_V13.png ./grass/refs/ferrari_V04.png ./grass/refs/ferrari_V14.png ./grass/refs/ferrari_V02.png ./grass/refs/ferrari_V16.png ./grass/refs/ferrari_V09.png ./grass/plates/figs/fig_ferrari_study.png ./grass/refs/crops/V13_bottom.png ./grass/refs/crops/V16_litbank_5x.png ./grass/refs/crops/V16_nearleft_6x.png ./grass/refs/crops/V16_nearedge_6x.png ./grass/refs/crops/V16_rightmid_5x.png ./grass/refs/crops/V04_left.png ./grass/refs/crops/V16_left.png ./grass/refs/crops/V04_right.png ./grass/refs/crops/V16_island_6x.png ./grass/refs/crops/V16_right.png ./grass/refs/crops/V16_leftfar_6x.png ./grass/refs/crops/V16_rightedge_6x.png ./pedagogy/shared/ferrari_alpine_tarn_dusk.png ./sky/refs/ferrari_cc_V26SNOW.png ./sky/refs/study_ferrari_V04_deck.png ./sky/refs/study_ferrari_cloud_lost_edges.png ./sky/refs/study_ferrari_V16_peak.png ./sky/refs/ferrari_cc_V29PM.png ./sky/refs/ferrari_cc_V16PM.png ./sky/refs/ferrari_cc_V07.png ./sky/refs/ferrari_cc_V13.png ./sky/refs/contact_ferrari_canvascycle.png ./sky/refs/ferrari_cc_V04.png ./sky/refs/ferrari_cc_V14.png ./sky/refs/ferrari_cc_V28.png ./sky/refs/ferrari_cc_V29.png ./sky/refs/ferrari_cc_V15.png ./sky/refs/ferrari_cc_V01.png ./sky/refs/ferrari_cc_V17.png ./sky/refs/study_V19_vs_V19PM_same_pixels.png ./sky/refs/ferrari_cc_V02.png ./sky/refs/ferrari_cc_V16.png ./sky/refs/ferrari_mossy_forest_pool.png</pre></details></div> Let me view the contact sheet of Ferrari's canvascycle scenes to find high/far views. <div class="steps"><div class="step"><code>Read: sky/refs/contact_ferrari_canvascycle.png</code></div></div>  *1. sky/refs/contact_ferrari_canvascycle.png* <div class="steps"><details class="step"><summary><code>Bash: List Ferrari canvascycle images and sizes</code></summary><pre>cd ~/work/pixelart-studies && ls sky/refs/ | head -80; python3 -c " from PIL import Image;import glob for f in sorted(glob.glob('sky/refs/ferrari_cc_*.png')): print(f, Image.open(f).size)" # output: contact_ferrari_canvascycle.png ferrari_alpine_tarn_dusk.png ferrari_cc_V01.png ferrari_cc_V02.png ferrari_cc_V04.png ferrari_cc_V07.png ferrari_cc_V09.png ferrari_cc_V11AM.png ferrari_cc_V13.png ferrari_cc_V14.png ferrari_cc_V15.png ferrari_cc_V16.png ferrari_cc_V16PM.png ferrari_cc_V17.png ferrari_cc_V19.png ferrari_cc_V19AURA.png ferrari_cc_V19PM.png ferrari_cc_V26SNOW.png ferrari_cc_V28.png ferrari_cc_V29.png ferrari_cc_V29FOG.png ferrari_cc_V29PM.png ferrari_mossy_forest_pool.png ferrari_snow_forest_boulders.png ghibli_kazetachinu024.png ghibli_laputa004.png ghibli_mononoke024.png ghibli_omoide033.png ghibli_omoide036.png study_V19_vs_V19PM_same_pixels.png study_ferrari_V01_dusk_bands.png study_ferrari_V04_deck.png study_ferrari_V13_planes.png study_ferrari_V16_peak.png study_ferrari_cloud_lost_edges.png study_ferrari_tarn_sky_bands.png sky/refs/ferrari_cc_V01.png (640, 480) sky/refs/ferrari_cc_V02.png (640, 480) sky/refs/ferrari_cc_V04.png (640, 480) sky/refs/ferrari_cc_V07.png (640, 480) sky/refs/ferrari_cc_V09.png (640, 480) sky/refs/ferrari_cc_V11AM.png (640, 480) sky/refs/ferrari_cc_V13.png (640, 480) sky/refs/ferrari_cc_V14.png (640, 480) sky/refs/ferrari_cc_V15.png (640, 480) sky/refs/ferrari_cc_V16.png (640, 480) sky/refs/ferrari_cc_V16PM.png (640, 480) sky/refs/ferrari_cc_V17.png (640, 480) sky/refs/ferrari_cc_V19.png (640, 480) sky/refs/ferrari_cc_V19AURA.png (640, 480) sky/refs/ferrari_cc_V19PM.png (640, 480) sky/refs/ferrari_cc_V26SNOW.png (640, 480) sky/refs/ferrari_cc_V28.png (640, 480) sky/refs/ferrari_cc_V29.png (640, 480) sky/refs/ferrari_cc_V29FOG.png (640, 480) sky/refs/ferrari_cc_V29PM.png (640, 480)</pre></details><details class="step"><summary><code>Bash: Build labeled contact sheet of Ferrari scenes</code></summary><pre>mkdir -p ~/work/pixelart-studies/aerial/scratch && cd ~/work/pixelart-studies && python3 -c " from PIL import Image, ImageDraw;import glob fs=sorted(glob.glob('sky/refs/ferrari_cc_*.png')) W,H=320,240;cols=5;rows=(len(fs)+cols-1)//cols S=Image.new('RGB',(W*cols,H*rows)) for i,f in enumerate(fs): im=Image.open(f).convert('RGB').resize((W,H));d=ImageDraw.Draw(im);d.rectangle([0,0,90,14],fill=(0,0,0));d.text((2,2),f.split('_')[-1],fill=(255,255,0)) S.paste(im,((i%cols)*W,(i//cols)*H)) S.save('aerial/scratch/ferrari_contact_labeled.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/ferrari_contact_labeled.png</code></div></div>  *2. aerial/scratch/ferrari_contact_labeled.png* <div class="steps"><details class="step"><summary><code>Bash: Find canvascycle fetch URL pattern</code></summary><pre>cd ~/work/pixelart-studies && cat pedagogy/master-copy/src/lwload.py | head -30; grep -rn "effectgames" --include=*.py . | head # output: import re, json, numpy as np def load(name): t=open(f'ref/lw/{name}.json').read() t=re.sub(r'([{,])\s*([A-Za-z_]+)\s*:', r'\1"\2":', t).replace("'",'"') d=json.loads(t) d['pal']=np.array(d['colors'],dtype=np.uint8) d['idx']=np.array(d['pixels'],dtype=np.int32).reshape(d['height'],d['width']) return d (eval):1: no matches found: --include=*.py</pre></details><details class="step"><summary><code>Bash: Fetch more Living Worlds scene data</code></summary><pre>cd ~/work/pixelart-studies && grep -rn "effectgames" . 2>/dev/null | grep -v "\.json:" | head; mkdir -p aerial/refs/ferrari_lw && cd aerial/refs/ferrari_lw && for n in V03 V05 V06 V08 V10 V12 V18 V20 V21 V22 V23 V24 V25 V26 V27 V30 V11 V15; do curl -s -m 30 -o $n.json "http://www.effectgames.com/demos/canvascycle/images/$n.LBM.json?" ; echo "$n $(wc -c < $n.json)"; done # output: pedagogy/master-copy/LESSONS.md:21:The original indexed data of the colour-cycling scenes is public. I fetched it from the Canvas Cycle demo (`effectgames.com/demos/canvascycle/images/*.LBM.json`; `src/lw2png.py`) for these scenes: Mirror Pond (Morning V16, Afternoon V16PM), Mountain Stream (V19, V19PM), Mountain Fortress Dusk, Seascape Sunset, Pond Ripples, Forest Edge, Mountain Storm, Island Fires, Approaching Storm and Deep Forest. The reference aligns with V16PM at offset (3,4). 86% of its pixels map one-to-one onto V16PM indices; the rest are colour-cycled water. sky/POST.md:279:*References: Mark J. Ferrari's scenes via Joseph Huckaby's Canvas Cycle (effectgames.com/demos/canvascycle); Studio Ghibli official stills (ghibli.jp/gallery); Kazuo Oga on poster colour and mist (Gurney Journey; Animation Obsessive). Reference images are kept for study only.* rock/POST.md:247:**Sources:** Mark Ferrari, *Living Worlds* (image data via Joe Huckaby's Canvas Cycle, effectgames.com/demos/canvascycle); Slynyrd, *Pixelblog 13 – Rocks* (slynyrd.com); Kazuo Oga demos (Gurney Journey, Open Culture); Wikimedia Commons: *Talus cones Isfjorden* (Mark A. Wilson), *Talus cones.jpg*, *Bare mountain talus.jpg*. V03 167 V05 167 V06 167 V08 167 V10 167 V12 167 V18 167 V20 167 V21 167 V22 167 V23 167 V24 167 V25 167 V26 167 V27 167 V30 167 V11 167 V15 167</pre></details><details class="step"><summary><code>Bash: Inspect failed response and list scene names</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs/ferrari_lw && cat V03.json; echo; curl -s -m 30 "http://www.effectgames.com/demos/canvascycle/" | grep -o "V[0-9][0-9A-Z]*" | sort -u | head -60 # output: <html> <head><title>301 Moved Permanently</title></head> <body> <center><h1>301 Moved Permanently</h1></center> <hr><center>CloudFront</center> </body> </html></pre></details><details class="step"><summary><code>Bash: List canvascycle scene names over https</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs/ferrari_lw && curl -sL -m 30 "https://www.effectgames.com/demos/canvascycle/" | grep -oE "'V[0-9]+[A-Z]*'|name:[^,]*|V[0-9]{2}[A-Z]*" | sort -u | head -80 # output: (Bash completed with no output)</pre></details><details class="step"><summary><code>Bash: Inspect canvascycle page</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs/ferrari_lw && curl -sL -m 30 "https://www.effectgames.com/demos/canvascycle/" | head -60; curl -sL -m 30 -o t.json "https://www.effectgames.com/demos/canvascycle/images/V14.LBM.json"; wc -c t.json; head -c 200 t.json # output: <!doctype html> <html lang="en"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>Canvas Cycle: True 8-bit Color Cycling with HTML5</title> <meta name="generator" content="TextMate http://macromates.com/"> <meta name="author" content="Joseph Huckaby"> <meta http-equiv="X-UA-Compatible" content="chrome=1"> <!-- Date: 2010-07-17 --> <link rel="stylesheet" type="text/css" href="style.css" > <script type="text/javascript" src="oop.js"></script> <script type="text/javascript" src="tools.js"></script> <script type="text/javascript" src="cookie.js"></script> <script type="text/javascript" src="palette.js"></script> <script type="text/javascript" src="bitmap.js"></script> <script type="text/javascript" src="scenes.js"></script> <script type="text/javascript" src="tween.js"></script> <script type="text/javascript" src="framecount.js"></script> <script type="text/javascript" src="main.js"></script> </head> <body> <div id="container"> <div id="d_header"> <div id="d_scene_selector"></div> <div id="d_scene_btns"> <div class="button left" onClick="CC.jumpScene(-1)">&lt; Prev</div><div class="button right" onClick="CC.jumpScene(1)">Next &gt;</div> </div> <div id="d_options_control"> <div id="btn_options_toggle" class="button left right" onClick="CC.toggleOptions()">Show Options &#x00BB;</div> </div> <div class="clear"></div> </div> <div id="d_loading"></div> <canvas id="mycanvas" width="640" height="480" style=""></canvas> <div id="d_options"> <div class="label">SOUND:</div> <div class="section"> <div id="btn_sound_off" class="button left" onClick="CC.setSound(false)">Off</div><div id="btn_sound_on" class="button right selected" onClick="CC.setSound(true)">On</div> </div> <div class="label">ZOOM:</div> <div class="section"> <div id="btn_zoom_actual" class="button left selected" onClick="CC.setZoom(false)">Actual</div><div id="btn_zoom_max" class="button right" onClick="CC.setZoom(true)">Max</div> </div> <div class="label">CYCLE SPEED:</div> <div class="section"> <div id="btn_speed_025" class="button thin left" onClick="CC.setSpeed(0.25)">&frac14;</div><div id="btn_speed_05" class="button thin" onClick="CC.setSpeed(0.5)">&frac12;</div><div id="btn_speed_1" class="button thin selected" onClick="CC.setSpeed(1)">1</div><div id="btn_speed_2" class="button thin" onClick="CC.setSpeed(2)">2</div><div id="btn_speed_4" class="button thin right" onClick="CC.setSpeed(4)">4</div> </div> <div class="label">CYCLE MODE:</div> <div class="section"> <div id="btn_blendshift_off" class="button left" onClick="CC.setBlendShift(false)">Standard</div><div id="btn_blendshift_on" class="button right selected" onClick="CC.setBlendShift(true)">Blend</div> </div> 1002956 t.json {filename:'V14.LBM',width:640,height:480,colors:[[0,0,0],[159,179,207],[143,159,191],[71,83,127],[71,79,123],[63,71,115],[35,35,59],[27,27,47],[15,19,31]</pre></details><details class="step"><summary><code>Bash: List scene names from scenes.js</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs/ferrari_lw && rm -f t.json V*.json; curl -sL -m 30 https://www.effectgames.com/demos/canvascycle/scenes.js | grep -oE "name:[^}]*" | head -60 # output: name: 'TESTRAMP', name: 'V08AM', name: 'V29', name: 'V19', name: 'V26SNOW', name: 'V08RAIN', name: 'V14', name: 'V30', name: 'V04', name: 'V07', name: 'V20', name: 'V05RAIN', name: 'V08PM', name: 'V16RAIN', name: 'V19AURA', name: 'CORAL', name: 'V15', name: 'V30RAIN', name: 'V02', name: 'V28', name: 'V29PM', name: 'V16', name: 'V01', name: 'V09', name: 'V16PM', name: 'V08', name: 'V03', name: 'V05HAUNT', name: 'V10', name: 'V11AM', name: 'V13', name: 'V17', name: 'V19PM', name: 'V25HEAT', name: 'V27', name: 'V29FOG',</pre></details><details class="step"><summary><code>Bash: Fetch missing scenes with titles</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs/ferrari_lw && curl -sL -m 30 https://www.effectgames.com/demos/canvascycle/scenes.js | grep -E "title|name" | paste - - | head -40; for n in V08AM V08 V20 V05RAIN V05HAUNT V30 V03 V10 V27 V25HEAT CORAL; do curl -sL -m 60 -o $n.json "https://www.effectgames.com/demos/canvascycle/images/$n.LBM.json"; done; ls -la # output: name: 'TESTRAMP', title: 'Test Image' name: 'V08AM', title: 'Jungle Waterfall - Morning', name: 'V29', title: 'Seascape - Day', name: 'V19', title: 'Mountain Stream - Morning', name: 'V26SNOW', title: 'Winter Forest - Snow', name: 'V08RAIN', title: 'Jungle Waterfall - Rain', name: 'V14', title: 'Mountain Storm - Day', name: 'V30', title: 'Deep Forest - Day', name: 'V04', title: 'Highland Ruins - Rain', name: 'V07', title: 'Rough Seas - Day', name: 'V20', title: 'Crystal Caves - Day', name: 'V05RAIN', title: 'Haunted Castle Ruins - Rain', name: 'V08PM', title: 'Jungle Waterfall - Night', name: 'V16RAIN', title: 'Mirror Pond - Rain', name: 'V19AURA', title: 'Mountain Stream - Night', name: 'CORAL', title: 'Aquarius - Day', name: 'V15', title: 'Harbor Town - Night', name: 'V30RAIN', title: 'Deep Forest - Rain', name: 'V02', title: 'Mountain Fortress - Dusk', name: 'V28', title: 'Water City Gates - Fog', name: 'V29PM', title: 'Seascape - Sunset', name: 'V16', title: 'Mirror Pond - Morning', name: 'V01', title: 'Island Fires - Dusk', name: 'V09', title: 'Forest Edge - Day', name: 'V16PM', title: 'Mirror Pond - Afternoon', name: 'V08', title: 'Jungle Waterfall - Afternoon', name: 'V03', title: 'Swamp Cathedral - Day', name: 'V05HAUNT', title: 'Haunted Castle Ruins - Night', name: 'V10', title: 'Deep Swamp - Day', name: 'V11AM', title: 'Approaching Storm - Day', name: 'V13', title: 'Pond Ripples - Dawn', name: 'V17', title: 'Ice Wind - Day', name: 'V19PM', title: 'Mountain Stream - Afternoon', name: 'V25HEAT', title: 'Desert Heat Wave - Day', name: 'V27', title: 'Magic Marsh Cave - Night', name: 'V29FOG', title: 'Seascape - Fog', total 21040 drwxr-xr-x 13 user staff 416 Sep 25 20:46 . drwxr-xr-x 10 user staff 320 Sep 25 20:45 .. -rw-r--r-- 1 user staff 880936 Sep 25 20:46 CORAL.json -rw-r--r-- 1 user staff 890460 Sep 25 20:46 V03.json -rw-r--r-- 1 user staff 931475 Sep 25 20:46 V05HAUNT.json -rw-r--r-- 1 user staff 1006248 Sep 25 20:46 V05RAIN.json -rw-r--r-- 1 user staff 1123943 Sep 25 20:46 V08.json -rw-r--r-- 1 user staff 1124290 Sep 25 20:46 V08AM.json -rw-r--r-- 1 user staff 924817 Sep 25 20:46 V10.json -rw-r--r-- 1 user staff 882884 Sep 25 20:46 V20.json -rw-r--r-- 1 user staff 975170 Sep 25 20:46 V25HEAT.json -rw-r--r-- 1 user staff 914398 Sep 25 20:46 V27.json -rw-r--r-- 1 user staff 1092077 Sep 25 20:46 V30.json</pre></details><details class="step"><summary><code>Bash: Fetch and convert Ferrari scenes to PNG</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs/ferrari_lw && for n in V14 V02 V11AM V04 V13 V29 V15 V01 V09 V16 V19; do curl -sL -m 60 -o $n.json "https://www.effectgames.com/demos/canvascycle/images/$n.LBM.json"; done; python3 - <<'EOF' import re,json,glob,numpy as np from PIL import Image for f in sorted(glob.glob('*.json')): t=open(f).read() t=re.sub(r'([{,])\s*([A-Za-z_]+)\s*:', r'\1"\2":', t).replace("'",'"') d=json.loads(t); w,h=d['width'],d['height'] pal=np.array(d['colors'],dtype=np.uint8); px=np.array(d['pixels'],dtype=np.int32).reshape(h,w) Image.fromarray(pal[px]).save(f.replace('.json','.png')); print(f,w,h,len(np.unique(px))) EOF # output: CORAL.json 640 480 179 V01.json 640 480 250 V02.json 640 480 215 V03.json 640 480 199 V04.json 640 480 189 V05HAUNT.json 640 480 208 V05RAIN.json 640 480 204 V08.json 640 480 196 V08AM.json 640 480 219 V09.json 640 480 250 V10.json 640 480 207 V11AM.json 640 480 169 V13.json 640 480 221 V14.json 640 480 241 V15.json 640 480 225 V16.json 640 480 192 V19.json 640 480 198 V20.json 640 480 226 V25HEAT.json 640 480 204 V27.json 640 480 205 V29.json 640 480 183 V30.json 640 480 190</pre></details><details class="step"><summary><code>Bash: Contact sheet of newly fetched Ferrari scenes</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " from PIL import Image, ImageDraw;import glob fs=[f for f in sorted(glob.glob('refs/ferrari_lw/*.png')) if any(k in f for k in ['V03','V05','V08','V10','V20','V25','V27','V30','CORAL'])] W,H=320,240;cols=4;rows=(len(fs)+cols-1)//cols S=Image.new('RGB',(W*cols,H*rows)) for i,f in enumerate(fs): im=Image.open(f).convert('RGB').resize((W,H));d=ImageDraw.Draw(im);d.rectangle([0,0,90,14],fill=(0,0,0));d.text((2,2),f.split('/')[-1],fill=(255,255,0)) S.paste(im,((i%cols)*W,(i//cols)*H)) S.save('scratch/ferrari_contact2.png')"; tail -5 refs/fetch.log # output: download failed: HTTP Error 403: Forbidden</pre></details><div class="step"><code>Read: aerial/scratch/ferrari_contact2.png</code></div></div>  *3. aerial/scratch/ferrari_contact2.png* <div class="steps"><details class="step"><summary><code>Bash: Check fetch progress</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs && grep -v "download failed" fetch.log | tail -30; ls; for d in */; do echo "$d $(ls $d | wc -l)"; done # output: aerial_conifer_forest_hillside aerial_river_valley_meadow aerial_view_forested_mountain_slope drone_forest_canopy_oblique drone_river_meadow_valley ferrari_lw fetch.log queries.txt aerial_conifer_forest_hillside/ 16 aerial_river_valley_meadow/ 15 aerial_view_forested_mountain_slope/ 16 drone_forest_canopy_oblique/ 16 drone_river_meadow_valley/ 10 ferrari_lw/ 44</pre></details></div> Fetch is progressing. Let me look at the first sheets. <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_view_forested_mountain_slope/_sheet.jpg</code></div></div>  *4. aerial/refs/aerial_view_forested_mountain_slope/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/drone_forest_canopy_oblique/_sheet.jpg</code></div></div>  *5. aerial/refs/drone_forest_canopy_oblique/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_conifer_forest_hillside/_sheet.jpg</code></div></div>  *6. aerial/refs/aerial_conifer_forest_hillside/_sheet.jpg* <div class="steps"><details class="step"><summary><code>Bash: List files and sizes</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs && ls aerial_view_forested_mountain_slope/ aerial_conifer_forest_hillside/; python3 -c " from PIL import Image;import glob for f in glob.glob('*/*NRCS*')+glob.glob('*/*Dangerous*'): print(f, Image.open(f).size)" # output: aerial_conifer_forest_hillside/: _sheet.jpg commons_Aerial_of_Lodgeploe_pine_forest_1c41bdf4_cbf5_4a_4abb8979.jpg commons_Aerial_of_Lodgepole_pine_forest_29a1f1e9_79c7_4a_8a500183.jpg commons_Alderholt_a_clearing_in_Telegraph_Plantation_geo_c99bdb21.jpg commons_Cattle_on_Beaulieu_Heath_New_Forest_geograph_org_498ffe5f.jpg commons_Conifer_plantation_with_storm_damage_geograph_or_7fd3178b.jpg commons_Quinault_Blowdown_Olympic_2008_2e6903c4_a3e8_4f1_750db212.jpg commons_Wintry_evergreen_forest_from_above_Unsplash_jpg_e0fa792e.jpg openverse_20120720_NRCS_LSC_0450_d62bac69.jpg openverse_20120720_NRCS_LSC_1547_2bf97f83.jpg openverse_20190911_oppe_lsc_1177_ccde4aaa.jpg openverse_Between_Dangerous_River_and_Alsek_River_c0688f25.jpg openverse_Logging_in_Oregon_16c037c7.jpg openverse_Mounds_of_slash_from_the_clearcut_waiting_to_be__4f1ab25a.jpg openverse_Sidlaws_Sundown_96a9ee5d.jpg sources.tsv aerial_view_forested_mountain_slope/: _sheet.jpg commons_1958_Aerial_view_of_Silver_Star_Mountain_Lookout_83e4d350.jpg commons_1958_Aerial_view_of_Silver_Star_Mountain_Lookout_c4e299b3.jpg commons_Aerial_View_of_Sunset_over_Forest_Slope_jpg_7d48850d.jpg commons_Aerial_view_of_a_forested_mountain_in_Lihue_Hawa_006977f6.jpg commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg commons_IN_AUGUST_1973_A_MAJOR_FOREST_FIRE_SWEPT_THROUGH_b8927448.jpg commons_Oblique_aerial_view_of_high_glaciated_terrain_ne_4bec6823.jpg openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg openverse_20120720_NRCS_LSC_0499_bac2cb4c.jpg openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_3edaed3b.jpg openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_7b07c4f7.jpg openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_918ece8e.jpg openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_eaa078db.jpg openverse_View_From_Kokol_Prayer_Summit_8ec54a87.jpg sources.tsv aerial_conifer_forest_hillside/openverse_20120720_NRCS_LSC_0450_d62bac69.jpg (1024, 680) aerial_conifer_forest_hillside/openverse_20120720_NRCS_LSC_1547_2bf97f83.jpg (613, 1024) aerial_view_forested_mountain_slope/openverse_20120720_NRCS_LSC_0499_bac2cb4c.jpg (1023, 725) aerial_view_forested_mountain_slope/openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg (1024, 680) aerial_conifer_forest_hillside/openverse_Between_Dangerous_River_and_Alsek_River_c0688f25.jpg (1024, 767)</pre></details><div class="step"><code>Read: aerial/refs/aerial_view_forested_mountain_slope/openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg</code></div></div>  *7. aerial/refs/aerial_view_forested_mountain_slope/openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_conifer_forest_hillside/openverse_Between_Dangerous_River_and_Alsek_River_c0688f25.jpg</code></div></div>  *8. aerial/refs/aerial_conifer_forest_hillside/openverse_Between_Dangerous_River_and_Alsek_River_c0688f25.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_view_forested_mountain_slope/commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg</code></div></div>  *9. aerial/refs/aerial_view_forested_mountain_slope/commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg* <div class="steps"><details class="step"><summary><code>Bash: Read transfer measurement code</code></summary><pre>cd ~/work/pixelart-studies/transfer && sed -n 1,200p lib/measure.py; cat measure_ratios.py | head -60 # output: """measure.py -- structural statistics measured *identically* on a photograph and on Ferrari's pixels. The observation student's key finding was a stylization ratio: the same statistic (gradient anisotropy) measured in a photo of grass (~1.1-1.45) and in Ferrari's grass (~2.8). This module generalises that into a small battery, so that for a subject Ferrari never painted we can measure the photo and multiply by the ratio Ferrari applies to the nearest thing he did paint. All statistics work on CIE L* (0..100) of an RGB array and a boolean region mask. Photos are first brought to "native-equivalent" scale (box-downsampled so the scene framing matches a 640-px-wide Ferrari canvas), so pixel-scale statistics are comparable. stats = region_stats(rgb, mask) -> dict of numbers """ import numpy as np from scipy import ndimage as ndi from skimage.color import rgb2lab def to_lab(rgb): a = np.asarray(rgb)[..., :3].astype(float) / 255.0 return rgb2lab(a) def native_equiv(img, width=640): """box-downsample a PIL image to `width` px wide (Ferrari's canvases are 640 wide).""" from PIL import Image w, h = img.size return img.convert("RGB").resize((width, max(1, round(h * width / w))), Image.BOX) # ------------------------------------------------------------------ individual statistics def gradients(L): gx = np.diff(L, axis=1)[:-1, :] gy = np.diff(L, axis=0)[:, :-1] return gx, gy def anisotropy_xy(L, mask): """observation student's statistic: mean|d/dx| / mean|d/dy|. >1 = vertical strokes.""" gx, gy = gradients(L) m = mask[:-1, :-1] & mask[1:, :-1] & mask[:-1, 1:] return float(np.abs(gx[m]).mean() / (np.abs(gy[m]).mean() + 1e-6)) def anisotropy_tensor(L, mask): """direction-free anisotropy: orientation coherence R = |sum |g| e^{2i theta}| / sum |g| (L1-weighted, robust to a few strong edges), reported as (1+R)/(1-R) so that it reads like |dx|/|dy| for axis-aligned strokes; plus the stroke direction (perpendicular to the dominant gradient) in degrees from horizontal, counter-clockwise (90 = vertical, 45 = '/').""" # 2x2-cell gradients. Plain forward differences share a pixel and correlate gx with gy on # pure noise (a fake 45-degree 'stroke', found by testing on white noise); central differences # are blind to 1-px strands. The 2x2 cell is unbiased and still sees 1-px strands. a00, a01, a10, a11 = L[:-1, :-1], L[:-1, 1:], L[1:, :-1], L[1:, 1:] gx = 0.5 * ((a01 + a11) - (a00 + a10)); gy = 0.5 * ((a10 + a11) - (a00 + a01)) m = mask[:-1, :-1] & mask[1:, :-1] & mask[:-1, 1:] & mask[1:, 1:] gx = gx[m]; gy = -gy[m] # y up mag = np.hypot(gx, gy) z = np.sum(mag * np.exp(2j * np.arctan2(gy, gx))) R = float(np.abs(z) / (mag.sum() + 1e-9)) gang = np.degrees(np.angle(z) / 2) # dominant gradient direction stroke = (gang + 90.0) % 180.0 return (1 + R) / (1 - R + 1e-9), float(stroke) def value_spread(L</pre></details><details class="step"><summary><code>Bash: Wait and check fetch progress</code></summary><pre>sleep 60; cd ~/work/pixelart-studies/aerial/refs; for d in */; do echo "$d $(ls $d | wc -l)"; done # output: <tool_use_error>Blocked: sleep 60 followed by: cd ~/work/pixelart-studies/aerial/refs for d in */; do echo "$d $(ls $d | wc -l)"; done. To wait for a condition, use Monitor with an until-loop (e.g. `until <check>; do sleep 2; done`). To wait for a command you started, use run_in_background: true. Do not chain shorter sleeps to work around this block.</tool_use_error></pre></details><details class="step"><summary><code>Bash: Check fetch progress</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs; for d in */; do echo "$d $(ls $d | wc -l)"; done # output: aerial_conifer_forest_hillside/ 16 aerial_river_valley_meadow/ 15 aerial_view_alpine_valley_river/ 13 aerial_view_forested_mountain_slope/ 16 drone_forest_canopy_oblique/ 16 drone_river_meadow_valley/ 12 ferrari_lw/ 44</pre></details><div class="step"><code>Read: aerial/refs/aerial_river_valley_meadow/_sheet.jpg</code></div></div>  *10. aerial/refs/aerial_river_valley_meadow/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_view_alpine_valley_river/_sheet.jpg</code></div><div class="step"><code>Read: aerial/refs/drone_river_meadow_valley/_sheet.jpg</code></div></div>  *11. aerial/refs/drone_river_meadow_valley/_sheet.jpg* <div class="steps"><details class="step"><summary><code>Bash: Check fetch log and fetcher options</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs; tail -5 fetch.log; grep -c failed fetch.log; sed -n 60,140p ../../tools/imgfetch.py # output: download failed: HTTP Error 429: Too many requests - please contact noc@wikimedia.org to discuss a less disruptive approach or instead use thumbnail images in sizes listed on https://w.wiki/GHai. (0c640b1) download failed: HTTP Error 429: Too many requests - please contact noc@wikimedia.org to discuss a less disruptive approach or instead use thumbnail images in sizes listed on https://w.wiki/GHai. (0c640b1) download failed: HTTP Error 429: Too many requests - please contact noc@wikimedia.org to discuss a less disruptive approach or instead use thumbnail images in sizes listed on https://w.wiki/GHai. (0c640b1) download failed: HTTP Error 429: Too many requests - please contact noc@wikimedia.org to discuss a less disruptive approach or instead use thumbnail images in sizes listed on https://w.wiki/GHai. (0c640b1) download failed: HTTP Error 429: Too many requests - please contact noc@wikimedia.org to discuss a less disruptive approach or instead use thumbnail images in sizes listed on https://w.wiki/GHai. (0c640b1) 6 ii = p.get("imageinfo", [{}])[0] if ii.get("width", 0) < 500 or "thumburl" not in ii: continue m = ii.get("extmetadata", {}) strip = lambda s: re.sub("<[^>]+>", "", s or "").strip() out.append(dict(url=ii["thumburl"], title=p["title"][5:], license=strip(m.get("LicenseShortName", {}).get("value")), author=strip(m.get("Artist", {}).get("value"))[:80], page=ii.get("descriptionurl", ""))) if len(out) >= n: break return out def openverse(query, n, width): results = [] for page in (1, 2, 3): # anonymous page_size is capped at 20 q = urllib.parse.urlencode({"q": query, "page_size": 20, "page": page, "mature": "false"}) try: d = json.loads(get("https://api.openverse.org/v1/images/?" + q)) except Exception: break results += d.get("results", []) if len(results) >= n * 4 or page >= (d.get("page_count") or 1): break out = []; per_creator = {} for r in results: if (r.get("width") or 0) < 500: continue c = r.get("creator") or "?" if per_creator.get(c, 0) >= 2: # variety: one photographer's series shouldn't fill the set continue per_creator[c] = per_creator.get(c, 0) + 1 out.append(dict(url=r["url"], title=r.get("title") or r["id"], license=f"CC {r.get('license','?').upper()} {r.get('license_version','')}".strip(), author=(r.get("creator") or "")[:80], page=r.get("foreign_landing_url", ""))) if len(out) >= n: break return out SOURCES = {"commons": commons, "openverse": openverse} def slug(s, k=60): return re.sub(r"[^A-Za-z0-9]+", "_", s).strip("_")[:k] or "img" def fetch(query, n, outdir, srcs, width): os.makedirs(outdir, exist_ok=True) items = [] per = max(1, -(-n // len(srcs))) creators = {} words = query.split(</pre></details><details class="step"><summary><code>Bash: Write photo-looking helpers and make scale crops</code></summary><pre>mkdir -p ~/work/pixelart-studies/aerial/lib ~/work/pixelart-studies/aerial/studies ~/work/pixelart-studies/aerial/sheets ~/work/pixelart-studies/aerial/plates; cd ~/work/pixelart-studies/aerial && cat > lib/look.py <<'EOF' """look.py -- helpers for looking at photos: crop, box-downsample to a pixel scale, nearest-upscale.""" from PIL import Image import numpy as np def load(path): return Image.open(path).convert("RGB") def crop(im, box): return im.crop(box) def to_px(im, width): """box-downsample so the image is `width` px wide: what the photo looks like at that pixel scale.""" w, h = im.size return im.resize((width, max(1, round(h * width / w))), Image.BOX) def up(im, k): return im.resize((im.size[0] * k, im.size[1] * k), Image.NEAREST) def hstack(ims, gap=4, bg=(20, 20, 24)): H = max(i.size[1] for i in ims); W = sum(i.size[0] for i in ims) + gap * (len(ims) - 1) out = Image.new("RGB", (W, H), bg); x = 0 for i in ims: out.paste(i, (x, 0)); x += i.size[0] + gap return out def vstack(ims, gap=4, bg=(20, 20, 24)): W = max(i.size[0] for i in ims); H = sum(i.size[1] for i in ims) + gap * (len(ims) - 1) out = Image.new("RGB", (W, H), bg); y = 0 for i in ims: out.paste(i, (0, y)); y += i.size[1] + gap return out EOF python3 - <<'EOF' import sys; sys.path.insert(0,'lib'); from look import * im=load('refs/aerial_view_forested_mountain_slope/commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg') c=crop(im,(0,640,400,960)) # near forest a=to_px(c,100); b=to_px(c,50) hstack([c, up(a,4), up(b,8)]).save('scratch/deer_near_scales.png') EOF # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/deer_near_scales.png</code></div></div>  *12. aerial/scratch/deer_near_scales.png* <div class="steps"><details class="step"><summary><code>Bash: Crop Ferrari canopy and far-view regions</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' import sys; sys.path.insert(0,'lib'); from look import * F=lambda n: load(f'refs/ferrari_lw/{n}.png') hstack([up(crop(F('V08'),(0,250,160,370)),4), up(crop(F('V14'),(0,340,200,440)),4)]).save('scratch/f_canopy.png') hstack([up(crop(F('V02'),(0,180,220,300)),4), up(crop(F('V11AM'),(60,260,260,380)),4)]).save('scratch/f_far.png') EOF # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/f_canopy.png</code></div></div>  *13. aerial/scratch/f_canopy.png* <div class="steps"><div class="step"><code>Read: aerial/scratch/f_far.png</code></div></div>  *14. aerial/scratch/f_far.png* <div class="steps"><div class="step"><code>Read: aerial/refs/ferrari_lw/V02.png</code></div></div>  *15. aerial/refs/ferrari_lw/V02.png* <div class="steps"><details class="step"><summary><code>Bash: Crop Ferrari river regions</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' import sys; sys.path.insert(0,'lib'); from look import * F=lambda n: load(f'refs/ferrari_lw/{n}.png') up(crop(F('V02'),(0,270,160,350)),6).save('scratch/f_v02_rivers.png') up(crop(F('V11AM'),(60,330,260,430)),5).save('scratch/f_v11_river.png') EOF # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/f_v02_rivers.png</code></div></div>  *16. aerial/scratch/f_v02_rivers.png* <div class="steps"><div class="step"><code>Read: aerial/scratch/f_v11_river.png</code></div></div>  *17. aerial/scratch/f_v11_river.png* <div class="steps"><details class="step"><summary><code>Bash: Check fetch and library versions</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs; for d in */; do echo "$d $(ls $d | wc -l)"; done; python3 -c "import skimage, scipy, numpy; print(skimage.__version__, scipy.__version__, numpy.__version__)"; sysctl -n hw.ncpu # output: aerial_conifer_forest_hillside/ 16 aerial_river_valley_meadow/ 15 aerial_view_alpine_valley_river/ 15 aerial_view_forested_mountain_slope/ 16 alpine_tarn_from_above/ 12 cirque_lake_snow_mountain_from_above/ 14 drone_forest_canopy_oblique/ 16 drone_river_meadow_valley/ 12 ferrari_lw/ 44 glacial_cirque_tarn_aerial/ 13 0.25.2 1.14.0 1.26.4 14</pre></details><div class="step"><code>Read: aerial/refs/glacial_cirque_tarn_aerial/_sheet.jpg</code></div></div>  *18. aerial/refs/glacial_cirque_tarn_aerial/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/cirque_lake_snow_mountain_from_above/_sheet.jpg</code></div></div>  *19. aerial/refs/cirque_lake_snow_mountain_from_above/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/alpine_tarn_from_above/_sheet.jpg</code></div><details class="step"><summary><code>Bash: Read existing noise and camera modules</code></summary><pre>cd ~/work/pixelart-studies/transfer/lib && cat noise.py camera.py | head -200; python3 -c "import numba" 2>&1 # output: """noise.py -- procedural fields evaluable at arbitrary world points (any scale, any camera). Everything takes float arrays x, y (metres) and an integer seed. Hash-based, so the same world point gives the same value whichever camera or distance looks at it: a debris fan painted at 300 m and at 10 m is the same debris fan. """ import numpy as np _M = np.uint32(0x27D4EB2D) def _hash(ix, iy, seed): with np.errstate(over="ignore"): h = (ix.astype(np.int64) * 374761393 + iy.astype(np.int64) * 668265263 + seed * 144665) & 0xFFFFFFFF h = h.astype(np.uint32) h = (h ^ (h >> np.uint32(13))) * np.uint32(1274126177) h = h ^ (h >> np.uint32(16)) return h def rand2(ix, iy, seed): """uniform [0,1) per integer lattice point.""" return (_hash(ix, iy, seed) & np.uint32(0xFFFFFF)).astype(np.float64) / float(0x1000000) def value(x, y, seed=0): """smooth value noise in [0,1], feature size 1.""" x = np.asarray(x, float); y = np.asarray(y, float) ix = np.floor(x); iy = np.floor(y) fx = x - ix; fy = y - iy ux = fx * fx * (3 - 2 * fx); uy = fy * fy * (3 - 2 * fy) ix = ix.astype(np.int64); iy = iy.astype(np.int64) a = rand2(ix, iy, seed); b = rand2(ix + 1, iy, seed) c = rand2(ix, iy + 1, seed); d = rand2(ix + 1, iy + 1, seed) return (a + (b - a) * ux) + ((c + (d - c) * ux) - (a + (b - a) * ux)) * uy def fbm(x, y, seed=0, scale=1.0, octaves=4, persistence=0.5, lacunarity=2.0): """fractal value noise in ~[0,1]; scale = largest feature size (m).""" x = np.asarray(x, float) / scale; y = np.asarray(y, float) / scale out = 0.0; amp = 1.0; tot = 0.0 for o in range(octaves): # rotate each octave a little to hide lattice alignment c, s = np.cos(0.5 * o), np.sin(0.5 * o) out = out + amp * value(c * x - s * y + 17.3 * o, s * x + c * y - 9.1 * o, seed + 101 * o) tot += amp; amp *= persistence x = x * lacunarity; y = y * lacunarity return out / tot def ridged(x, y, seed=0, scale=1.0, octaves=4): """ridged noise (sharp crests / gullies) in [0,1].""" x = np.asarray(x, float) / scale; y = np.asarray(y, float) / scale out = 0.0; amp = 1.0; tot = 0.0 for o in range(octaves): n = 1.0 - np.abs(2 * value(x + 31.7 * o, y - 11.3 * o, seed + 57 * o) - 1) out = out + amp * n * n; tot += amp; amp *= 0.5; x = x * 2.03; y = y * 2.03 return out / tot def voronoi(x, y, seed=0, scale=1.0, jitter=0.9): """cellular noise. Returns (F1, F2, cell_id, cx, cy) with distances and centre in world units. Cells are ~`scale` across.""" x = np.asarray(x, float) / scale; y = np.asarray(y, float) / scale ix = np.floor(x).astype(np.int64); iy = np.floor(y).astype(np.int64) F1 = np.full(x.shape, 9.0); F2 = np.full(x.shape, 9.0) cid = np.zeros(x.shape, np.int64); cx = np.zeros(x.shape); cy = np.zeros(x.shape) for dy in (-1, 0, 1): for dx in (-1, 0, 1): jx = ix + dx; jy = iy + dy </pre></details><details class="step"><summary><code>Bash: Copy noise and camera modules into aerial lib</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cp ../../transfer/lib/noise.py noise.py && cp ../../transfer/lib/camera.py camera.py && sed -i '' '1s/^/# copied from transfer\/lib (shared noise + cameras)\n/' noise.py camera.py && head -3 noise.py # output: # copied from transfer/lib (shared noise + cameras) """noise.py -- procedural fields evaluable at arbitrary world points (any scale, any camera).</pre></details><details class="step"><summary><code>Write: aerial/lib/terrain.py</code></summary><pre>"""terrain.py -- a heightfield grid, its derived fields, and a ray-marcher that turns it into a G-buffer. World: x east, y north, z up, metres. Grid H[j, i] with j along y (north), i along x (east); cell size `cell` metres; origin (x0, y0) at H[0, 0]. T = Terrain(H, cell, x0, y0) T.normals(), T.sun_shadow(sun), T.flow(), T.concavity(r) G = T.gbuffer(cam) # per-pixel hit, world pos, normal, distance, footprint """ import numpy as np from scipy import ndimage as ndi def sun_vector(alt_deg, az_deg): """unit vector TOWARD the sun. az: 0 = north, 90 = east, 180 = south (behind a north-looking camera).""" a = np.radians(alt_deg); z = np.radians(az_deg) return np.array([np.sin(z) * np.cos(a), np.cos(z) * np.cos(a), np.sin(a)]) class Terrain: def __init__(self, H, cell, x0=0.0, y0=0.0): self.H = np.asarray(H, np.float64) self.cell = float(cell) self.x0, self.y0 = float(x0), float(y0) self.ny, self.nx = self.H.shape self._n = None # ---------------------------------------------------------------- sampling def ij(self, x, y): return (np.asarray(x) - self.x0) / self.cell, (np.asarray(y) - self.y0) / self.cell def sample(self, F, x, y, order=1, cval=None): """bilinear sample of a grid field F at world points (clamped at the edges).""" fi, fj = self.ij(x, y) fi = np.clip(fi, 0, self.nx - 1.001); fj = np.clip(fj, 0, self.ny - 1.001) if order == 0: return F[np.round(fj).astype(int), np.round(fi).astype(int)] i0 = np.floor(fi).astype(int); j0 = np.floor(fj).astype(int) u = fi - i0; v = fj - j0 a = F[j0, i0]; b = F[j0, i0 + 1]; c = F[j0 + 1, i0]; d = F[j0 + 1, i0 + 1] if a.ndim > u.ndim: # vector field u = u[..., None]; v = v[..., None] return (a * (1 - u) + b * u) * (1 - v) + (c * (1 - u) + d * u) * v def height(self, x, y): return self.sample(self.H, x, y) @property def extent(self): return self.x0, self.y0, self.x0 + (self.nx - 1) * self.cell, self.y0 + (self.ny - 1) * self.cell # ---------------------------------------------------------------- derived fields def normals(self): if self._n is None: gy, gx = np.gradient(self.H, self.cell) n = np.stack([-gx, -gy, np.ones_like(gx)], -1) self._n = n / np.linalg.norm(n, axis=-1, keepdims=True) return self._n def slope_deg(self): return np.degrees(np.arccos(np.clip(self.normals()[..., 2], -1, 1))) def sun_shadow(self, sun, soft=0.0, max_dist=None): """1 = sunlit, 0 = in the terrain's cast shadow. Marches from every cell toward the sun. `soft` (metres) turns the hard test into a penumbra ramp.""" s = np.asarray(sun, float) hor = np.hypot(s[0], s[1]) + 1e-9 dx, dy = s[0] / hor, s[1] / hor rise = s[2] / hor # metres of rise per metre of horizontal travel if max_dist is None: max_dist = min(np.ptp(self.H) / max(rise, 1e-3) + self.cell, self.cell * max(self.nx, self.ny)) jj, ii = np.mgrid[0:self.ny, 0:self.nx].astype(float) vis = np.ones_like(self.H) step = self.cell * 0.75 n = int(max_dist / step) + 1 for k in range(1, n + 1): d = k * step fi = ii + dx * d / self.cell; fj = jj + dy * d / self.cell inside = (fi >= 0) & (fi <= self.nx - 1) & (fj >= 0) & (fj <= self.ny - 1) if not inside.any(): break h = ndi.map_coordinates(self.H, [np.clip(fj, 0, self.ny - 1), np.clip(fi, 0, self.nx - 1)], order=1) excess = h - (self.H + rise * d) if soft > 0: vis = np.minimum(vis, np.where(inside, np.clip(1 - excess / soft, 0, 1), 1)) else: vis = np.where(inside & (excess > 0), 0.0, vis) return vis def concavity(self, r_m): """local height minus the mean height within radius r (m): <0 in hollows/gullies, >0 on ridges.""" s = max(r_m / self.cell, 0.5) return self.H - ndi.gaussian_filter(self.H, s) def flow(self): """D8 flow accumulation (number of upstream cells, >= 1), after a light pit fill.""" H = self.H + 1e-6 * np.random.default_rng(0).random(self.H.shape) order = np.argsort(-H, axis=None) acc = np.ones(H.size) Hp = np.pad(H, 1, constant_values=-1e9) ny, nx = H.shape offs = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)] best = np.full(H.shape, -1, np.int64); bestd = np.zeros(H.shape) for dj, di in offs: nb = Hp[1 + dj:1 + dj + ny, 1 + di:1 + di + nx] drop = (H - nb) / np.hypot(dj, di) better = drop > bestd bestd = np.where(better, drop, bestd) jj, ii = np.mgrid[0:ny, 0:nx] tgt = (jj + dj) * nx + (ii + di) best = np.where(better, tgt, best) best = best.ravel() for c in order: t = best[c] if t >= 0: acc[t] += acc[c] return acc.reshape(H.shape) # ---------------------------------------------------------------- rendering def raymarch(self, O, D, t0=0.0, t1=None, max_iter=4000): """first intersection of rays with the heightfield. O, D: [..., 3]. Returns t (inf = miss).""" shp = O.shape[:-1] O = O.reshape(-1, 3); D = D.reshape(-1, 3) hmax = self.H.max(); hmin = self.H.min() # clip each ray to the slab hmin..hmax dz = np.where(np.abs(D[:, 2]) < 1e-9, -1e-9, D[:, 2]) ta = (hmax - O[:, 2]) / dz; tb = (hmin - O[:, 2]) / dz tin = np.maximum(np.minimum(ta, tb), t0); tout = np.maximum(ta, tb) if t1 is not None: tout = np.minimum(tout, t1) t = tin.copy() hit = np.full(len(t), np.inf) active = np.nonzero(tout > tin)[0] slope_k = 0.5 # step factor on (ray height - terrain height) min_step = self.cell * 0.2 prev_t = t.copy() for it in range(max_iter): if active.size == 0: break P = O[active] + D[active] * t[active, None] h = self.height(P[:, 0], P[:, 1]) gap = P[:, 2] - h below = gap <= 0 if below.any(): idx = active[below] lo = prev_t[idx]; hi = t[idx] for _ in range(10): # bisection refine mid = 0.5 * (lo + hi) Pm = O[idx] + D[idx] * mid[:, None] under = Pm[:, 2] <= self.height(Pm[:, 0], Pm[:, 1]) hi = np.where(under, mid, hi); lo = np.where(under, lo, mid) hit[idx] = hi keep = ~below active = active[keep]; gap = gap[keep] prev_t[active] = t[active] step = np.maximum(gap * slope_k / np.maximum(-D[active, 2], 0.05), min_step) step = np.minimum(step, self.cell * 4) t[active] += step out = t[active] > tout[active] active = active[~out] return hit.reshape(shp) def gbuffer(self, cam): O, D = cam.rays() t = self.raymarch(O, D) hit = np.isfinite(t) tt = np.where(hit, t, 0.0) P = O + D * tt[..., None] n = self.sample(self.normals(), P[..., 0], P[..., 1]) n = n / np.linalg.norm(n, axis=-1, keepdims=True) G = dict(hit=hit, t=np.where(hit, t, np.inf), x=P[..., 0], y=P[..., 1], z=P[..., 2], n=n, D=D, mpp=cam.footprint(tt)) return G </pre></details><details class="step"><summary><code>Write: aerial/lib/pal.py</code></summary><pre>"""pal.py -- the palette is the light. A picture is painted as an index canvas of (material, step, band): material what the thing is (conifer, meadow, snow, ...) step a form class: 0 = contact/core dark ... top = highlight (see STEP_E below) band a depth band (0 near .. 3 far) for aerial perspective The palette maps each used key to a colour computed from a Light state, so the same index canvas re-lights for morning, noon, evening or overcast by swapping the palette. Colours are computed in linear RGB from a measured albedo and a light model, then pushed in Lab: chroma x CHROMA (Ferrari's chroma is ~2-3x a photo's; transfer/measure/ratios.json) and optionally a hue walk (shadows cooler, lights warmer). """ import numpy as np from skimage.color import rgb2lab, lab2rgb # ---------------------------------------------------------------- colour utils def srgb_to_lin(c): c = np.asarray(c, float) / 255.0 return np.where(c <= 0.04045, c / 12.92, ((c + 0.055) / 1.055) ** 2.4) def lin_to_srgb(c): c = np.clip(np.asarray(c, float), 0, 1) return np.where(c <= 0.0031308, 12.92 * c, 1.055 * c ** (1 / 2.4) - 0.055) * 255.0 def lab(rgb255): return rgb2lab(np.asarray(rgb255, float).reshape(-1, 1, 3) / 255.0).reshape(np.shape(rgb255)) def from_lab(L): return np.clip(lab2rgb(np.asarray(L, float).reshape(-1, 1, 3)).reshape(np.shape(L)) * 255, 0, 255) def push_chroma(rgb255, k=1.6, lift=0.0): L = lab(rgb255) L[..., 1:] *= k L[..., 0] = np.clip(L[..., 0] + lift, 0, 100) return from_lab(L) # ---------------------------------------------------------------- light states class Light: """sun: direction (alt, az) and colour; sky: ambient colour; haze: colour + density.""" def __init__(self, name, alt, az, sun, sky, haze, haze_k, bounce=(0.25, 0.22, 0.15), exposure=1.0, shadow_hue=0.0, chroma=1.6): self.name = name; self.alt = alt; self.az = az self.sun = np.asarray(sun, float); self.sky = np.asarray(sky, float) self.haze = np.asarray(haze, float) # sRGB 0..255 of the horizon haze self.haze_k = haze_k # 1/m extinction for aerial perspective self.bounce = np.asarray(bounce, float) self.exposure = exposure self.chroma = chroma @property def vec(self): from terrain import sun_vector return sun_vector(self.alt, self.az) LIGHTS = { # sun colours and sky ambient in linear RGB (relative). Measured targets noted in NOTES.md. "morning": Light("morning", 14, 105, sun=(1.25, 1.0, 0.72), sky=(0.20, 0.26, 0.40), haze=(196, 196, 206), haze_k=1 / 9000), "noon": Light("noon", 58, 200, sun=(1.15, 1.08, 0.98), sky=(0.24, 0.30, 0.42), haze=(190, 205, 222), haze_k=1 / 12000), "afternoon": Light("afternoon", 30, 245, sun=(1.2, 1.05, 0.85), sky=(0.21, 0.27, 0.42), haze=(185, 200, 220), haze_k=1 / 10000), "evening": Light("evening", 7, 290, sun=(1.35, 0.78, 0.45), sky=(0.22, 0.20, 0.40), haze=(214, 170, 176), haze_k=1 / 7000), "overcast": Light("overcast", 45, 200, sun=(0.18, 0.18, 0.19), sky=(0.62, 0.64, 0.68), haze=(200, 202, 206), haze_k=1 / 5000), } # ---------------------------------------------------------------- materials # albedo in sRGB (as a photo shows the lit surface at ~noon, exposure-normalised), measured from # the oblique photos in refs/ (see NOTES.md, 'measured albedos'). MATERIALS = { "conifer": dict(alb=(62, 88, 52), steps=6), "broadleaf": dict(alb=(88, 120, 50), steps=6), "meadow": dict(alb=(140, 150, 72), steps=5), "drygrass": dict(alb=(170, 152, 100), steps=5), "rock": dict(alb=(150, 142, 132), steps=6), "scree": dict(alb=(160, 152, 140), steps=5), "snow": dict(alb=(245, 247, 250), steps=6), "water": dict(alb=(40, 70, 80), steps=6), "shallow": dict(alb=(60, 130, 120), steps=4), "sand": dict(alb=(215, 195, 150), steps=5), "wetsand": dict(alb=(150, 130, 100), steps=3), "foam": dict(alb=(250, 250, 250), steps=3), "soil": dict(alb=(120, 96, 70), steps=4), "roof": dict(alb=(120, 80, 52), steps=4), "wall": dict(alb=(170, 140, 100), steps=4), "fire": dict(alb=(255, 200, 80), steps=4, emissive=True), "smoke": dict(alb=(170, 170, 175), steps=3), "sky": dict(alb=(255, 255, 255), steps=10, sky=True), } MAT_ID = {k: i + 1 for i, k in enumerate(MATERIALS)} # 0 = empty MAT_NAME = {v: k for k, v in MAT_ID.items()} def step_irradiance(nsteps, light): """irradiance per form class. Steps split into a shadow family (sky + bounce only) and a lit family (sun at increasing n.l). Lower half = shadow, upper half = lit; the jump between them is the terminator and is never dithered across.""" ns = nsteps // 2 # shadow classes nl = nsteps - ns # lit classes E = [] for k in range(ns): # core/contact (occluded) .. reflected light occ = 0.35 + 0.65 * k / max(ns - 1, 1) E.append(light.sky * occ * (0.55 + 0.45 * (k / max(ns - 1, 1))) + light.bounce * 0.4 * k / max(ns - 1, 1)) for k in range(nl): # halftone .. full light ndl = 0.35 + 0.65 * (k + 1) / nl E.append(light.sky + light.sun * ndl) return np.array(E) def material_ramp(mat, light, hue_walk=True): """colours (sRGB 0..255) of every step of a material under a light, before depth bands.""" m = MATERIALS[mat] alb = srgb_to_lin(m["alb"]) n = m["steps"] if m.get("emissive"): base = np.array(m["alb"], float) cols = np.array([base * (0.45 + 0.55 * k / (n - 1)) for k in range(n)]) cols[-1] = (255, 250, 210) return cols E = step_irradiance(n, light) col = alb[None] * E * light.exposure # a gentle shoulder so snow and sunlit sand don't clip flat col = col / (1 + 0.35 * col) rgb = lin_to_srgb(col * 1.35) return push_chroma(rgb, light.chroma) def haze_mix(rgb, light, f): """aerial perspective: mix toward the haze colour by fraction f; the black point lifts first.""" rgb = np.asarray(rgb, float) return rgb * (1 - f) + light.haze[None] * f if rgb.ndim == 2 else rgb * (1 - f) + light.haze * f class Palette: """collects (mat, step, band) keys used by a picture and resolves them to colours.""" def __init__(self, light, band_f=(0.0, 0.22, 0.45, 0.68)): self.light = light self.band_f = band_f self.ramps = {m: material_ramp(m, light) for m in MATERIALS if not MATERIALS[m].get("sky")} def colour(self, mat, step, band=0): name = MAT_NAME[mat] r = self.ramps[name] step = int(np.clip(step, 0, len(r) - 1)) c = r[step] f = self.band_f[min(band, len(self.band_f) - 1)] return haze_mix(c, self.light, f) def render(self, mat, step, band, sky_rgb=None): """index canvas -> RGB image, plus the number of distinct colours used.""" h, w = mat.shape out = np.zeros((h, w, 3), np.uint8) keys = mat.astype(np.int64) * 10000 + np.clip(step, 0, 99).astype(np.int64) * 100 + band.astype(np.int64) u, inv = np.unique(keys, return_inverse=True) cols = np.zeros((len(u), 3)) for i, k in enumerate(u): m, s, b = k // 10000, (k // 100) % 100, k % 100 if m == 0: cols[i] = (0, 0, 0) elif MAT_NAME[m] == "sky": cols[i] = sky_rgb[s] if sky_rgb is not None else self.light.haze else: cols[i] = self.colour(m, s, b) out = np.round(cols[inv.reshape(h, w)]).astype(np.uint8) ncol = len(np.unique(out.reshape(-1, 3), axis=0)) return out, ncol </pre></details><details class="step"><summary><code>Bash: Check fetch progress</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs; for d in */; do echo "$d $(ls $d | wc -l)"; done; pgrep -f imgfetch >/dev/null && echo running # output: aerial_coastline_cliffs/ 13 aerial_conifer_forest_hillside/ 16 aerial_river_valley_meadow/ 15 aerial_view_alpine_valley_river/ 15 aerial_view_forested_mountain_slope/ 16 alpine_tarn_from_above/ 14 cirque_lake_snow_mountain_from_above/ 14 cliff_bands_mountain_aerial/ 16 drone_forest_canopy_oblique/ 16 drone_river_meadow_valley/ 12 ferrari_lw/ 44 glacial_cirque_tarn_aerial/ 13 scree_slope_from_above/ 11 talus_fan_mountain/ 14 running</pre></details><div class="step"><code>Read: aerial/refs/scree_slope_from_above/_sheet.jpg</code></div></div>  *20. aerial/refs/scree_slope_from_above/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/talus_fan_mountain/_sheet.jpg</code></div></div>  *21. aerial/refs/talus_fan_mountain/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/cliff_bands_mountain_aerial/_sheet.jpg</code></div></div>  *22. aerial/refs/cliff_bands_mountain_aerial/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/alpine_tarn_from_above/_sheet.jpg</code></div></div>  *23. aerial/refs/alpine_tarn_from_above/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_coastline_cliffs/_sheet.jpg</code></div><details class="step"><summary><code>Bash: Prepare second query batch</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs && cat > queries2.txt <<'EOF' talus cone aerial scree fan mountain drone rock glacier aerial view aerial view alpine lake cirque snow gully mountain aerial helicopter view mountain snow drone view mountain ridge snow aerial view braided river valley aerial view meandering river forest drone river valley forest mountains aerial view fjord aerial coast drone cliffs sea drone beach waves above aerial view headland surf aerial view village mountain valley drone cabin forest aerial view farm clearing forest drone campfire night aerial view mountains layers haze view from summit valley haze aerial photograph forest clearing drone autumn forest mountain EOF echo ok # output: ok</pre></details><details class="step"><summary><code>Write: aerial/lib/dither.py</code></summary><pre>"""dither.py -- quantising a continuous step coordinate into ramp indices. Ferrari: patterned (ordered) dither for smooth precise surfaces, diffusion/random for chaotic ones, no dither for solid bands. Only adjacent steps of one ramp are ever mixed, and never across the terminator (the caller clamps each pixel into its light family first). """ import numpy as np BAYER2 = np.array([[0, 2], [3, 1]]) / 4.0 + 1 / 8 BAYER4 = np.array([[0, 8, 2, 10], [12, 4, 14, 6], [3, 11, 1, 9], [15, 7, 13, 5]]) / 16.0 + 1 / 32 def tile(pat, h, w, ox=0, oy=0): ph, pw = pat.shape ys = (np.arange(h) + oy) % ph; xs = (np.arange(w) + ox) % pw return pat[ys[:, None], xs[None, :]] _blue = {} def blue_noise(n=64, seed=0): """a cheap blue-noise threshold map (iterative high-pass of white noise, rank-normalised).""" key = (n, seed) if key in _blue: return _blue[key] rng = np.random.default_rng(seed) a = rng.random((n, n)) from scipy import ndimage as ndi for _ in range(6): a = a - ndi.gaussian_filter(a, 1.2, mode="wrap") r = np.argsort(np.argsort(a, axis=None)).reshape(n, n) a = r / (n * n) _blue[key] = a return a def threshold_map(h, w, kind="bayer4", seed=0, ox=0, oy=0): if kind == "bayer2": return tile(BAYER2, h, w, ox, oy) if kind == "bayer4": return tile(BAYER4, h, w, ox, oy) if kind == "checker": return tile(np.array([[0.25, 0.75], [0.75, 0.25]]), h, w, ox, oy) if kind == "blue": return tile(blue_noise(64, seed), h, w, ox, oy) if kind == "white": return np.random.default_rng(seed).random((h, w)) if kind == "clump": # 2-px clustered (observation arm: dither in 2-px clumps, never salt and pepper) b = blue_noise(64, seed) return tile(np.kron(b[:32, :32], np.ones((2, 2))), h, w, ox, oy) raise ValueError(kind) def quantize(x, thr, lo=None, hi=None): """continuous step coordinate x -> integer step, dithering between floor and ceil by threshold. lo/hi: per-pixel clamp (the light family), so dither never crosses the terminator.""" f = np.floor(x); frac = x - f s = f + (frac > thr) if lo is not None: s = np.maximum(s, lo) if hi is not None: s = np.minimum(s, hi) return s.astype(np.int32) def flat_bands(x, thr, seam=0.18): """Ferrari's sky/water rule: hold each step flat, dither only in a narrow seam around the half step. seam = the fraction of each step that is dithered.""" f = np.floor(x); frac = x - f t = np.clip((frac - (0.5 - seam / 2)) / seam, 0, 1) return (f + (t > thr)).astype(np.int32) </pre></details><details class="step"><summary><code>Bash: Test heightfield renderer for iso and far cameras</code></summary><pre>cd ~/work/pixelart-studies/aerial && cat > scratch/t_render.py <<'EOF' import sys, time; sys.path.insert(0,'lib') import numpy as np from PIL import Image from terrain import Terrain, sun_vector from camera import Iso, Persp import noise as N n=384; cell=6.0 jj,ii=np.mgrid[0:n,0:n]*cell H=900*N.fbm(ii,jj,seed=3,scale=1500,octaves=6)+400*N.ridged(ii,jj,seed=5,scale=900,octaves=5) T=Terrain(H,cell) t0=time.time() cam=Iso(target=(n*cell/2,n*cell/2,H.mean()),mpp=4.0,elev=30,yaw=0,w=320,h=180) G=T.gbuffer(cam); print('iso',time.time()-t0, G['hit'].mean()) sun=sun_vector(30,245) sh=T.sun_shadow(sun); print('shadow',time.time()-t0) vis=T.sample(sh,G['x'],G['y']) ndl=np.clip((G['n']*sun).sum(-1),0,1)*vis img=(np.clip(ndl*0.8+0.15,0,1)*255).astype(np.uint8) Image.fromarray(img).resize((960,540),Image.NEAREST).save('scratch/t_iso.png') cam2=Persp(target=(n*cell/2,n*cell*0.6,H.mean()),dist=2600,pitch=28,yaw=0,vfov=40,w=320,h=180) t0=time.time();G2=T.gbuffer(cam2);print('persp',time.time()-t0) vis=T.sample(sh,G2['x'],G2['y']) ndl=np.clip((G2['n']*sun).sum(-1),0,1)*vis img=np.where(G2['hit'],np.clip(ndl*0.8+0.15,0,1),0.9) Image.fromarray((img*255).astype(np.uint8)).resize((960,540),Image.NEAREST).save('scratch/t_far.png') EOF nice -n 10 python3 scratch/t_render.py # output: iso 0.26722288131713867 1.0 shadow 1.6631669998168945 persp 0.39430975914001465</pre></details><details class="step"><summary><code>Bash: Stack test renders</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * vstack([load('scratch/t_iso.png'),load('scratch/t_far.png')]).save('scratch/t_both.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/t_both.png</code></div></div>  *24. aerial/scratch/t_both.png* <div class="steps"><details class="step"><summary><code>Write: aerial/lib/landform.py</code></summary><pre>"""landform.py -- heightfields that look like land from above: gradient noise with derivative damping (slopes smooth, crests sharp), ridged ranges, a vectorised droplet erosion pass (fall-line gullies and debris), and shape primitives for the subjects (valley trough, cirque bowl, coast). All fields are grids in metres; helpers take the grid coordinates X, Y (metres). """ import numpy as np from scipy import ndimage as ndi _P = {} def _grad_table(seed): if seed not in _P: rng = np.random.default_rng(seed) perm = rng.permutation(256) ang = rng.random(256) * 2 * np.pi _P[seed] = (np.concatenate([perm, perm]), np.cos(ang), np.sin(ang)) return _P[seed] def perlin(x, y, seed=0): """gradient noise in about [-0.7, 0.7] with analytic derivatives: returns (n, dn/dx, dn/dy).""" perm, gx, gy = _grad_table(seed) xi = np.floor(x).astype(np.int64); yi = np.floor(y).astype(np.int64) fx = x - xi; fy = y - yi xi &= 255; yi &= 255 def g(ix, iy): h = perm[perm[ix] + iy] return gx[h], gy[h] g00 = g(xi, yi); g10 = g((xi + 1) & 255, yi); g01 = g(xi, (yi + 1) & 255); g11 = g((xi + 1) & 255, (yi + 1) & 255) d00 = g00[0] * fx + g00[1] * fy d10 = g10[0] * (fx - 1) + g10[1] * fy d01 = g01[0] * fx + g01[1] * (fy - 1) d11 = g11[0] * (fx - 1) + g11[1] * (fy - 1) u = fx * fx * fx * (fx * (fx * 6 - 15) + 10); v = fy * fy * fy * (fy * (fy * 6 - 15) + 10) du = 30 * fx * fx * (fx * (fx - 2) + 1); dv = 30 * fy * fy * (fy * (fy - 2) + 1) a = d00; b = d10 - d00; c = d01 - d00; d = d11 - d10 - d01 + d00 n = a + b * u + c * v + d * u * v # derivative (approximate gradient term + interpolation term) ga_x = g00[0] + (g10[0] - g00[0]) * u + (g01[0] - g00[0]) * v + (g11[0] - g10[0] - g01[0] + g00[0]) * u * v ga_y = g00[1] + (g10[1] - g00[1]) * u + (g01[1] - g00[1]) * v + (g11[1] - g10[1] - g01[1] + g00[1]) * u * v dx = ga_x + (b + d * v) * du dy = ga_y + (c + d * u) * dv return n, dx, dy def eroded_fbm(X, Y, scale, octaves=8, seed=0, damp=1.0, gain=0.5): """Quilez-style fbm: each octave is damped by the accumulated slope, so slopes stay smooth and detail concentrates on flats and crests. Returns roughly [-1, 1].""" x = X / scale; y = Y / scale out = np.zeros_like(x); dsx = np.zeros_like(x); dsy = np.zeros_like(x) amp = 1.0; tot = 0.0 for o in range(octaves): c, s = np.cos(0.6 * o + 0.3), np.sin(0.6 * o + 0.3) xr = c * x - s * y + 13.1 * o; yr = s * x + c * y - 7.7 * o n, dx, dy = perlin(xr, yr, seed + o) dxw = c * dx + s * dy; dyw = -s * dx + c * dy # derivative back in unrotated axes dsx += dxw * amp * (2.0 ** o); dsy += dyw * amp * (2.0 ** o) out += amp * n / (1 + damp * (dsx * dsx + dsy * dsy)) tot += amp; amp *= gain x = x * 2.0; y = y * 2.0 return out / tot * 1.6 def ridged(X, Y, scale, octaves=6, seed=0, gain=0.5): """sharp-crested ridges in [0, 1].""" x = X / scale; y = Y / scale out = np.zeros_like(x); amp = 1.0; tot = 0.0; w = np.ones_like(x) for o in range(octaves): n, _, _ = perlin(x + 5.3 * o, y - 3.1 * o, seed + 31 * o) r = 1 - np.abs(n * 1.4) r = r * r * w w = np.clip(r * 1.5, 0, 1) out += amp * r; tot += amp; amp *= gain x = x * 2.02; y = y * 2.02 return out / tot def fbm(X, Y, scale, octaves=5, seed=0, gain=0.5): x = X / scale; y = Y / scale out = np.zeros_like(x); amp = 1.0; tot = 0.0 for o in range(octaves): n, _, _ = perlin(x + 3.7 * o, y + 9.2 * o, seed + 17 * o) out += amp * n; tot += amp; amp *= gain; x = x * 2.0; y = y * 2.0 return out / tot * 1.6 def droplet_erosion(H, cell, n_drops=60000, steps=80, seed=0, erode=0.3, deposit=0.3, capacity=4.0, inertia=0.05, evaporate=0.02, gravity=4.0, radius=1, batch=20000): """vectorised hydraulic erosion (droplets carry sediment down the fall line; they erode where fast and deposit where slow). Carves fall-line gullies and builds debris fans at slope breaks.""" H = H.copy() ny, nx = H.shape rng = np.random.default_rng(seed) hscale = cell # work in cell units for the height too Hc = H / hscale for b0 in range(0, n_drops, batch): nb = min(batch, n_drops - b0) px = rng.random(nb) * (nx - 2); py = rng.random(nb) * (ny - 2) dx = np.zeros(nb); dy = np.zeros(nb); vel = np.ones(nb); water = np.ones(nb); sed = np.zeros(nb) alive = np.ones(nb, bool) for _ in range(steps): ix = np.clip(px.astype(int), 0, nx - 2); iy = np.clip(py.astype(int), 0, ny - 2) u = px - ix; v = py - iy h00 = Hc[iy, ix]; h10 = Hc[iy, ix + 1]; h01 = Hc[iy + 1, ix]; h11 = Hc[iy + 1, ix + 1] gx = (h10 - h00) * (1 - v) + (h11 - h01) * v gy = (h01 - h00) * (1 - u) + (h11 - h10) * u hcur = h00 * (1 - u) * (1 - v) + h10 * u * (1 - v) + h01 * (1 - u) * v + h11 * u * v dx = dx * inertia - gx * (1 - inertia); dy = dy * inertia - gy * (1 - inertia) ln = np.hypot(dx, dy) + 1e-9 dx /= ln; dy /= ln nxp = px + dx; nyp = py + dy out = (nxp < 0) | (nxp >= nx - 1) | (nyp < 0) | (nyp >= ny - 1) alive &= ~out nxp = np.clip(nxp, 0, nx - 1.001); nyp = np.clip(nyp, 0, ny - 1.001) jx = nxp.astype(int); jy = nyp.astype(int); uu = nxp - jx; vv = nyp - jy jx = np.clip(jx, 0, nx - 2); jy = np.clip(jy, 0, ny - 2) hnew = (Hc[jy, jx] * (1 - uu) * (1 - vv) + Hc[jy, jx + 1] * uu * (1 - vv) + Hc[jy + 1, jx] * (1 - uu) * vv + Hc[jy + 1, jx + 1] * uu * vv) dh = hnew - hcur cap = np.maximum(-dh, 0.01) * vel * water * capacity dep = np.where((sed > cap) | (dh > 0), np.where(dh > 0, np.minimum(dh, sed), (sed - cap) * deposit), 0.0) ero = np.where((sed <= cap) & (dh <= 0), np.minimum((cap - sed) * erode, -dh), 0.0) amt = (dep - ero) * alive sed = sed - amt w00 = (1 - u) * (1 - v); w10 = u * (1 - v); w01 = (1 - u) * v; w11 = u * v np.add.at(Hc, (iy, ix), amt * w00); np.add.at(Hc, (iy, ix + 1), amt * w10) np.add.at(Hc, (iy + 1, ix), amt * w01); np.add.at(Hc, (iy + 1, ix + 1), amt * w11) vel = np.sqrt(np.maximum(vel * vel + (-dh) * gravity, 0.0)) water *= (1 - evaporate) px, py = nxp, nyp if not alive.any(): break H = Hc * hscale return ndi.gaussian_filter(H, 0.5) * 0.3 + H * 0.7 def smooth_max(a, b, k): h = np.clip(0.5 + 0.5 * (a - b) / k, 0, 1) return a * h + b * (1 - h) + k * h * (1 - h) def smooth_min(a, b, k): return -smooth_max(-a, -b, k) </pre></details><details class="step"><summary><code>Bash: Test eroded landform generation and rendering</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='terrain.py'; s=open(p).read() s=s.replace(""" h = self.height(P[:, 0], P[:, 1]) gap = P[:, 2] - h""",""" h = self.height(P[:, 0], P[:, 1]) fi, fj = self.ij(P[:, 0], P[:, 1]) outside = (fi < 0) | (fi > self.nx - 1) | (fj < 0) | (fj > self.ny - 1) h = np.where(outside, -1e9, h) gap = P[:, 2] - h""") s=s.replace(""" step = np.maximum(gap * slope_k / np.maximum(-D[active, 2], 0.05), min_step)""",""" step = np.maximum(np.minimum(gap, 1e6) * slope_k / np.maximum(-D[active, 2], 0.05), min_step)""") open(p,'w').write(s) EOF cd .. && cat > scratch/t_land.py <<'EOF' import sys, time; sys.path.insert(0,'lib') import numpy as np from PIL import Image from terrain import Terrain, sun_vector from camera import Iso, Persp import landform as LF n=384; cell=8.0 Y,X=np.mgrid[0:n,0:n]*cell H=1400*(0.5+0.5*LF.eroded_fbm(X,Y,2200,octaves=8,seed=4))+500*LF.ridged(X,Y,1500,seed=2) t0=time.time(); H2=LF.droplet_erosion(H,cell,n_drops=80000,seed=1); print('erode',time.time()-t0) sun=sun_vector(30,245) for name,HH in [('raw',H),('ero',H2)]: T=Terrain(HH,cell) cam=Iso(target=(n*cell/2,n*cell/2,HH.mean()),mpp=6.0,elev=30,yaw=0,w=320,h=180) G=T.gbuffer(cam); sh=T.sun_shadow(sun) vis=T.sample(sh,G['x'],G['y']) ndl=np.clip((G['n']*sun).sum(-1),0,1)*vis img=np.where(G['hit'],np.clip(ndl*0.8+0.15,0,1),0.5) Image.fromarray((img*255).astype(np.uint8)).resize((640,360),Image.NEAREST).save(f'scratch/t_land_{name}.png') np.save('scratch/H_ero.npy',H2) EOF nice -n 10 python3 scratch/t_land.py && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * hstack([load('scratch/t_land_raw.png'),load('scratch/t_land_ero.png')]).save('scratch/t_land.png')" # output: ~/work/pixelart-studies/aerial/lib/landform.py:122: RuntimeWarning: overflow encountered in multiply cap = np.maximum(-dh, 0.01) * vel * water * capacity ~/miniconda3/lib/python3.12/site-packages/numpy/linalg/linalg.py:2582: RuntimeWarning: overflow encountered in multiply s = (x.conj() * x).real ~/miniconda3/lib/python3.12/site-packages/numpy/linalg/linalg.py:2583: RuntimeWarning: overflow encountered in reduce return sqrt(add.reduce(s, axis=axis, keepdims=keepdims)) ~/work/pixelart-studies/aerial/lib/terrain.py:173: RuntimeWarning: invalid value encountered in divide n = n / np.linalg.norm(n, axis=-1, keepdims=True) ~/work/pixelart-studies/aerial/scratch/t_land.py:19: RuntimeWarning: invalid value encountered in cast Image.fromarray((img*255).astype(np.uint8)).resize((640,360),Image.NEAREST).save(f'scratch/t_land_{name}.png') erode 0.8423769474029541</pre></details><details class="step"><summary><code>Bash: Fix erosion overflow and rerun</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='lib/landform.py'; s=open(p).read() s=s.replace("vel = np.sqrt(np.maximum(vel * vel + (-dh) * gravity, 0.0))","vel = np.clip(np.sqrt(np.maximum(vel * vel + (-dh) * gravity, 0.0)), 0, 8.0)") s=s.replace("cap = np.maximum(-dh, 0.01) * vel * water * capacity","cap = np.minimum(np.maximum(-dh, 0.01), 2.0) * vel * water * capacity") open(p,'w').write(s) EOF nice -n 10 python3 scratch/t_land.py && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * hstack([load('scratch/t_land_raw.png'),load('scratch/t_land_ero.png')]).save('scratch/t_land.png')" # output: erode 0.9046311378479004</pre></details><div class="step"><code>Read: aerial/scratch/t_land.png</code></div></div>  *25. aerial/scratch/t_land.png* <div class="steps"><details class="step"><summary><code>Bash: Gentler blurred erosion and rerun</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='lib/landform.py'; s=open(p).read() s=s.replace(""" alive = np.ones(nb, bool) for _ in range(steps):""",""" alive = np.ones(nb, bool) for st in range(steps): if st % 8 == 0: if st > 0: Hc += ndi.gaussian_filter(dH, 0.8) dH = np.zeros_like(Hc)""") s=s.replace(""" np.add.at(Hc, (iy, ix), amt * w00); np.add.at(Hc, (iy, ix + 1), amt * w10) np.add.at(Hc, (iy + 1, ix), amt * w01); np.add.at(Hc, (iy + 1, ix + 1), amt * w11)""",""" np.add.at(dH, (iy, ix), amt * w00); np.add.at(dH, (iy, ix + 1), amt * w10) np.add.at(dH, (iy + 1, ix), amt * w01); np.add.at(dH, (iy + 1, ix + 1), amt * w11)""") s=s.replace(""" if not alive.any(): break H = Hc * hscale""",""" if not alive.any(): break Hc += ndi.gaussian_filter(dH, 0.8) H = Hc * hscale""") s=s.replace("erode=0.3, deposit=0.3, capacity=4.0","erode=0.08, deposit=0.1, capacity=2.0") open(p,'w').write(s) EOF sed -i '' 's/n_drops=80000,seed=1/n_drops=200000,seed=1/' scratch/t_land.py nice -n 10 python3 scratch/t_land.py && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * hstack([load('scratch/t_land_raw.png'),load('scratch/t_land_ero.png')]).save('scratch/t_land.png')" # output: erode 2.355682134628296</pre></details><div class="step"><code>Read: aerial/scratch/t_land.png</code></div></div>  *26. aerial/scratch/t_land.png* <div class="steps"><details class="step"><summary><code>Bash: Check fetch status</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs; pgrep -f imgfetch >/dev/null && echo running; ls -d */ | wc -l; tail -3 fetch.log | cut -c1-150 # output: running 20 download failed: HTTP Error 429: Too many requests - please contact noc@wikimedia.org to discuss a less disruptive approach or instead use thumbnail download failed: HTTP Error 429: Too many requests - please contact noc@wikimedia.org to discuss a less disruptive approach or instead use thumbnail download failed: HTTP Error 429: Too many requests - please contact noc@wikimedia.org to discuss a less disruptive approach or instead use thumbnail</pre></details><details class="step"><summary><code>Bash: Find canopy photo filenames</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs; ls drone_river_meadow_valley drone_forest_canopy_oblique | grep -i -E "cosum|jungle|epping|over_the|drone_forest|sahas" # output: drone_forest_canopy_oblique: commons_Aerial_view_of_Sahasradhara_Waterfall_and_forest_4013f9c1.jpg commons_Drone_Forest_Unsplash_jpg_59394478.jpg commons_Jungle_exploration_jpg_7f6b17fc.jpg openverse_Autumn_in_Epping_Forest_5967ce1a.jpg openverse_Over_the_forest_f030305a.jpg commons_Cosumnes_River_drone_jpg_d9b23c68.jpg</pre></details><div class="step"><code>Read: aerial/refs/drone_river_meadow_valley/commons_Cosumnes_River_drone_jpg_d9b23c68.jpg</code></div></div>  *27. aerial/refs/drone_river_meadow_valley/commons_Cosumnes_River_drone_jpg_d9b23c68.jpg* <div class="steps"><details class="step"><summary><code>Write: aerial/measure_photos.py</code></summary><pre>"""measure_photos.py -- what the oblique photos say, in numbers. For each (photo, box, subject) it measures, on CIE L*: crown : canopy texture period (px, first minimum of the radial autocorrelation), lit fraction, lit/gap L* (p85 / p10), vertical:horizontal correlation (crown elongation in oblique view), and where the dark sits relative to the light (cross-correlation offset of lit and gap masks) tone : median L*, chroma, hue of a region (albedos, river, snow, scree, haze) Writes measure/photo_stats.json and a contact atlas measure/atlas_boxes.png. nice -n 10 python3 measure_photos.py """ import json, os, sys import numpy as np from PIL import Image, ImageDraw from scipy import ndimage as ndi from skimage.color import rgb2lab ROOT = os.path.dirname(os.path.abspath(__file__)) R = lambda p: os.path.join(ROOT, "refs", p) os.makedirs(os.path.join(ROOT, "measure"), exist_ok=True) def lab_of(im): return rgb2lab(np.asarray(im, float)[..., :3] / 255.0) def radial_ac(L): """radially averaged autocorrelation of the mean-removed patch.""" a = L - ndi.gaussian_filter(L, max(L.shape) / 6) F = np.fft.fft2(a, s=(2 * a.shape[0], 2 * a.shape[1])) ac = np.real(np.fft.ifft2(F * np.conj(F))); ac /= ac[0, 0] ac = np.fft.fftshift(ac) cy, cx = np.array(ac.shape) // 2 yy, xx = np.indices(ac.shape) r = np.hypot(yy - cy, xx - cx).astype(int) prof = np.bincount(r.ravel(), ac.ravel()) / np.bincount(r.ravel()) return prof[:min(a.shape) // 2], ac, (cy, cx) def crown_stats(im, box): Lab = lab_of(im.crop(box)); L = Lab[..., 0] prof, ac, (cy, cx) = radial_ac(L) # texture period: first local minimum of the radial profile mins = [i for i in range(2, len(prof) - 1) if prof[i] < prof[i - 1] and prof[i] <= prof[i + 1]] period = 2 * mins[0] if mins else float("nan") # min at half a period half = next((i for i, v in enumerate(prof) if v < 0.5), len(prof)) # elongation: correlation length along y vs x row = ac[cy, cx:]; col = ac[cy:, cx] lx = next((i for i, v in enumerate(row) if v < 0.5), len(row)) ly = next((i for i, v in enumerate(col) if v < 0.5), len(col)) lo = ndi.gaussian_filter(L, max(L.shape) / 6) hp = L - lo lit = hp > np.percentile(hp, 60); gap = hp < np.percentile(hp, 25) # where is the dark relative to the light? peak of cross-correlation of the two masks A = lit.astype(float) - lit.mean(); B = gap.astype(float) - gap.mean() F = np.fft.fft2(A) * np.conj(np.fft.fft2(B)) xc = np.fft.fftshift(np.real(np.fft.ifft2(F))) c0y, c0x = np.array(xc.shape) // 2 win = max(2, int(period)) if np.isfinite(period) else 6 sub = xc[c0y - win:c0y + win + 1, c0x - win:c0x + win + 1] # gap offset from lit = argmin of correlation (anti-correlated at 0; the nearest positive lobe is # where dark sits). report the centroid of the positive part. ys, xs = np.mgrid[-win:win + 1, -win:win + 1] pos = np.clip(sub, 0, None) off = (float((pos * xs).sum() / (pos.sum() + 1e-9)), float((pos * ys).sum() / (pos.sum() + 1e-9))) C = np.hypot(Lab[..., 1], Lab[..., 2]) return dict(period_px=float(period), ac_half_px=float(half), elong_y_over_x=float(ly / max(lx, 1)), lit_frac=float((hp > 0.5 * (np.percentile(hp, 90) + np.percentile(hp, 10))).mean()), L_lit_p85=float(np.percentile(L, 85)), L_gap_p10=float(np.percentile(L, 10)), L_med=float(np.median(L)), chroma_med=float(np.median(C)), dark_offset_from_lit_px=off, rgb_med=[float(v) for v in np.median(np.asarray(im.crop(box), float).reshape(-1, 3), 0)]) def tone_stats(im, box): a = np.asarray(im.crop(box), float)[..., :3] Lab = lab_of(im.crop(box)) C = np.hypot(Lab[..., 1], Lab[..., 2]); hue = np.degrees(np.arctan2(np.median(Lab[..., 2]), np.median(Lab[..., 1]))) return dict(L_med=float(np.median(Lab[..., 0])), L_p10=float(np.percentile(Lab[..., 0], 10)), L_p90=float(np.percentile(Lab[..., 0], 90)), chroma_med=float(np.median(C)), hue_deg=float(hue % 360), rgb_med=[float(v) for v in np.median(a.reshape(-1, 3), 0)]) FOREST = "aerial_view_forested_mountain_slope/" CONIF = "aerial_conifer_forest_hillside/" DRONE = "drone_forest_canopy_oblique/" RIV = "drone_river_meadow_valley/" # (label, file, box, kind) ITEMS = [ ("conifer_near_dawn", FOREST + "commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg", (0, 640, 500, 959), "crown"), ("conifer_mid_dawn", FOREST + "commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg", (700, 520, 1280, 700), "crown"), ("conifer_dense_overcast_near", CONIF + "openverse_Between_Dangerous_River_and_Alsek_River_c0688f25.jpg", (0, 450, 1024, 767), "crown"), ("conifer_dense_overcast_far", CONIF + "openverse_Between_Dangerous_River_and_Alsek_River_c0688f25.jpg", (0, 0, 1024, 180), "crown"), ("broadleaf_sun_near", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (700, 420, 1200, 620), "crown"), ("broadleaf_sun_mid", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (0, 220, 480, 330), "crown"), ("broadleaf_sun_far", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (850, 150, 1280, 200), "crown"), ("sparse_conifer_on_meadow", FOREST + "openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg", (0, 300, 360, 520), "crown"), ("far_slope_dotted_trees", FOREST + "openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg", (420, 120, 820, 280), "crown"), # tones ("meadow_sun", FOREST + "openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg", (160, 500, 460, 640), "tone"), ("meadow_green_dawn", FOREST + "commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg", (620, 480, 760, 540), "tone"), ("bare_slope_sun", FOREST + "openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg", (500, 60, 900, 200), "tone"), ("river_near", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (270, 600, 390, 700), "tone"), ("river_mid", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (520, 360, 580, 420), "tone"), ("river_far", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (700, 255, 780, 285), "tone"), ("dry_field_far", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (400, 180, 560, 215), "tone"), ("canopy_far_band", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (900, 145, 1280, 165), "tone"), ("canopy_near_band", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (0, 600, 200, 700), "tone"), ("sky_horizon", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (0, 100, 1280, 125), "tone"), ("sky_top", RIV + "commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (0, 0, 1280, 20), "tone"), ] def run(items=ITEMS, out="measure/photo_stats.json"): res = {} thumbs = [] for lab_, f, box, kind in items: p = R(f) if not os.path.exists(p): print("missing", f); continue im = Image.open(p).convert("RGB") st = crown_stats(im, box) if kind == "crown" else tone_stats(im, box) st.update(file=f, box=box, kind=kind) res[lab_] = st t = im.copy(); d = ImageDraw.Draw(t); d.rectangle(box, outline=(255, 40, 40), width=4) d.text((box[0] + 6, box[1] + 6), lab_, fill=(255, 255, 0)) thumbs.append(t.resize((320, int(320 * t.size[1] / t.size[0])))) print(f"{lab_:30s}", {k: (round(v, 2) if isinstance(v, float) else v) for k, v in st.items() if k not in ("file", "box", "kind", "rgb_med")}) json.dump(res, open(os.path.join(ROOT, out), "w"), indent=1) cols = 5; W = 320; Hs = [t.size[1] for t in thumbs] rows = (len(thumbs) + cols - 1) // cols; rh = max(Hs) A = Image.new("RGB", (cols * W, rows * rh), (20, 20, 24)) for i, t in enumerate(thumbs): A.paste(t, ((i % cols) * W, (i // cols) * rh)) A.save(os.path.join(ROOT, out.replace(".json", "_atlas.png"))) return res if __name__ == "__main__": run() </pre></details><details class="step"><summary><code>Bash: Run photo measurements</code></summary><pre>cd ~/work/pixelart-studies/aerial && nice -n 10 python3 measure_photos.py 2>&1 | tail -30 # output: conifer_near_dawn {'period_px': 82.0, 'ac_half_px': 2.0, 'elong_y_over_x': 1.0, 'lit_frac': 0.31, 'L_lit_p85': 18.96, 'L_gap_p10': 1.39, 'L_med': 7.57, 'chroma_med': 10.15, 'dark_offset_from_lit_px': (-11.81271689530376, -9.571208687460278)} conifer_mid_dawn {'period_px': nan, 'ac_half_px': 8.0, 'elong_y_over_x': 1.12, 'lit_frac': 0.41, 'L_lit_p85': 35.32, 'L_gap_p10': 4.74, 'L_med': 18.27, 'chroma_med': 12.93, 'dark_offset_from_lit_px': (0.0, 0.0)} conifer_dense_overcast_near {'period_px': 48.0, 'ac_half_px': 5.0, 'elong_y_over_x': 1.75, 'lit_frac': 0.49, 'L_lit_p85': 53.03, 'L_gap_p10': 30.0, 'L_med': 42.3, 'chroma_med': 18.38, 'dark_offset_from_lit_px': (4.207107057667392, -6.991524917497627)} conifer_dense_overcast_far {'period_px': 58.0, 'ac_half_px': 2.0, 'elong_y_over_x': 2.0, 'lit_frac': 0.54, 'L_lit_p85': 59.71, 'L_gap_p10': 46.13, 'L_med': 54.03, 'chroma_med': 12.45, 'dark_offset_from_lit_px': (0.0, 0.0)} broadleaf_sun_near {'period_px': 72.0, 'ac_half_px': 1.0, 'elong_y_over_x': 0.5, 'lit_frac': 0.59, 'L_lit_p85': 70.45, 'L_gap_p10': 24.14, 'L_med': 53.2, 'chroma_med': 29.67, 'dark_offset_from_lit_px': (-0.8228193801934945, 2.6349000029121554)} broadleaf_sun_mid {'period_px': 52.0, 'ac_half_px': 1.0, 'elong_y_over_x': 1.0, 'lit_frac': 0.6, 'L_lit_p85': 59.79, 'L_gap_p10': 7.36, 'L_med': 40.94, 'chroma_med': 11.57, 'dark_offset_from_lit_px': (2.2813917792321092, -0.07636862658845595)} broadleaf_sun_far {'period_px': 20.0, 'ac_half_px': 1.0, 'elong_y_over_x': 0.5, 'lit_frac': 0.55, 'L_lit_p85': 64.28, 'L_gap_p10': 30.28, 'L_med': 50.33, 'chroma_med': 8.69, 'dark_offset_from_lit_px': (0.1359641531567893, 1.547337448797061)} sparse_conifer_on_meadow {'period_px': 102.0, 'ac_half_px': 5.0, 'elong_y_over_x': 0.83, 'lit_frac': 0.54, 'L_lit_p85': 66.4, 'L_gap_p10': 13.11, 'L_med': 40.98, 'chroma_med': 10.83, 'dark_offset_from_lit_px': (4.884251115887201, 34.572448342479035)} Traceback (most recent call last): File "~/work/pixelart-studies/aerial/measure_photos.py", line 141, in <module> run() File "~/work/pixelart-studies/aerial/measure_photos.py", line 123, in run st = crown_stats(im, box) if kind == "crown" else tone_stats(im, box) ^^^^^^^^^^^^^^^^^^^^ File "~/work/pixelart-studies/aerial/measure_photos.py", line 65, in crown_stats off = (float((pos * xs).sum() / (pos.sum() + 1e-9)), float((pos * ys).sum() / (pos.sum() + 1e-9))) ~~~~^~~~ ValueError: operands could not be broadcast together with shapes (14,189) (189,189)</pre></details><details class="step"><summary><code>Bash: Rewrite crown measurement with blob detection</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='measure_photos.py'; s=open(p).read() start=s.index('def crown_stats'); end=s.index('def tone_stats') new='''def crown_stats(im, box, overlay=None): """crowns found as bright blobs (scale-normalised LoG): spacing, size, and where the dark sits.""" from skimage.feature import blob_log Lab = lab_of(im.crop(box)); L = ndi.gaussian_filter(Lab[..., 0], 1.0) Ln = (L - L.min()) / (np.ptp(L) + 1e-9) blobs = blob_log(Ln, min_sigma=1.5, max_sigma=25, num_sigma=24, threshold=0.04, overlap=0.6) ys, xs, sg = blobs[:, 0], blobs[:, 1], blobs[:, 2] r = sg * np.sqrt(2) from scipy.spatial import cKDTree nn = cKDTree(np.c_[xs, ys]).query(np.c_[xs, ys], k=2)[0][:, 1] if len(xs) > 2 else np.array([np.nan]) # dark offset: from each crown centre, the centroid of the darkest 20% within 2r offs = [] for y, x, rr in zip(ys, xs, r): R2 = int(max(3, 2 * rr)); y0, y1 = int(max(0, y - R2)), int(min(L.shape[0], y + R2 + 1)) x0, x1 = int(max(0, x - R2)), int(min(L.shape[1], x + R2 + 1)) sub = L[y0:y1, x0:x1] if sub.size < 9: continue m = sub < np.percentile(sub, 20) yy, xx = np.nonzero(m) offs.append(((xx + x0 - x).mean() / rr, (yy + y0 - y).mean() / rr)) offs = np.array(offs) if offs else np.zeros((1, 2)) lo = ndi.gaussian_filter(L, max(L.shape) / 6); hp = L - lo # elongation of crowns: correlation length of the high-pass along y vs x F = np.fft.fft2(hp); ac = np.real(np.fft.ifft2(F * np.conj(F))); ac /= ac[0, 0] lx = next((i for i in range(1, ac.shape[1] // 2) if ac[0, i] < 0.5), 1) ly = next((i for i in range(1, ac.shape[0] // 2) if ac[i, 0] < 0.5), 1) C = np.hypot(Lab[..., 1], Lab[..., 2]) if overlay is not None: t = im.crop(box).copy(); d = ImageDraw.Draw(t) for y, x, rr in zip(ys, xs, r): d.ellipse([x - rr, y - rr, x + rr, y + rr], outline=(255, 60, 60)) t.save(overlay) return dict(n_crowns=int(len(xs)), crown_r_med_px=float(np.median(r)) if len(r) else float("nan"), crown_spacing_px=float(np.nanmedian(nn)), elong_y_over_x=float(ly / max(lx, 1)), lit_frac=float((hp > 0.5 * (np.percentile(hp, 90) + np.percentile(hp, 10))).mean()), L_lit_p85=float(np.percentile(Lab[..., 0], 85)), L_gap_p10=float(np.percentile(Lab[..., 0], 10)), L_med=float(np.median(Lab[..., 0])), chroma_med=float(np.median(C)), dark_offset_in_radii=[float(v) for v in np.median(offs, 0)], rgb_med=[float(v) for v in np.median(np.asarray(im.crop(box), float).reshape(-1, 3), 0)]) ''' s=s[:start]+new+s[end:] s=s.replace('st = crown_stats(im, box) if kind == "crown" else tone_stats(im, box)','st = crown_stats(im, box, overlay=os.path.join(ROOT, "measure", f"crowns_{lab_}.png")) if kind == "crown" else tone_stats(im, box)') open(p,'w').write(s) EOF nice -n 10 python3 measure_photos.py 2>&1 | tail -30 # output: conifer_near_dawn {'n_crowns': 1168, 'crown_r_med_px': 2.12, 'crown_spacing_px': 6.71, 'elong_y_over_x': 1.38, 'lit_frac': 0.35, 'L_lit_p85': 18.96, 'L_gap_p10': 1.39, 'L_med': 7.57, 'chroma_med': 10.15, 'dark_offset_in_radii': [-0.029462782549439476, 0.15385578334474714]} conifer_mid_dawn {'n_crowns': 721, 'crown_r_med_px': 2.12, 'crown_spacing_px': 7.21, 'elong_y_over_x': 0.43, 'lit_frac': 0.41, 'L_lit_p85': 35.32, 'L_gap_p10': 4.74, 'L_med': 18.27, 'chroma_med': 12.93, 'dark_offset_in_radii': [0.1702570784128577, 0.05892556509887895]} conifer_dense_overcast_near {'n_crowns': 2426, 'crown_r_med_px': 2.12, 'crown_spacing_px': 7.28, 'elong_y_over_x': 1.5, 'lit_frac': 0.51, 'L_lit_p85': 53.03, 'L_gap_p10': 30.0, 'L_med': 42.3, 'chroma_med': 18.38, 'dark_offset_in_radii': [0.03181210190286022, 0.11352589536977414]} conifer_dense_overcast_far {'n_crowns': 2020, 'crown_r_med_px': 2.12, 'crown_spacing_px': 7.0, 'elong_y_over_x': 1.25, 'lit_frac': 0.56, 'L_lit_p85': 59.71, 'L_gap_p10': 46.13, 'L_med': 54.03, 'chroma_med': 12.45, 'dark_offset_in_radii': [-0.029462782549439476, -0.062312091828699574]} broadleaf_sun_near {'n_crowns': 1216, 'crown_r_med_px': 2.12, 'crown_spacing_px': 5.83, 'elong_y_over_x': 0.6, 'lit_frac': 0.55, 'L_lit_p85': 70.45, 'L_gap_p10': 24.14, 'L_med': 53.2, 'chroma_med': 29.67, 'dark_offset_in_radii': [0.0, -0.0031156045914349792]} broadleaf_sun_mid {'n_crowns': 791, 'crown_r_med_px': 2.12, 'crown_spacing_px': 5.39, 'elong_y_over_x': 0.8, 'lit_frac': 0.55, 'L_lit_p85': 59.79, 'L_gap_p10': 7.36, 'L_med': 40.94, 'chroma_med': 11.57, 'dark_offset_in_radii': [-0.029462782549439476, 0.03738725509721975]} broadleaf_sun_far {'n_crowns': 295, 'crown_r_med_px': 2.12, 'crown_spacing_px': 6.08, 'elong_y_over_x': 0.43, 'lit_frac': 0.52, 'L_lit_p85': 64.28, 'L_gap_p10': 30.28, 'L_med': 50.33, 'chroma_med': 8.69, 'dark_offset_in_radii': [-0.022676318972797812, 0.2357022603955158]} sparse_conifer_on_meadow {'n_crowns': 669, 'crown_r_med_px': 2.12, 'crown_spacing_px': 6.32, 'elong_y_over_x': 0.73, 'lit_frac': 0.52, 'L_lit_p85': 66.4, 'L_gap_p10': 13.11, 'L_med': 40.98, 'chroma_med': 10.83, 'dark_offset_in_radii': [-0.05892556509887895, 0.2056299030347086]} far_slope_dotted_trees {'n_crowns': 724, 'crown_r_med_px': 2.12, 'crown_spacing_px': 6.08, 'elong_y_over_x': 0.71, 'lit_frac': 0.5, 'L_lit_p85': 74.63, 'L_gap_p10': 43.34, 'L_med': 61.75, 'chroma_med': 4.2, 'dark_offset_in_radii': [0.05892556509887895, 0.029462782549439476]} meadow_sun {'L_med': 65.86, 'L_p10': 44.76, 'L_p90': 75.52, 'chroma_med': 15.24, 'hue_deg': 88.35} meadow_green_dawn {'L_med': 30.15, 'L_p10': 14.9, 'L_p90': 45.95, 'chroma_med': 30.4, 'hue_deg': 137.83} bare_slope_sun {'L_med': 63.27, 'L_p10': 42.06, 'L_p90': 78.83, 'chroma_med': 3.95, 'hue_deg': 354.05} river_near {'L_med': 22.66, 'L_p10': 2.73, 'L_p90': 27.43, 'chroma</pre></details><details class="step"><summary><code>Bash: Use dominant-scale blob detection for crowns</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='measure_photos.py'; s=open(p).read() s=s.replace(''' blobs = blob_log(Ln, min_sigma=1.5, max_sigma=25, num_sigma=24, threshold=0.04, overlap=0.6) ys, xs, sg = blobs[:, 0], blobs[:, 1], blobs[:, 2] r = sg * np.sqrt(2)''',''' # dominant bright-blob scale: the sigma where the scale-normalised LoG energy of bright blobs peaks sig = np.geomspace(1.5, 30, 28) en = [np.mean(np.clip(-(s_ ** 2) * ndi.gaussian_laplace(Ln, s_), 0, None)) for s_ in sig] s_dom = float(sig[int(np.argmax(en))]) from skimage.feature import peak_local_max sm = ndi.gaussian_filter(Ln, s_dom * 0.7) pk = peak_local_max(sm, min_distance=max(1, int(s_dom)), threshold_rel=0.0, exclude_border=False) ys, xs = pk[:, 0].astype(float), pk[:, 1].astype(float) r = np.full(len(xs), s_dom * np.sqrt(2)); sg = r''') s=s.replace("return dict(n_crowns=int(len(xs)),","return dict(n_crowns=int(len(xs)), blob_sigma_dom=s_dom,") open(p,'w').write(s) EOF nice -n 10 python3 measure_photos.py 2>&1 | grep -E "conifer|broadleaf|sparse|far_slope" | cut -c1-260 # output: conifer_near_dawn {'n_crowns': 50, 'blob_sigma_dom': 12.35, 'crown_r_med_px': 17.46, 'crown_spacing_px': 42.59, 'elong_y_over_x': 1.38, 'lit_frac': 0.35, 'L_lit_p85': 18.96, 'L_gap_p10': 1.39, 'L_med': 7.57, 'chroma_med': 10.15, 'dark_offset_in_ra conifer_mid_dawn {'n_crowns': 104, 'blob_sigma_dom': 6.35, 'crown_r_med_px': 8.97, 'crown_spacing_px': 22.07, 'elong_y_over_x': 0.43, 'lit_frac': 0.41, 'L_lit_p85': 35.32, 'L_gap_p10': 4.74, 'L_med': 18.27, 'chroma_med': 12.93, 'dark_offset_in_ra conifer_dense_overcast_near {'n_crowns': 299, 'blob_sigma_dom': 7.09, 'crown_r_med_px': 10.03, 'crown_spacing_px': 24.08, 'elong_y_over_x': 1.5, 'lit_frac': 0.51, 'L_lit_p85': 53.03, 'L_gap_p10': 30.0, 'L_med': 42.3, 'chroma_med': 18.38, 'dark_offset_in_rad conifer_dense_overcast_far {'n_crowns': 1167, 'blob_sigma_dom': 2.61, 'crown_r_med_px': 3.69, 'crown_spacing_px': 8.6, 'elong_y_over_x': 1.25, 'lit_frac': 0.56, 'L_lit_p85': 59.71, 'L_gap_p10': 46.13, 'L_med': 54.03, 'chroma_med': 12.45, 'dark_offset_in_ra broadleaf_sun_near {'n_crowns': 629, 'blob_sigma_dom': 2.61, 'crown_r_med_px': 3.69, 'crown_spacing_px': 8.54, 'elong_y_over_x': 0.6, 'lit_frac': 0.55, 'L_lit_p85': 70.45, 'L_gap_p10': 24.14, 'L_med': 53.2, 'chroma_med': 29.67, 'dark_offset_in_radi broadleaf_sun_mid {'n_crowns': 334, 'blob_sigma_dom': 2.61, 'crown_r_med_px': 3.69, 'crown_spacing_px': 8.25, 'elong_y_over_x': 0.8, 'lit_frac': 0.55, 'L_lit_p85': 59.79, 'L_gap_p10': 7.36, 'L_med': 40.94, 'chroma_med': 11.57, 'dark_offset_in_radi broadleaf_sun_far {'n_crowns': 155, 'blob_sigma_dom': 2.61, 'crown_r_med_px': 3.69, 'crown_spacing_px': 9.0, 'elong_y_over_x': 0.43, 'lit_frac': 0.52, 'L_lit_p85': 64.28, 'L_gap_p10': 30.28, 'L_med': 50.33, 'chroma_med': 8.69, 'dark_offset_in_radi sparse_conifer_on_meadow {'n_crowns': 13, 'blob_sigma_dom': 17.23, 'crown_r_med_px': 24.36, 'crown_spacing_px': 70.49, 'elong_y_over_x': 0.73, 'lit_frac': 0.52, 'L_lit_p85': 66.4, 'L_gap_p10': 13.11, 'L_med': 40.98, 'chroma_med': 10.83, 'dark_offset_in_r far_slope_dotted_trees {'n_crowns': 6, 'blob_sigma_dom': 30.0, 'crown_r_med_px': 42.43, 'crown_spacing_px': 116.0, 'elong_y_over_x': 0.71, 'lit_frac': 0.5, 'L_lit_p85': 74.63, 'L_gap_p10': 43.34, 'L_med': 61.75, 'chroma_med': 4.2, 'dark_offset_in_radii</pre></details></div> Let me check the overlays with my own eyes. <div class="steps"><details class="step"><summary><code>Bash: Stack crown detection overlays</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * a=load('measure/crowns_conifer_near_dawn.png'); b=load('measure/crowns_conifer_dense_overcast_near.png').crop((0,0,500,317)); c=load('measure/crowns_broadleaf_sun_near.png') hstack([a,b,c]).save('scratch/crown_overlays.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/crown_overlays.png</code></div></div>  *28. aerial/scratch/crown_overlays.png* <div class="steps"><details class="step"><summary><code>Bash: Print dark offsets and spacing ratios</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import json;d=json.load(open('measure/photo_stats.json')) for k,v in d.items(): if v['kind']=='crown': print(k, v['dark_offset_in_radii'], round(v['crown_spacing_px']/v['crown_r_med_px'],2))" # output: conifer_near_dawn [0.16652996349944396, 0.018164527739747766] 2.44 conifer_mid_dawn [0.09366152293286656, 0.17827558736944077] 2.46 conifer_dense_overcast_near [-0.020478371181737325, -0.06351262946219982] 2.4 conifer_dense_overcast_far [-0.04812156419266669, -0.024060782096333343] 2.33 broadleaf_sun_near [-0.024060782096333343, -0.07819754181308335] 2.31 broadleaf_sun_mid [-0.006015195524083336, -0.17143307243637507] 2.23 broadleaf_sun_far [0.0, 0.2766989941078334] 2.44 sparse_conifer_on_meadow [-0.24657822532553947, -0.10144296830698107] 2.89 far_slope_dotted_trees [-0.16234015849281808, -0.123612799471853] 2.73</pre></details><details class="step"><summary><code>Bash: Zoom isolated trees and shadows</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * im=load('refs/aerial_view_forested_mountain_slope/openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg') hstack([up(crop(im,(230,380,480,480)),3), up(crop(im,(100,540,300,640)),3)]).save('scratch/nrcs_trees.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/nrcs_trees.png</code></div></div>  *29. aerial/scratch/nrcs_trees.png* <div class="steps"><details class="step"><summary><code>Bash: Check fetch status</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs; pgrep -f imgfetch >/dev/null && echo running; ls -d */ | wc -l; ls -d */ # output: 23 aerial_coastline_cliffs/ aerial_conifer_forest_hillside/ aerial_river_valley_meadow/ aerial_valley_haze_mountains/ aerial_view_alpine_valley_river/ aerial_view_coast_beach_forest/ aerial_view_forested_mountain_slope/ aerial_view_mountain_range_haze/ aerial_view_snowfield_mountain/ aerial_village_clearing_forest/ alpine_tarn_from_above/ campfire_from_above/ cirque_lake_snow_mountain_from_above/ cliff_bands_mountain_aerial/ drone_forest_canopy_oblique/ drone_hut_clearing_forest/ drone_river_meadow_valley/ drone_rocky_coast_forest/ drone_view_pine_forest_shadows/ ferrari_lw/ glacial_cirque_tarn_aerial/ scree_slope_from_above/ talus_fan_mountain/</pre></details><details class="step"><summary><code>Bash: Start second fetch batch, Openverse only</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs && nohup nice -n 10 python3 ../../tools/imgfetch.py -f queries2.txt -n 12 -o . --src openverse --sheet > fetch2.log 2>&1 & echo started # output: started</pre></details><div class="step"><code>Read: aerial/refs/aerial_view_mountain_range_haze/_sheet.jpg</code></div></div>  *30. aerial/refs/aerial_view_mountain_range_haze/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_valley_haze_mountains/_sheet.jpg</code></div></div>  *31. aerial/refs/aerial_valley_haze_mountains/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_view_snowfield_mountain/_sheet.jpg</code></div></div>  *32. aerial/refs/aerial_view_snowfield_mountain/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_coastline_cliffs/_sheet.jpg</code></div></div>  *33. aerial/refs/aerial_coastline_cliffs/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/drone_rocky_coast_forest/_sheet.jpg</code></div></div>  *34. aerial/refs/drone_rocky_coast_forest/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_view_coast_beach_forest/_sheet.jpg</code></div></div>  *35. aerial/refs/aerial_view_coast_beach_forest/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/aerial_village_clearing_forest/_sheet.jpg</code></div></div>  *36. aerial/refs/aerial_village_clearing_forest/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/drone_hut_clearing_forest/_sheet.jpg</code></div></div>  *37. aerial/refs/drone_hut_clearing_forest/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/campfire_from_above/_sheet.jpg</code></div></div>  *38. aerial/refs/campfire_from_above/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/drone_view_pine_forest_shadows/_sheet.jpg</code></div></div>  *39. aerial/refs/drone_view_pine_forest_shadows/_sheet.jpg* <div class="steps"><details class="step"><summary><code>Write: aerial/lib/canvas.py</code></summary><pre>"""canvas.py -- the index canvas every technique paints into. mat[h, w] material id (pal.MAT_ID), 0 = nothing step[h, w] form class within the material's ramp (0 = core/contact dark .. top = highlight) band[h, w] depth band for aerial perspective (0 near .. 3 far) z[h, w] depth of what was painted there (ray distance, m), for object occlusion Sprites are dicts of arrays {a: alpha bool, mat: int, step: int} with an anchor (ax, ay) in px. """ import numpy as np from pal import MAT_ID class Canvas: def __init__(self, w, h): self.w, self.h = w, h self.mat = np.zeros((h, w), np.int32) self.step = np.zeros((h, w), np.int32) self.band = np.zeros((h, w), np.int32) self.z = np.full((h, w), np.inf) self.tag = np.zeros((h, w), np.int32) # free per-technique tags (e.g. 1 = canopy, 2 = water) def fill(self, mask, mat, step, band=None, z=None, tag=None): if isinstance(mat, str): mat = MAT_ID[mat] self.mat[mask] = mat if np.isscalar(mat) else mat[mask] self.step[mask] = step if np.isscalar(step) else step[mask] if band is not None: self.band[mask] = band if np.isscalar(band) else band[mask] if z is not None: self.z[mask] = z if np.isscalar(z) else z[mask] if tag is not None: self.tag[mask] = tag if np.isscalar(tag) else tag[mask] def blit(self, spr, x, y, z, ground_t=None, tol=0.0, band=None, tag=None): """paint sprite with its anchor at screen (x, y); depth z. Pixels are skipped where the terrain (ground_t) is nearer than z - tol (hidden behind a ridge) or an object nearer than z already sits (z-buffer).""" a = spr["a"]; sh, sw = a.shape x0 = int(round(x - spr["ax"])); y0 = int(round(y - spr["ay"])) xa, ya = max(0, x0), max(0, y0); xb, yb = min(self.w, x0 + sw), min(self.h, y0 + sh) if xa >= xb or ya >= yb: return sa = a[ya - y0:yb - y0, xa - x0:xb - x0] m = sa & (self.z[ya:yb, xa:xb] > z) if ground_t is not None: m &= ground_t[ya:yb, xa:xb] > z - tol if not m.any(): return sl = (slice(ya, yb), slice(xa, xb)) smat = spr["mat"][ya - y0:yb - y0, xa - x0:xb - x0] sst = spr["step"][ya - y0:yb - y0, xa - x0:xb - x0] self.mat[sl][m] = smat[m] if np.ndim(smat) else smat self.step[sl][m] = sst[m] self.z[sl][m] = z if band is not None: self.band[sl][m] = band if tag is not None: self.tag[sl][m] = tag </pre></details><details class="step"><summary><code>Write: aerial/lib/tech_canopy.py</code></summary><pre>"""tech_canopy.py -- forests from above: the crown-clump canopy stroke and its cast shadows. What the oblique photos say (measure/photo_stats.json, NOTES.md 'canopy'): * at 20-45 deg down, conifers still read as upright spires: lit tops on the sun side, the shade side and the gap below dark. Crown lit-caps are ~0.8 x the crown spacing; the gaps between them are narrow dark seams (spacing / lit radius = 2.3-2.5 in every canopy photo). * crowns are elongated vertically on screen (autocorrelation y/x = 1.25-1.5 for conifers). * the value range lives in the stroke: lit cap vs gap is 20-45 L* while the squinted mass is flat. * isolated trees cast short, flattened pools of shadow (ground foreshortened by sin 30 = 0.5). * broadleaf crowns are clumps of clumps: the dominant bright blob is a sub-crown leaf mass (~1/5 of the crown), each lit on its sun side. What Ferrari does (V16 conifers, V08 jungle canopy): conifer = 1-px spire, drooping tiers lengthening downward, lit dabs on the sun-side tier tips, ~15-20% holes; broadleaf = stacked scallops, each a small dome with a lit rim arc over a dark body, black between. Scale classes by crown width in screen px (w): w >= 5 CROWN sprite: a tiny shaded cone / clump cluster, then Ferrari marks on top 2 <= w SPIRE mark: lit dab over a dark stem, 1-2 px wide, height from the tree height w < 2 TEXTURE: the forest is a ground material; vertical lit-dab/dark-stem dashes stippled at the measured lit fraction, dash length = projected tree height (grain grows with nearness) """ import numpy as np from pal import MAT_ID from dither import threshold_map CON = MAT_ID["conifer"]; BRD = MAT_ID["broadleaf"] _cache = {} def _screen_sun(sun, cam): """sun direction in screen space: (sx, sy) with sy down, and the elevation term.""" sx = float(np.dot(sun, cam.right)); sy = -float(np.dot(sun, cam.up)) return sx, sy def conifer_sprite(w, h, sun, cam, seed=0, lit_ok=True, ramp_top=5): """a conifer crown w px wide and h px tall (screen), shaded as a tiered cone and quantised into the 6-step conifer ramp (0 core | 1 shadow | 2 reflected || 3 halftone | 4 lit | 5 highlight).""" key = ("con", w, h, round(sun[0], 2), round(sun[1], 2), round(sun[2], 2), seed % 6, lit_ok) if key in _cache: return _cache[key] rng = np.random.default_rng(seed % 6 + 100 * w + 7 * h) W = w + 2; Hh = h + 2 a = np.zeros((Hh, W), bool); st = np.zeros((Hh, W), np.int32) cx = (W - 1) / 2.0 tiers = max(1, int(round(h / 4.5))) sxs, sys_ = _screen_sun(sun, cam) side = 1 if sxs >= 0 else -1 # which screen side is lit elev = sun[2] for yy in range(Hh): v = (yy - 1) / max(h - 1, 1) # 0 at the tip, 1 at the base if v < 0 or v > 1.0: continue tpos = (v * tiers) % 1.0 if tiers > 1 else v # position inside a tier (0 top .. 1 bottom) r = 0.5 * w * (0.12 + 0.88 * v ** 0.9) if h >= 8 and v > 0.12: r *= 0.72 + 0.34 * tpos # drooping spurs: each tier widens to its bottom for xx in range(W): u = (xx - cx) / max(r, 0.5) if abs(u) > 1.0 + 1e-6: continue a[yy, xx] = True # normal of the cone at this screen x: across-the-crown angle, tilted down at tier bottoms nx = u; nz = 0.45 + (0.25 if tpos < 0.35 else -0.2 * tpos) ny = -np.sqrt(max(0.0, 1 - u * u)) # facing the camera n = np.array([nx, 0.0, nz]); n = n / (np.linalg.norm(n) + 1e-9) ndl = n[0] * abs(sun[0] if abs(sun[0]) > 1e-3 else 0) * side * np.sign(u) if False else None # light: horizontal part from the screen-side, vertical part from the sun elevation lit = (u * side) * np.hypot(sun[0], sun[1]) * 0.9 + nz * elev * 1.1 occ = (0.55 + 0.45 * (1 - v)) * (1 - 0.5 * max(0.0, tpos - 0.6)) # lower & tier bottoms darker if lit_ok and lit > 0.12: s = 3 + (lit > 0.45) + (lit > 0.8 and v < 0.6) else: s = 0 + (occ > 0.55) + (occ > 0.85 and (u * side) < -0.2) st[yy, xx] = s # Ferrari marks ---------------------------------------------------------- if h >= 6: # 1-px spire for the top ~15% top = max(1, int(0.15 * h)) for yy in range(1, 1 + top): row = np.nonzero(a[yy])[0] if len(row) > 1: keep = int(round(cx)) a[yy, :] = False; a[yy, keep] = True st[yy, keep] = 4 if lit_ok else 2 if h >= 8: # lit dabs on the sun-side tier tips; dark undersides just below each tier line for k in range(1, tiers + 1): yb = 1 + int(round(k / tiers * (h - 1))) - 1 if 1 <= yb < Hh: row = np.nonzero(a[yb])[0] if len(row): tip = row.max() if side > 0 else row.min() if lit_ok: st[yb, tip] = 5 if rng.random() < 0.7 else 4 if yb + 1 < Hh: under = np.nonzero(a[yb + 1])[0] for xx in under: if abs(xx - cx) < 0.5 * len(under) * 0.6 and st[yb + 1, xx] <= 2: st[yb + 1, xx] = 0 # ~15% holes in the interior (dark core shows through) inner = a.copy(); inner[:, 1:] &= a[:, :-1]; inner[:, :-1] &= a[:, 1:] holes = inner & (rng.random(a.shape) < 0.15) holes[:int(0.3 * Hh)] = False st[holes] = 0 spr = dict(a=a, mat=np.full(a.shape, CON), step=st, ax=cx, ay=Hh - 1.5) _cache[key] = spr return spr def broadleaf_sprite(w, h, sun, cam, seed=0, lit_ok=True): """a broadleaf crown: a cluster of 3-7 leaf masses, each shaded as a dome, front masses covering back ones (the scallop); lit rim arcs toward the sun, black seams between masses.""" key = ("brd", w, h, round(sun[0], 2), round(sun[1], 2), round(sun[2], 2), seed % 8, lit_ok) if key in _cache: return _cache[key] rng = np.random.default_rng(seed % 8 + 31 * w) W = w + 2; Hh = h + 2 a = np.zeros((Hh, W), bool); st = np.zeros((Hh, W), np.int32); zb = np.full((Hh, W), -1e9) sxs, _ = _screen_sun(sun, cam) L = np.array([np.sign(sxs) * np.hypot(sun[0], sun[1]) * 0.8, -0.35 * sun[2], sun[2]]) # screen-space light (x right, y down, z toward viewer/up) L = L / np.linalg.norm(L) n_cl = int(np.clip(round(w / 3.2), 1, 9)) cx0 = (W - 1) / 2; cy0 = (Hh - 1) / 2 blobs = [] for i in range(n_cl): ang = rng.random() * 2 * np.pi; rad = rng.random() ** 0.5 * 0.33 bx = cx0 + np.cos(ang) * rad * w; by = cy0 + np.sin(ang) * rad * h * 0.9 br = (0.28 + 0.14 * rng.random()) * w if n_cl > 1 else 0.5 * w blobs.append((bx, by, br)) blobs.sort(key=lambda b: b[1]) # top (far) first: nearer lower masses cover yy, xx = np.mgrid[0:Hh, 0:W] for bx, by, br in blobs: dx = (xx - bx) / br; dy = (yy - by) / (br * 0.9) d2 = dx * dx + dy * dy inside = d2 <= 1.0 nz = np.sqrt(np.clip(1 - d2, 0, 1)) depth = by + nz * br # lower & bulging = nearer m = inside & (depth > zb) ndl = dx * L[0] + dy * L[1] + nz * L[2] if lit_ok: s = np.where(ndl > 0.62, 5, np.where(ndl > 0.35, 4, np.where(ndl > 0.12, 3, np.where(ndl > -0.15, 2, np.where(ndl > -0.5, 1, 0))))) else: s = np.where(ndl > 0.2, 2, np.where(ndl > -0.3, 1, 0)) # the seam: a dark rim where this mass meets a mass behind it edge = inside & (d2 > 0.72) & (dy > -0.2) s = np.where(edge, np.minimum(s, 1), s) a |= m; st[m] = s[m]; zb[m] = depth[m] spr = dict(a=a, mat=np.full(a.shape, BRD), step=st, ax=(W - 1) / 2, ay=Hh - 1.5) _cache[key] = spr return spr def spire_mark(w, h, sun, cam, kind="conifer", lit_ok=True): """2-4 px wide trees: a lit dab on the sun side over a dark stem (the contrast inside the stroke).""" key = ("spire", kind, w, h, round(sun[0], 2), lit_ok) if key in _cache: return _cache[key] mat = CON if kind == "conifer" else BRD W = max(1, w); Hh = max(2, h) a = np.zeros((Hh, W), bool); st = np.zeros((Hh, W), np.int32) sxs, _ = _screen_sun(sun, cam) side = 1 if sxs >= 0 else -1 for yy in range(Hh): v = yy / max(Hh - 1, 1) if kind == "conifer": half = (W - 1) / 2 * min(1.0, 0.25 + v * 1.2) else: half = (W - 1) / 2 * (0.7 + 0.3 * np.sin(np.pi * min(1, v * 1.1))) for xx in range(W): if abs(xx - (W - 1) / 2) <= half + 0.01: a[yy, xx] = True sunside = (xx - (W - 1) / 2) * side >= 0 if lit_ok and (v < 0.5 or (sunside and v < 0.8)): st[yy, xx] = 4 if (sunside or W == 1) and v < 0.34 else 3 else: st[yy, xx] = 1 if v < 0.85 else 0 spr = dict(a=a, mat=np.full(a.shape, mat), step=st, ax=(W - 1) / 2, ay=Hh - 1) _cache[key] = spr return spr # --------------------------------------------------------------------- stands def scatter_trees(T, density, spacing, rng, kind_field=None, hmean=18.0, jitter=0.45, clump=None): """place trees on a jittered grid of `spacing` metres, kept where rng < density(x, y). clump: optional field in [0,1] multiplying density (stand structure: gaps and dense groups). Returns arrays x, y, z(base), height, crown width, kind (0 conifer / 1 broadleaf).""" x0, y0, x1, y1 = T.extent xs = np.arange(x0 + spacing / 2, x1, spacing); ys = np.arange(y0 + spacing / 2, y1, spacing) X, Y = np.meshgrid(xs, ys) X = X + (rng.random(X.shape) - 0.5) * 2 * jitter * spacing Y = Y + (rng.random(Y.shape) - 0.5) * 2 * jitter * spacing X = X.ravel(); Y = Y.ravel() d = T.sample(density, X, Y) if clump is not None: d = d * T.sample(clump, X, Y) keep = rng.random(len(X)) < d X, Y = X[keep], Y[keep] Z = T.height(X, Y) kind = np.zeros(len(X), int) if kind_field is None else (rng.random(len(X)) < T.sample(kind_field, X, Y)).astype(int) Ht = hmean * (0.7 + 0.6 * rng.random(len(X))) Wc = np.where(kind == 0, Ht * (0.28 + 0.08 * rng.random(len(X))), Ht * (0.55 + 0.2 * rng.random(len(X)))) return dict(x=X, y=Y, z=Z, h=Ht, w=Wc, kind=kind, seed=rng.integers(0, 1 << 20, len(X))) def paint_trees(cv, trees, cam, G, sun, sunvis_fn, ground_mat=None, band_fn=None, shadow=True, shadow_dark=True): """draw every tree back to front. Sprites by scale class; cast shadows first (on the ground pixels already painted), then crowns with terrain occlusion.""" n = len(trees["x"]) if n == 0: return P = np.c_[trees["x"], trees["y"], trees["z"]] sx, sy, depth = cam.project(P) fp = cam.footprint(depth) wpx = trees["w"] / fp hpx = trees["h"] * np.cos(np.radians(cam.pitch)) / fp vis_sun = sunvis_fn(trees["x"], trees["y"]) hor = np.hypot(sun[0], sun[1]) + 1e-9 # ---- cast shadows on the ground (drawn into the ground layer before any crown) if shadow and sun[2] > 0.02: L = np.minimum(trees["h"] * hor / sun[2], trees["h"] * 6) # shadow length (m), clamp at grazing sun for i in np.argsort(-depth): if vis_sun[i] < 0.5 or wpx[i] < 1.2: continue # shadow = ellipse from the base toward -sun, length L, width = crown width cxw = trees["x"][i] - sun[0] / hor * L[i] * 0.55 cyw = trees["y"][i] - sun[1] / hor * L[i] * 0.55 ex, ey, _ = cam.project(np.array([cxw, cyw, trees["z"][i]])) # axis of the shadow in screen space tip = cam.project(np.array([trees["x"][i] - sun[0] / hor * L[i], trees["y"][i] - sun[1] / hor * L[i], trees["z"][i]])) ax_ = np.array([tip[0] - sx[i], tip[1] - sy[i]]) la = np.linalg.norm(ax_) + 1e-6 ux, uy = ax_ / la half_len = max(la * 0.5, wpx[i] * 0.45); half_w = wpx[i] * 0.45 rr = int(np.ceil(half_len + 2)) xa, xb = int(ex - rr), int(ex + rr + 1); ya, yb = int(ey - rr), int(ey + rr + 1) xa, ya = max(xa, 0), max(ya, 0); xb, yb = min(xb, cv.w), min(yb, cv.h) if xa >= xb or ya >= yb: continue YY, XX = np.mgrid[ya:yb, xa:xb] du = (XX - ex) * ux + (YY - ey) * uy; dv = -(XX - ex) * uy + (YY - ey) * ux m = (du / half_len) ** 2 + (dv / (half_w + 0.3)) ** 2 <= 1.0 m &= np.abs(G["t"][ya:yb, xa:xb] - depth[i]) < trees["h"][i] * 2 + 3 * fp[i] m &= cv.tag[ya:yb, xa:xb] != 1 # not on canopy already painted sub = cv.step[ya:yb, xa:xb] ns = cv.nsteps_of(cv.mat[ya:yb, xa:xb]) if hasattr(cv, "nsteps_of") else None if shadow_dark: cv.step[ya:yb, xa:xb] = np.where(m, np.minimum(sub, 1), sub) cv.tag[ya:yb, xa:xb] = np.where(m, 3, cv.tag[ya:yb, xa:xb]) # ---- crowns, far to near for i in np.argsort(-depth): w = wpx[i]; h = hpx[i] if w < 0.6 and h < 1.5: continue lit_ok = vis_sun[i] > 0.5 kind = "conifer" if trees["kind"][i] == 0 else "broadleaf" if w >= 5: wi = int(round(w)); hi = int(round(h if kind == "conifer" else max(h * 0.55, w * 0.8))) spr = conifer_sprite(wi, hi, sun, cam, trees["seed"][i], lit_ok) if kind == "conifer" \ else broadleaf_sprite(wi, hi, sun, cam, trees["seed"][i], lit_ok) else: wi = int(np.clip(round(w), 1, 4)); hi = int(max(2, round(h if kind == "conifer" else max(h * 0.6, w)))) spr = spire_mark(wi, hi, sun, cam, kind, lit_ok) band = band_fn(depth[i]) if band_fn else None cv.blit(spr, sx[i], sy[i] + 0.5, depth[i] - 0.01 * (i % 7), ground_t=G["t"], tol=trees["w"][i] * 1.5 + fp[i] * 2, band=band, tag=1) def forest_texture(cv, mask, G, cam, sun, sunvis, ndl, kind="conifer", tree_h=18.0, crown_w=5.0, lit_frac=0.45, seed=0, band=None): """far forest as a ground material. Each pixel of `mask` is painted as canopy with vertical dashes: a lit dab (step 3/4) on top of a dark stem (step 1/0), the dash length the projected tree height, stippled with density = lit_frac scaled by the slope's light. Where the sun can't reach, the whole mass drops to the shadow family with sparse reflected-light dabs.""" mat = CON if kind == "conifer" else BRD h, w = mask.shape fp = G["mpp"] dash = np.clip(np.round(tree_h * np.cos(np.radians(cam.pitch)) / np.maximum(fp, 1e-3)), 1, 4).astype(int) thr = threshold_map(h, w, "blue", seed) thr2 = threshold_map(h, w, "blue", seed + 7) light = np.clip(ndl, 0, 1) * sunvis dens = np.clip(lit_frac * (0.35 + 1.1 * light), 0.05, 0.85) step = np.where(light > 0.08, 1, 0).astype(np.int32) # the gap/body tone step[(light > 0.08) & (thr2 < 0.25)] = 2 heads = mask & (thr < dens) # a head is lit (3/4) in sun, reflected (2) in shade; the pixels below the head are its stem lit = light > 0.08 headstep = np.where(lit, np.where(light > 0.55, 4, 3), 2) out = step.copy() yy, xx = np.nonzero(heads) for y, x in zip(yy, xx): out[y, x] = headstep[y, x] L = dash[y, x] for k in range(1, L): if y + k < h and mask[y + k, x] and not heads[y + k, x]: out[y + k, x] = 0 if k == L - 1 else min(out[y + k, x], 1) cv.fill(mask, mat, out, band=band, tag=1) </pre></details><details class="step"><summary><code>Bash: Clean leftover lines in canopy module</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_canopy.py'; s=open(p).read() s=s.replace(""" ndl = n[0] * abs(sun[0] if abs(sun[0]) > 1e-3 else 0) * side * np.sign(u) if False else None ""","") s=s.replace(""" sub = cv.step[ya:yb, xa:xb] ns = cv.nsteps_of(cv.mat[ya:yb, xa:xb]) if hasattr(cv, "nsteps_of") else None """,""" sub = cv.step[ya:yb, xa:xb] """) open(p,'w').write(s) EOF echo ok # output: ok</pre></details><details class="step"><summary><code>Write: aerial/lib/tech_ground.py</code></summary><pre>"""tech_ground.py -- open ground from above: the slope-tone ramp and ground textures. Slope-tone ramp (the technique for slopes whose silhouettes are gone). From 30 deg down and farther, a slope has no outline; it reads by *tone planes*: every facet facing the sun is one flat light value, every facet turned away is one flat shadow value, and the turn between them is a narrow dithered seam (Ferrari V14: mountain flanks as flat planes with checker seams; the photos: sunlit facets vs shaded gully walls of a bare slope differ by 20-35 L* while each facet is flat, NOTES.md 'slopes'). So: * the step coordinate comes from n.l (lit family) or sky-view + bounce (shadow family), * it is *posterised into planes* (flat_bands with a narrow seam) rather than smoothly dithered, * the lit/shadow families never mix: the terminator is a hard edge, * fall-line flecks: a sparse 1-px dark/light fleck elongated along the fall line gives the slope its direction (grass stipple on meadows is isotropic instead). """ import numpy as np from pal import MATERIALS, MAT_ID from dither import threshold_map, quantize, flat_bands def form_coordinate(ndl, sunvis, skyview, nsteps, ao=None): """continuous step coordinate in [0, nsteps-1] with a jump at the terminator. Shadow family: [0, ns-1] from skyview (and ao). Lit family: [ns, n-1] from n.l.""" ns = nsteps // 2; nl = nsteps - ns lit = (ndl > 0.06) & (sunvis > 0.5) sh = np.clip(skyview, 0, 1) if ao is not None: sh = sh * np.clip(ao, 0, 1) xs = sh * (ns - 1 + 0.49) # 0 .. ns-1 (+ half, so the top shadow step shows) xl = ns + np.clip((ndl - 0.06) / 0.9, 0, 1) * (nl - 1 + 0.49) return np.where(lit, xl, xs), lit, ns def slope_tone(ndl, sunvis, skyview, mat, thr, seam=0.22, ao=None, planes=True): """step for every pixel of one material: posterised planes with narrow dither seams, clamped into its light family (no dither across the terminator).""" n = MATERIALS[mat]["steps"] x, lit, ns = form_coordinate(ndl, sunvis, skyview, n, ao) s = flat_bands(x, thr, seam) if planes else quantize(x, thr) s = np.where(lit, np.clip(s, ns, n - 1), np.clip(s, 0, ns - 1)) return s def fall_line_flecks(step, mask, G, thr, density=0.06, lit_ok=None, seed=0): """sparse flecks along the fall line: a dark pixel with a lighter pixel uphill of it. The fall line on screen is the projected downslope direction.""" h, w = step.shape n = G["n"] # downslope direction in world xy is -grad = (n_x, n_y); on an iso screen with yaw 0 world +y # is screen up, so screen down-slope is (n_x, -n_y) (sign for rows) dx = n[..., 0]; dy = -n[..., 1] ln = np.hypot(dx, dy) + 1e-6 dx /= ln; dy /= ln pick = mask & (thr < density) yy, xx = np.nonzero(pick) out = step.copy() for y, x in zip(yy, xx): ox = int(round(dx[y, x])); oy = int(round(dy[y, x])) y2, x2 = y - oy, x - ox out[y, x] = max(0, step[y, x] - 1) if 0 <= y2 < h and 0 <= x2 < w and mask[y2, x2]: out[y2, x2] = step[y2, x2] + (1 if (lit_ok is None or lit_ok[y2, x2]) else 0) return out def stipple(step, mask, thr, up=0.18, down=0.14, lo=None, hi=None): """isotropic grain: a share of pixels one step up, a share one step down (within the family).""" out = step.copy() out = np.where(mask & (thr < up), step + 1, out) out = np.where(mask & (thr > 1 - down), step - 1, out) if lo is not None: out = np.maximum(out, lo) if hi is not None: out = np.minimum(out, hi) return out def family_bounds(mat, lit): n = MATERIALS[mat]["steps"]; ns = n // 2 lo = np.where(lit, ns, 0); hi = np.where(lit, n - 1, ns - 1) return lo, hi </pre></details><details class="step"><summary><code>Write: aerial/lib/painter.py</code></summary><pre>"""painter.py -- the thin scaffold: G-buffer -> index canvas (via the technique portfolio) -> palette. A Scene holds what the simulator owns (terrain, cover fields, objects). paint() only decides how it looks: it calls one technique per material/object and never invents geography. sc = Scene(T, cover={...}, trees=..., huts=[...], fires=[...], water=...) img, info = paint(sc, cam, LIGHTS['afternoon']) """ import numpy as np from scipy import ndimage as ndi from pal import Palette, MAT_ID, MATERIALS from canvas import Canvas from dither import threshold_map import tech_ground as TG import tech_canopy as TC GROUND_ORDER = ["meadow", "drygrass", "soil", "rock", "scree", "sand", "snow"] class Scene: def __init__(self, T, cover, trees=None, water=None, huts=None, fires=None, extras=None, seed=0): self.T = T self.cover = cover # name -> world grid [0,1] (ground materials + 'forest') self.trees = trees self.water = water # dict(mask=grid bool or level=float, kind='river'|'lake'|'sea') self.huts = huts or [] self.fires = fires or [] self.extras = extras or {} self.seed = seed self._cache = {} def field(self, name, fn): if name not in self._cache: self._cache[name] = fn() return self._cache[name] def band_of(t, bands): """depth band index from ray distance (m) and band edges.""" b = np.zeros(np.shape(t), np.int32) for i, e in enumerate(bands): b = np.where(t > e, i + 1, b) return b def ground_materials(sc, G, thr): """pick one ground material per pixel from the cover weights; boundaries get a 1-2 px fringe (texture ends at a mass boundary, it isn't outlined).""" names = [n for n in GROUND_ORDER if n in sc.cover] Wt = np.stack([sc.T.sample(sc.cover[n], G["x"], G["y"]) for n in names], 0) Wt = Wt + (thr[None] - 0.5) * 0.18 # fringe idx = np.argmax(Wt, 0) return names, idx, Wt def paint(sc, cam, light, bands=None, forest_mode="auto", tex_threshold=2.0, return_canvas=False): T = sc.T G = T.gbuffer(cam) h, w = G["hit"].shape cv = Canvas(w, h) sun = light.vec seed = sc.seed thr_b = threshold_map(h, w, "blue", seed) thr_4 = threshold_map(h, w, "bayer4") shadow = sc.field(("shadow", light.name), lambda: T.sun_shadow(sun, soft=T.cell * 0.5)) sunvis = T.sample(shadow, G["x"], G["y"]) ndl = np.clip((G["n"] * sun).sum(-1), -1, 1) conc = sc.field("conc", lambda: T.concavity(max(T.cell * 3, 30))) cc = T.sample(conc, G["x"], G["y"]) skyview = np.clip(0.55 + 0.45 * G["n"][..., 2] + cc / 60.0, 0.05, 1.0) if bands is None: bands = [np.inf] band = band_of(G["t"], bands) G.update(sunvis=sunvis, ndl=ndl, skyview=skyview, band=band) # ---- ground names, idx, Wt = ground_materials(sc, G, thr_b) for k, name in enumerate(names): m = G["hit"] & (idx == k) if not m.any(): continue hard = name in ("rock", "snow") s = TG.slope_tone(ndl, sunvis, skyview, name, thr_4 if hard else thr_b, seam=0.22 if hard else 0.35) lit = (ndl > 0.06) & (sunvis > 0.5) lo, hi = TG.family_bounds(name, lit) if name in ("meadow", "drygrass", "soil", "sand"): s = TG.stipple(s, m, threshold_map(h, w, "blue", seed + 3), up=0.16, down=0.16, lo=lo, hi=hi) if name in ("rock", "scree"): s = TG.fall_line_flecks(s, m, G, threshold_map(h, w, "blue", seed + 5), density=0.08, lit_ok=lit) s = np.clip(s, lo, hi) cv.fill(m, name, s, band=band) # ---- forest: texture where trees are sub-pixel, instances where they are big enough if "forest" in sc.cover and sc.trees is not None: fp = G["mpp"] crown = np.median(sc.trees["w"]) if len(sc.trees["w"]) else 5.0 fdens = T.sample(sc.cover["forest"], G["x"], G["y"]) tex = G["hit"] & (fdens > 0.5 + (thr_b - 0.5) * 0.25) & (crown / fp < tex_threshold) if tex.any(): TC.forest_texture(cv, tex, G, cam, sun, sunvis, ndl, kind="conifer", tree_h=float(np.median(sc.trees["h"])), crown_w=crown, seed=seed, band=band) big = sc.trees P = np.c_[big["x"], big["y"], big["z"]] _, _, dep = cam.project(P) keep = big["w"] / cam.footprint(dep) >= tex_threshold sub = {k: v[keep] for k, v in big.items()} TC.paint_trees(cv, sub, cam, G, sun, lambda x, y: T.sample(shadow, x, y), band_fn=(lambda t: int(band_of(t, bands))) if len(bands) > 1 else None) pal = Palette(light) img, ncol = pal.render(cv.mat, cv.step, cv.band) info = dict(colours=ncol, G=G) if return_canvas: info["canvas"] = cv return img, info </pre></details><details class="step"><summary><code>Bash: First canopy scale test render</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_canopy.py'; s=open(p).read() s=s.replace(""" P = np.c_[trees["x"], trees["y"], trees["z"]] sx, sy, depth = cam.project(P)""",""" P = np.c_[trees["x"], trees["y"], trees["z"]] sx, sy, depth = cam.project(P) onscr = (sx > -40) & (sx < cv.w + 40) & (sy > -10) & (sy < cv.h + 120) & (depth > 0) if not onscr.all(): trees = {k: v[onscr] for k, v in trees.items()} sx, sy, depth = sx[onscr], sy[onscr], depth[onscr] n = len(sx) if n == 0: return""") open(p,'w').write(s) EOF cd .. && cat > scratch/t_canopy.py <<'EOF' import sys, time; sys.path.insert(0,'lib') import numpy as np from PIL import Image from terrain import Terrain from camera import Iso import landform as LF, tech_canopy as TC from painter import Scene, paint from pal import LIGHTS from look import * n=800; cell=2.0 Y,X=np.mgrid[0:n,0:n]*cell H=0.25*Y+60*LF.eroded_fbm(X,Y,500,octaves=6,seed=2)+8*LF.fbm(X,Y,60,seed=4) T=Terrain(H,cell) clear=np.hypot(X-800,Y-800)<90+40*LF.fbm(X,Y,80,seed=9) stand=np.clip(0.75+0.6*LF.fbm(X,Y,120,seed=3),0,1) forest=np.where(clear,0.0,1.0) cover=dict(meadow=np.where(clear,1.0,0.3), forest=forest) rng=np.random.default_rng(1) trees=TC.scatter_trees(T, forest*stand, 5.0, rng, hmean=20) print('trees',len(trees['x'])) sc=Scene(T,cover,trees=trees) rows=[] for mpp in [0.3,0.7,1.6,4.0]: cam=Iso(target=(800,800,T.height(800,800)),mpp=mpp,elev=30,yaw=0,w=320,h=180) t0=time.time(); img,info=paint(sc,cam,LIGHTS['afternoon']); print(mpp,time.time()-t0,info['colours']) rows.append(up(Image.fromarray(img),2)) vstack([hstack(rows[:2]),hstack(rows[2:])]).save('scratch/t_canopy.png') EOF nice -n 10 python3 scratch/t_canopy.py # output: trees 76296 0.3 21.88295602798462 4 0.7 0.9543020725250244 10 1.6 2.157160997390747 10 4.0 1.88372802734375 9</pre></details><div class="step"><code>Read: aerial/scratch/t_canopy.png</code></div></div>  *40. aerial/scratch/t_canopy.png* <div class="steps"><details class="step"><summary><code>Bash: Compare measured colours to current ramps</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import json;d=json.load(open('measure/photo_stats.json')) for k,v in d.items(): print(f\"{k:30s}\", [round(x) for x in v['rgb_med']], round(v['L_med'],1), round(v['chroma_med'],1)) "; python3 -c " import sys; sys.path.insert(0,'lib') from pal import * for n in ['afternoon','evening']: L=LIGHTS[n] for m in ['conifer','meadow','rock','snow']: r=material_ramp(m,L); print(n,m,[tuple(int(v) for v in c) for c in r], [round(x) for x in lab(r)[:,0]]) " # output: conifer_near_dawn [11, 26, 11] 7.6 10.1 conifer_mid_dawn [26, 49, 33] 18.3 12.9 conifer_dense_overcast_near [88, 105, 76] 42.3 18.4 conifer_dense_overcast_far [113, 134, 119] 54.0 12.5 broadleaf_sun_near [136, 128, 74] 53.2 29.7 broadleaf_sun_mid [99, 97, 77] 40.9 11.6 broadleaf_sun_far [120, 121, 108] 50.3 8.7 sparse_conifer_on_meadow [104, 96, 81] 41.0 10.8 far_slope_dotted_trees [155, 147, 149] 61.8 4.2 meadow_sun [172, 159, 131] 65.9 15.2 meadow_green_dawn [43, 79, 34] 30.1 30.4 bare_slope_sun [158, 152, 154] 63.3 4.0 river_near [55, 55, 49] 22.7 2.6 river_mid [77, 108, 159] 45.3 32.1 river_far [75, 83, 91] 35.2 8.8 dry_field_far [187, 160, 140] 67.9 14.6 canopy_far_band [121, 127, 123] 52.6 4.5 canopy_near_band [20, 22, 19] 6.9 2.9 sky_horizon [177, 202, 232] 80.4 17.7 sky_top [120, 180, 236] 71.3 34.1 afternoon conifer [(2, 21, 8), (15, 45, 20), (24, 63, 31), (52, 97, 38), (60, 107, 40), (67, 117, 43)] [5, 16, 23, 37, 41, 45] afternoon meadow [(27, 41, 5), (83, 108, 26), (139, 158, 16), (156, 173, 13), (170, 187, 10)] [15, 42, 62, 68, 72] afternoon rock [(32, 37, 47), (71, 72, 80), (97, 99, 109), (160, 146, 134), (179, 160, 143), (194, 173, 152)] [15, 31, 42, 62, 67, 72] afternoon snow [(54, 71, 100), (113, 129, 160), (151, 170, 207), (238, 236, 245), (254, 255, 254), (254, 255, 254)] [30, 54, 69, 94, 100, 100] evening conifer [(5, 16, 9), (20, 39, 22), (31, 56, 33), (65, 83, 29), (74, 93, 28), (82, 101, 28)] [4, 14, 21, 33, 37, 40] evening meadow [(32, 34, 8), (91, 96, 31), (156, 136, 0), (174, 150, 0), (189, 162, 0)] [13, 39, 57, 63, 67] evening rock [(36, 30, 48), (75, 63, 81), (103, 87, 110), (176, 124, 112), (196, 137, 116), (212, 149, 119)] [13, 29, 40, 57, 63, 67] evening snow [(61, 60, 101), (121, 115, 160), (160, 153, 208), (255, 208, 214), (255, 228, 222), (255, 246, 231)] [27, 51, 66, 88, 93, 97]</pre></details><details class="step"><summary><code>Write: aerial/lib/study.py</code></summary><pre>"""study.py -- the technique study layout: photo | my pixels | nearest master analogue, all at 8x (the photo is box-downsampled to the same pixel scale first, so it is judged at the pixel size it would have in the frame), with a caption strip.""" import os from PIL import Image, ImageDraw, ImageFont import numpy as np BG = (22, 22, 26) FG = (230, 230, 220) def _font(sz=14): for p in ["/System/Library/Fonts/Menlo.ttc", "/System/Library/Fonts/Monaco.ttf", "/Library/Fonts/Arial.ttf"]: if os.path.exists(p): try: return ImageFont.truetype(p, sz) except Exception: pass return ImageFont.load_default() def px_photo(path, box, out_w): """crop a photo and box-downsample so it is out_w pixels wide (what it looks like at that scale).""" im = Image.open(path).convert("RGB").crop(box) w, h = im.size return im.resize((out_w, max(1, round(h * out_w / w))), Image.BOX) def up(im, k): return im.resize((im.size[0] * k, im.size[1] * k), Image.NEAREST) def panel(title, ims, captions, k=8, note=None, gap=10): """ims: list of small PIL images (native px); each shown at k x with a caption under it.""" f = _font(15); fs = _font(12) big = [up(i, k) if i.size[0] * k <= 1400 else i for i in ims] H = max(b.size[1] for b in big) W = sum(b.size[0] for b in big) + gap * (len(big) + 1) top = 30; cap = 22; bot = 0 if not note else 18 * (note.count("\n") + 1) + 8 out = Image.new("RGB", (W, top + H + cap + bot), BG) d = ImageDraw.Draw(out) d.text((gap, 7), title, fill=FG, font=f) x = gap for b, c in zip(big, captions): out.paste(b, (x, top)) d.text((x, top + H + 4), c, fill=(190, 190, 180), font=fs) x += b.size[0] + gap if note: d.multiline_text((gap, top + H + cap + 2), note, fill=(170, 170, 160), font=fs, spacing=4) return out def stack(panels, gap=8): W = max(p.size[0] for p in panels); H = sum(p.size[1] for p in panels) + gap * (len(panels) - 1) out = Image.new("RGB", (W, H), BG); y = 0 for p in panels: out.paste(p, (0, y)); y += p.size[1] + gap return out def label(im, text, k=1): im = im.copy(); d = ImageDraw.Draw(im); f = _font(12) tw = d.textlength(text, font=f) d.rectangle([0, 0, tw + 6, 16], fill=(0, 0, 0)); d.text((3, 1), text, fill=(255, 255, 200), font=f) return im </pre></details><details class="step"><summary><code>Bash: Per-material chroma and recalibrated albedos</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='pal.py'; s=open(p).read() s=s.replace(''' "conifer": dict(alb=(62, 88, 52), steps=6), "broadleaf": dict(alb=(88, 120, 50), steps=6), "meadow": dict(alb=(140, 150, 72), steps=5), "drygrass": dict(alb=(170, 152, 100), steps=5),''',''' "conifer": dict(alb=(58, 86, 54), steps=6, chroma=1.3), "broadleaf": dict(alb=(96, 124, 56), steps=6, chroma=1.25), "meadow": dict(alb=(118, 140, 72), steps=5, chroma=1.2), "drygrass": dict(alb=(172, 158, 118), steps=5, chroma=1.4),''') s=s.replace(''' return push_chroma(rgb, light.chroma)''',''' return push_chroma(rgb, m.get("chroma", light.chroma))''') open(p,'w').write(s) EOF echo ok # output: ok</pre></details><details class="step"><summary><code>Bash: Zoomed canopy render at three scales</code></summary><pre>cd ~/work/pixelart-studies/aerial && cat > scratch/t_canopy2.py <<'EOF' import sys, time; sys.path.insert(0,'lib') import numpy as np from PIL import Image from terrain import Terrain from camera import Iso import landform as LF, tech_canopy as TC from painter import Scene, paint from pal import LIGHTS from look import * import pickle n=500; cell=2.0 Y,X=np.mgrid[0:n,0:n]*cell H=0.25*Y+40*LF.eroded_fbm(X,Y,400,octaves=6,seed=2)+6*LF.fbm(X,Y,60,seed=4) T=Terrain(H,cell) clear=np.hypot(X-500,Y-470)<45+25*LF.fbm(X,Y,50,seed=9) stand=np.clip(0.8+0.7*LF.fbm(X,Y,70,seed=3),0,1) forest=np.where(clear,0.0,1.0) cover=dict(meadow=np.where(clear,1.0,0.3), forest=forest) rng=np.random.default_rng(1) trees=TC.scatter_trees(T, forest*stand, 5.0, rng, hmean=20) sc=Scene(T,cover,trees=trees) out=[] for mpp in [0.5,1.2,2.5]: cam=Iso(target=(500,520,T.height(500,520)),mpp=mpp,elev=30,yaw=0,w=160,h=100) img,info=paint(sc,cam,LIGHTS['afternoon']); print(mpp,info['colours']) out.append(up(Image.fromarray(img),4)) vstack(out).save('scratch/t_canopy2.png') EOF nice -n 10 python3 scratch/t_canopy2.py # output: 0.5 10 1.2 10 2.5 8</pre></details><div class="step"><code>Read: aerial/scratch/t_canopy2.png</code></div></div>  *41. aerial/scratch/t_canopy2.png* <div class="steps"><details class="step"><summary><code>Bash: Zoom Ferrari distant forest masses</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * F=lambda n: load(f'refs/ferrari_lw/{n}.png') hstack([up(crop(F('V16'),(300,170,380,230)),8), up(crop(F('V14'),(420,380,500,440)),8)]).save('scratch/f_forest_far.png') " # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/f_forest_far.png</code></div></div>  *42. aerial/scratch/f_forest_far.png* <div class="steps"><details class="step"><summary><code>Bash: Spur-stroke conifer sprite, hue walk, rerun</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_canopy.py'; s=open(p).read() start=s.index('def conifer_sprite'); end=s.index('def broadleaf_sprite') new='''def conifer_sprite(w, h, sun, cam, seed=0, lit_ok=True, ramp_top=5): """a conifer crown w px wide, h px tall, built from Ferrari's strokes: a 1-px spire, then tiers of horizontal spurs that droop at their outer ends and lengthen downward, lit on the sun side (ochre dab on the tip), dark gaps between tiers, the shade side in the reflected-light step. Conifer ramp: 0 gap | 1 shadow | 2 reflected || 3 halftone | 4 lit | 5 tip highlight.""" key = ("con2", w, h, round(sun[0], 2), round(sun[1], 2), round(sun[2], 2), seed % 6, lit_ok) if key in _cache: return _cache[key] rng = np.random.default_rng(seed % 6 + 100 * w + 7 * h) W = w + 2; Hh = h + 2 a = np.zeros((Hh, W), bool); st = np.zeros((Hh, W), np.int32) cx = int(round((W - 1) / 2.0)) sxs, _ = _screen_sun(sun, cam) side = 1 if sxs >= 0 else -1 hor = np.hypot(sun[0], sun[1]); elev = sun[2] pitch = 2 if h < 14 else 3 # rows per tier (spur row + gap rows) top = max(1, int(round(0.12 * h))) for yy in range(1, 1 + top): # spire a[yy, cx] = True; st[yy, cx] = 4 if lit_ok else 2 for yy in range(1 + top, 1 + h): v = (yy - 1) / max(h - 1, 1) r = 0.5 * (w - 1) * min(1.0, 0.18 + 0.95 * v) # cone half-width spur = ((yy - 1 - top) % pitch) == 0 rr = r if spur else r * 0.55 # gap rows are narrower: the tier notch rr = rr * (0.9 + 0.2 * rng.random()) xl = int(round(cx - rr)); xr = int(round(cx + rr)) for xx in range(max(0, xl), min(W, xr + 1)): a[yy, xx] = True u = (xx - cx) / max(rr, 0.5) # -1 .. 1 across the crown sunside = u * side if spur: if lit_ok and (sunside > -0.25 or (elev > 0.55 and sunside > -0.6)): s = 3 + (sunside > 0.2) + (sunside > 0.75) if v > 0.8 and sunside < 0.5: s = min(s, 3) else: s = 2 if sunside > -0.8 else 1 else: s = 0 if abs(u) < 0.6 else 1 if lit_ok and sunside > 0.7 and v < 0.5: s = 2 st[yy, xx] = s # droop: the spur's outer ends hang one row lower if spur and yy + 1 < Hh and r >= 2: for xx in (xl, xr): if 0 <= xx < W: a[yy + 1, xx] = True st[yy + 1, xx] = st[yy, xx] a[yy, xx] = rng.random() < 0.5 and a[yy, xx] # trunk shadow: the axis below the spire is darker (the core of the tree) for yy in range(1 + top, 1 + h): if a[yy, cx] and st[yy, cx] < 4: st[yy, cx] = max(0, st[yy, cx] - 1) spr = dict(a=a, mat=np.full(a.shape, CON), step=st, ax=(W - 1) / 2.0, ay=Hh - 1.5) _cache[key] = spr return spr ''' s=s[:start]+new+s[end:] start=s.index('def spire_mark'); end=s.index('# --------------------------------------------------------------------- stands') new2='''def spire_mark(w, h, sun, cam, kind="conifer", lit_ok=True): """2-4 px wide trees. Conifer: a lit tip and a sun-side lit column over a dark body, with the tier notches every 2 rows (the smallest honest version of the spur stroke). Broadleaf: a rounded dab, lit on the sun side of its top, dark below.""" key = ("spire2", kind, w, h, round(sun[0], 2), lit_ok) if key in _cache: return _cache[key] mat = CON if kind == "conifer" else BRD W = max(1, w); Hh = max(2, h) a = np.zeros((Hh, W), bool); st = np.zeros((Hh, W), np.int32) sxs, _ = _screen_sun(sun, cam) side = 1 if sxs >= 0 else -1 c = (W - 1) / 2 for yy in range(Hh): v = yy / max(Hh - 1, 1) if kind == "conifer": half = c * min(1.0, 0.1 + v * 1.4) notch = (yy % 2 == 1) and yy > 1 and W >= 3 else: half = c * (0.6 + 0.4 * np.sin(np.pi * min(1, v * 1.15))); notch = False for xx in range(W): d = xx - c if abs(d) <= half + 0.01 and not (notch and abs(d) > half - 0.6): a[yy, xx] = True sunside = d * side >= -0.01 if W > 1 else True if lit_ok and yy == 0: st[yy, xx] = 4 elif lit_ok and sunside and v < 0.75: st[yy, xx] = 4 if (v < 0.35 and d * side > 0) else 3 elif lit_ok and v < 0.3: st[yy, xx] = 3 else: st[yy, xx] = 1 if v < 0.9 else 0 if not lit_ok: st[yy, xx] = 2 if (yy == 0 or (sunside and v < 0.4)) else (1 if v < 0.9 else 0) spr = dict(a=a, mat=np.full(a.shape, mat), step=st, ax=c, ay=Hh - 1) _cache[key] = spr return spr ''' s=s[:start]+new2+s[end:] open(p,'w').write(s) p='pal.py'; s=open(p).read() s=s.replace(''' for k in range(nl): # halftone .. full light ndl = 0.35 + 0.65 * (k + 1) / nl E.append(light.sky + light.sun * ndl)''',''' for k in range(nl): # halftone .. full light .. highlight ndl = 0.28 + 0.72 * k / max(nl - 1, 1) if k == nl - 1 and nl >= 3: ndl *= 1.3 # the top step is a highlight (tips, rims), brighter than n.l allows E.append(light.sky + light.sun * ndl)''') s=s.replace(''' rgb = lin_to_srgb(col * 1.35) return push_chroma(rgb, m.get("chroma", light.chroma))''',''' rgb = lin_to_srgb(col * 1.35) rgb = push_chroma(rgb, m.get("chroma", light.chroma)) if hue_walk and m.get("walk", 0): rgb = walk_hue(rgb, m["walk"], n // 2) return rgb def walk_hue(rgb, deg, ns): """Ferrari's hue walk along a ramp: shadow steps rotate cooler, lit steps warmer (toward ochre).""" L = lab(rgb) n = len(rgb) for k in range(n): t = (k - (ns - 0.5)) / max(n / 2, 1) # <0 shadow, >0 light a, b = L[k, 1], L[k, 2] ang = np.radians(-deg * t) # positive t: rotate toward yellow/orange (clockwise from green) L[k, 1] = a * np.cos(ang) - b * np.sin(ang) L[k, 2] = a * np.sin(ang) + b * np.cos(ang) return from_lab(L)''') s=s.replace('"conifer": dict(alb=(58, 86, 54), steps=6, chroma=1.3),','"conifer": dict(alb=(58, 86, 54), steps=6, chroma=1.35, walk=40),') s=s.replace('"broadleaf": dict(alb=(96, 124, 56), steps=6, chroma=1.25),','"broadleaf": dict(alb=(96, 124, 56), steps=6, chroma=1.3, walk=30),') s=s.replace('"meadow": dict(alb=(118, 140, 72), steps=5, chroma=1.2),','"meadow": dict(alb=(118, 140, 72), steps=5, chroma=1.2, walk=25),') open(p,'w').write(s) EOF cd .. && python3 -c " import sys; sys.path.insert(0,'lib') from pal import * for m in ['conifer','meadow']: r=material_ramp(m,LIGHTS['afternoon']); print(m,[tuple(int(v) for v in c) for c in r], [round(x) for x in lab(r)[:,0]]) " && nice -n 10 python3 scratch/t_canopy2.py # output: conifer [(0, 20, 18), (4, 43, 33), (22, 61, 41), (46, 75, 40), (77, 93, 39), (119, 115, 43)] [5, 15, 23, 29, 37, 48] meadow [(15, 38, 21), (68, 100, 53), (102, 120, 54), (148, 146, 59), (206, 177, 72)] [13, 39, 48, 59, 73] 0.5 10 1.2 10 2.5 8</pre></details><div class="step"><code>Read: aerial/scratch/t_canopy2.png</code></div></div>  *43. aerial/scratch/t_canopy2.png* <div class="steps"><details class="step"><summary><code>Bash: Downsample forest photos to pixel scales</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import sys; sys.path.insert(0,'lib'); from look import *; from study import px_photo p='refs/aerial_view_forested_mountain_slope/commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg' q='refs/aerial_conifer_forest_hillside/openverse_Between_Dangerous_River_and_Alsek_River_c0688f25.jpg' r='refs/drone_view_pine_forest_shadows/commons_9_jpg_9fd30cc1.jpg' a=[up(px_photo(p,(0,560,480,860),w),int(640/w)) for w in (160,80,40)] b=[up(px_photo(q,(0,400,640,700),w),int(640/w)) for w in (160,80,40)] import os print(os.path.exists(r)) vstack([hstack(a),hstack(b)]).save('scratch/photo_forest_scales.png') " # output: True</pre></details><div class="step"><code>Read: aerial/scratch/photo_forest_scales.png</code></div></div>  *44. aerial/scratch/photo_forest_scales.png* <div class="steps"><details class="step"><summary><code>Bash: Lit-cap conifer sprite with stand occlusion</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_canopy.py'; s=open(p).read() start=s.index('def conifer_sprite'); end=s.index('def broadleaf_sprite') new='''def conifer_sprite(w, h, sun, cam, seed=0, lit_ok=True, occl=0.8, tone=0): """a conifer crown w px wide, h px tall. Two layers: * the lit-cap gradient (the photos): the top of the crown is lit, value falls toward the base because neighbours shade it (occl = stand density 0..1: a lone tree stays lit to the ground); the sun side is one step above the shade side; * Ferrari's strokes on top: 1-px spire, tiers of horizontal spurs that droop at their outer ends, a tip highlight on the sun-side spur ends, the tier notches one step darker. Conifer ramp: 0 gap | 1 shadow | 2 reflected || 3 halftone | 4 lit | 5 tip highlight. tone: -1/0/+1 per-tree value variation (species, age), applied inside the families.""" key = ("con3", w, h, round(sun[0], 2), round(sun[1], 2), round(sun[2], 2), seed % 6, lit_ok, round(occl, 1), tone) if key in _cache: return _cache[key] rng = np.random.default_rng(seed % 6 + 100 * w + 7 * h) W = w + 2; Hh = h + 2 a = np.zeros((Hh, W), bool); st = np.zeros((Hh, W), np.int32) cx = int(round((W - 1) / 2.0)) sxs, _ = _screen_sun(sun, cam) side = 1 if sxs >= 0 else -1 elev = sun[2] pitch = 2 if h < 16 else 3 top = max(1, int(round(0.1 * h))) phase = rng.integers(0, pitch) for yy in range(1, 1 + top): # spire a[yy, cx] = True; st[yy, cx] = 4 if lit_ok else 2 for yy in range(1 + top, 1 + h): v = (yy - 1) / max(h - 1, 1) r = 0.5 * (w - 1) * min(1.0, 0.2 + 1.0 * v) spur = ((yy - 1 - top + phase) % pitch) == 0 rr = r if spur else r * 0.7 rr = rr * (0.88 + 0.24 * rng.random()) xl = int(round(cx - rr)); xr = int(round(cx + rr)) # the lit-cap gradient: light available at this height avail = 1.0 - occl * np.clip((v - 0.25) / 0.6, 0, 1) for xx in range(max(0, xl), min(W, xr + 1)): a[yy, xx] = True u = (xx - cx) / max(rr, 0.5) sunside = u * side if lit_ok: lvl = avail * (0.62 + 0.38 * sunside + 0.25 * elev) + 0.12 * tone if lvl > 0.95: s = 5 elif lvl > 0.72: s = 4 elif lvl > 0.48: s = 3 elif lvl > 0.3: s = 2 elif lvl > 0.15: s = 1 else: s = 0 else: lvl = avail * (0.6 + 0.3 * sunside) + 0.1 * tone s = 2 if lvl > 0.62 else (1 if lvl > 0.3 else 0) if not spur and s > 0 and abs(u) > 0.2: s = s - 1 if s != 3 else 2 # tier notch: one step down (and across the terminator only 3->2) st[yy, xx] = s # spur tips: highlight on the sun-side end, droop one row if spur and r >= 1.5: tip = xr if side > 0 else xl if lit_ok and 0 <= tip < W and avail > 0.45: st[yy, tip] = 5 if avail > 0.7 else 4 if yy + 1 < 1 + h: for xx in (xl, xr): if 0 <= xx < W: a[yy + 1, xx] = True; st[yy + 1, xx] = st[yy, xx] spr = dict(a=a, mat=np.full(a.shape, CON), step=st, ax=(W - 1) / 2.0, ay=Hh - 1.5) _cache[key] = spr return spr ''' s=s[:start]+new+s[end:] # pass occlusion & tone in paint_trees s=s.replace(''' spr = conifer_sprite(wi, hi, sun, cam, trees["seed"][i], lit_ok) if kind == "conifer" \\''',''' spr = conifer_sprite(wi, hi, sun, cam, trees["seed"][i], lit_ok, occl=occl[i], tone=int(tone[i])) if kind == "conifer" \\''') s=s.replace(''' # ---- crowns, far to near for i in np.argsort(-depth):''',''' # ---- crowns, far to near # stand density around each tree (neighbours within 2 crown widths) -> how much it is shaded below from scipy.spatial import cKDTree kd = cKDTree(np.c_[trees["x"], trees["y"]]) rad = 2.0 * np.median(trees["w"]) cnt = np.array([len(c) for c in kd.query_ball_point(np.c_[trees["x"], trees["y"]], rad)]) - 1 occl = np.clip(cnt / 6.0, 0, 1) * 0.9 tone = np.where(trees["seed"] % 5 == 0, -1, np.where(trees["seed"] % 7 == 0, 1, 0)) for i in np.argsort(-depth):''') open(p,'w').write(s) EOF cd .. && sed -i '' 's/meadow": dict(alb=(118, 140, 72), steps=5, chroma=1.2, walk=25)/meadow": dict(alb=(118, 140, 72), steps=5, chroma=1.2, walk=10)/' lib/pal.py && nice -n 10 python3 scratch/t_canopy2.py # output: 0.5 10 1.2 10 2.5 8</pre></details><div class="step"><code>Read: aerial/scratch/t_canopy2.png</code></div></div>  *45. aerial/scratch/t_canopy2.png* <div class="steps"><details class="step"><summary><code>Bash: Add canopy-surface functions</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cat >> tech_canopy.py <<'EOF' # --------------------------------------------------------------------- canopy surface (far regime) def canopy_height(T, trees, smooth_below=None): """rasterise every crown as a bump (conifer: cone, broadleaf: dome) into a height grid on the terrain's cells, max-composited. Where crowns are smaller than ~2 cells they are rasterised as single-cell cones anyway: the forest surface then carries crown-scale grain.""" C = np.zeros_like(T.H) fi, fj = T.ij(trees["x"], trees["y"]) cell = T.cell for kind in (0, 1): sel = np.nonzero(trees["kind"] == kind)[0] if len(sel) == 0: continue rmax = int(np.ceil(trees["w"][sel].max() / 2 / cell)) + 1 for dj in range(-rmax, rmax + 1): for di in range(-rmax, rmax + 1): jj = np.round(fj[sel]).astype(int) + dj; ii = np.round(fi[sel]).astype(int) + di ok = (jj >= 0) & (jj < T.ny) & (ii >= 0) & (ii < T.nx) d = np.hypot((ii - fi[sel]) * cell, (jj - fj[sel]) * cell) / (trees["w"][sel] / 2) if kind == 0: hgt = trees["h"][sel] * (1 - 0.55 * np.clip(d, 0, 1.2)) # cone top: pointed else: hgt = trees["h"][sel] * (0.75 + 0.25 * np.sqrt(np.clip(1 - d * d, 0, 1))) # dome hgt = np.where(d <= 1.0, hgt, 0.0) ok &= hgt > 0 np.maximum.at(C, (jj[ok], ii[ok]), hgt[ok]) return C def paint_canopy_surface(cv, mask, G, sun, sunvis, ndl, skyview, apex, pit, kind="conifer", band=None, thr=None, seed=0): """the far forest, from the canopy surface's own light: lit family where the crown faces the sun, shadow family in gaps and on the shade side, then the marks: a highlight dab on sunlit crown apices with the stem pixel below it one step down (contrast inside the stroke), and the darkest step in the pits between crowns (dark holes).""" mat = CON if kind == "conifer" else BRD h, w = mask.shape if thr is None: thr = threshold_map(h, w, "blue", seed) lit = (ndl > 0.05) & (sunvis > 0.5) # lit family 3..5 by n.l; shadow family 0..2 by skyview xl = 3 + np.clip((ndl - 0.05) / 0.75, 0, 1) * 1.6 xs = np.clip((skyview - 0.35) / 0.55, 0, 1) * 2.4 x = np.where(lit, xl, xs) s = np.floor(x + (thr - 0.5) * 0.6).astype(np.int32) s = np.where(lit, np.clip(s, 3, 5), np.clip(s, 0, 2)) # marks ap = mask & apex s = np.where(ap & lit, np.minimum(s + 1, 5), s) s = np.where(ap & ~lit, np.minimum(s + 1, 2), s) below = np.zeros_like(ap); below[1:] = ap[:-1] s = np.where(below & mask & ~ap, np.maximum(s - 1, np.where(lit, 3, 0)), s) s = np.where(pit & mask, 0, s) cv.fill(mask, mat, s, band=band, tag=1) EOF echo ok # output: ok</pre></details><details class="step"><summary><code>Bash: Painter regime switch: sprites vs canopy surface</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='painter.py'; s=open(p).read() s=s.replace('''def paint(sc, cam, light, bands=None, forest_mode="auto", tex_threshold=2.0, return_canvas=False): T = sc.T G = T.gbuffer(cam)''','''def paint(sc, cam, light, bands=None, forest_mode="auto", sprite_min=5.0, return_canvas=False): T0 = sc.T # regime: crowns big enough for sprites, or the forest as a canopy surface crown = float(np.median(sc.trees["w"])) if sc.trees is not None and len(sc.trees["w"]) else 5.0 fp0 = float(np.median(cam.footprint(np.array([1000.0])))) if cam.kind == "persp" else cam.mpp if forest_mode == "auto": forest_mode = "sprites" if (cam.kind == "iso" and crown / cam.mpp >= sprite_min) else "surface" C = None if sc.trees is not None and forest_mode == "surface": C = sc.field(("canopy",), lambda: TC.canopy_height(T0, sc.trees)) from terrain import Terrain T = sc.field(("T+C",), lambda: Terrain(T0.H + C, T0.cell, T0.x0, T0.y0)) else: T = T0 G = T.gbuffer(cam)''') s=s.replace(''' shadow = sc.field(("shadow", light.name), lambda: T.sun_shadow(sun, soft=T.cell * 0.5))''',''' shadow = sc.field(("shadow", light.name, forest_mode), lambda: T.sun_shadow(sun, soft=T.cell * 0.5))''') s=s.replace(''' conc = sc.field("conc", lambda: T.concavity(max(T.cell * 3, 30))) cc = T.sample(conc, G["x"], G["y"]) skyview = np.clip(0.55 + 0.45 * G["n"][..., 2] + cc / 60.0, 0.05, 1.0)''',''' conc = sc.field(("conc", forest_mode), lambda: T0.concavity(max(T0.cell * 3, 30))) cc = T.sample(conc, G["x"], G["y"]) skyview = np.clip(0.55 + 0.45 * G["n"][..., 2] + cc / 60.0, 0.05, 1.0) if C is not None: # crown-scale sky view: how deep a point sits below its neighbourhood's canopy top ctop = sc.field(("ctop",), lambda: ndi.maximum_filter(T.H, size=max(3, int(round(crown * 1.5 / T0.cell))))) depth_below = T.sample(ctop, G["x"], G["y"]) - G["z"] skyview = np.clip(skyview - depth_below / (crown * 4.0), 0.0, 1.0)''') s=s.replace(''' # ---- forest: texture where trees are sub-pixel, instances where they are big enough if "forest" in sc.cover and sc.trees is not None: fp = G["mpp"] crown = np.median(sc.trees["w"]) if len(sc.trees["w"]) else 5.0 fdens = T.sample(sc.cover["forest"], G["x"], G["y"]) tex = G["hit"] & (fdens > 0.5 + (thr_b - 0.5) * 0.25) & (crown / fp < tex_threshold) if tex.any(): TC.forest_texture(cv, tex, G, cam, sun, sunvis, ndl, kind="conifer", tree_h=float(np.median(sc.trees["h"])), crown_w=crown, seed=seed, band=band) big = sc.trees P = np.c_[big["x"], big["y"], big["z"]] _, _, dep = cam.project(P) keep = big["w"] / cam.footprint(dep) >= tex_threshold sub = {k: v[keep] for k, v in big.items()} TC.paint_trees(cv, sub, cam, G, sun, lambda x, y: T.sample(shadow, x, y), band_fn=(lambda t: int(band_of(t, bands))) if len(bands) > 1 else None)''',''' # ---- forest floor under the canopy: dark understorey, sun flecks where lit if "forest" in sc.cover: fdens = T0.sample(sc.cover["forest"], G["x"], G["y"]) floor = G["hit"] & (fdens > 0.5) if C is not None: floor &= T0.sample(C, G["x"], G["y"]) < 2.0 fl = np.where((sunvis > 0.5) & (ndl > 0.1) & (thr_b < 0.35), 2, np.where(thr_b < 0.5, 1, 0)) cv.fill(floor, "conifer", fl, band=band) # ---- forest if sc.trees is not None and forest_mode == "surface": csamp = T0.sample(C, G["x"], G["y"]) th = float(np.median(sc.trees["h"])) onc = G["hit"] & (csamp > 2.0) rel = csamp / np.maximum(T0.sample(ndi.maximum_filter(C, size=max(3, int(round(crown / T0.cell)) + 1)), G["x"], G["y"]), 1) apex = rel > 0.93 pit = rel < 0.5 kindf = T0.sample(sc.cover["broadleaf"], G["x"], G["y"]) if "broadleaf" in sc.cover else np.zeros_like(csamp) for kname, km in (("conifer", kindf < 0.5), ("broadleaf", kindf >= 0.5)): m = onc & km if m.any(): TC.paint_canopy_surface(cv, m, G, sun, sunvis, ndl, skyview, apex, pit, kind=kname, band=band, thr=threshold_map(h, w, "blue", seed + 11), seed=seed) elif sc.trees is not None: TC.paint_trees(cv, sc.trees, cam, G, sun, lambda x, y: T.sample(shadow, x, y), band_fn=(lambda t: int(band_of(t, bands))) if len(bands) > 1 else None)''') open(p,'w').write(s) EOF cd .. && nice -n 10 python3 scratch/t_canopy2.py # output: 0.5 10 1.2 10 2.5 11</pre></details><div class="step"><code>Read: aerial/scratch/t_canopy2.png</code></div></div>  *46. aerial/scratch/t_canopy2.png* <div class="steps"><details class="step"><summary><code>Write: aerial/lib/subjects.py</code></summary><pre>"""subjects.py -- small world builders for the studies and plates (what the simulator would own). Each returns a painter.Scene. Sizes in metres; `cell` chooses the grid resolution (the canopy surface needs cells <= crown/3 when crowns are drawn as a surface). """ import numpy as np from scipy import ndimage as ndi from terrain import Terrain import landform as LF import tech_canopy as TC from painter import Scene def grid(size_x, size_y, cell): nx = int(size_x / cell) + 1; ny = int(size_y / cell) + 1 Y, X = np.mgrid[0:ny, 0:nx] * cell return X.astype(float), Y.astype(float) def forest_slope(size=600, cell=1.5, seed=1, slope=0.25, clearing=(0.5, 0.5, 60), broadleaf=0.0, spacing=5.0, hmean=20.0, lone_trees=12): X, Y = grid(size, size, cell) H = slope * Y + 0.07 * size * LF.eroded_fbm(X, Y, size * 0.7, octaves=6, seed=seed + 1) + 3 * LF.fbm(X, Y, 40, seed=seed + 4) T = Terrain(H, cell) cx, cy, cr = clearing[0] * size, clearing[1] * size, clearing[2] rr = np.hypot(X - cx, (Y - cy) * 1.2) edge = cr * (1 + 0.35 * LF.fbm(X, Y, cr * 0.8, seed=seed + 9)) clear = rr < edge stand = np.clip(0.85 + 0.8 * LF.fbm(X, Y, 45, seed=seed + 3), 0, 1) forest = np.where(clear, 0.0, 1.0) cover = dict(meadow=np.where(clear, 1.0, 0.4), forest=forest) if broadleaf: cover["broadleaf"] = np.clip(broadleaf + 0.8 * LF.fbm(X, Y, 120, seed=seed + 5), 0, 1) rng = np.random.default_rng(seed) trees = TC.scatter_trees(T, forest * stand, spacing, rng, kind_field=cover.get("broadleaf"), hmean=hmean) # a few lone trees standing in the clearing (for cast shadows) if lone_trees: ang = rng.random(lone_trees) * 2 * np.pi; rad = np.sqrt(rng.random(lone_trees)) * cr * 0.7 lx = cx + np.cos(ang) * rad; ly = cy + np.sin(ang) * rad lt = dict(x=lx, y=ly, z=T.height(lx, ly), h=hmean * (0.6 + 0.4 * rng.random(lone_trees)), kind=(rng.random(lone_trees) < broadleaf).astype(int), seed=rng.integers(0, 1 << 20, lone_trees)) lt["w"] = np.where(lt["kind"] == 0, lt["h"] * 0.33, lt["h"] * 0.6) trees = {k: np.concatenate([trees[k], lt[k]]) for k in trees} return Scene(T, cover, trees=trees, seed=seed) </pre></details><details class="step"><summary><code>Bash: Texture-preserving shadow family shift</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='canvas.py'; s=open(p).read() s=s.replace("from pal import MAT_ID","from pal import MAT_ID, MAT_NAME, MATERIALS") s+=''' def to_shadow(self, mask): """move painted pixels under `mask` from the lit family into the shadow family, keeping their texture: the dominant lit steps become the top shadow step, the lower ones the step below.""" for m in np.unique(self.mat[mask]): if m == 0: continue n = MATERIALS[MAT_NAME[m]]["steps"]; ns = n // 2 sel = mask & (self.mat == m) & (self.step >= ns) self.step[sel] = np.where(self.step[sel] >= ns + 1, ns - 1, max(ns - 2, 0)) ''' open(p,'w').write(s) p='tech_canopy.py'; s=open(p).read() s=s.replace(''' sub = cv.step[ya:yb, xa:xb] if shadow_dark: cv.step[ya:yb, xa:xb] = np.where(m, np.minimum(sub, 1), sub) cv.tag[ya:yb, xa:xb] = np.where(m, 3, cv.tag[ya:yb, xa:xb])''',''' full = np.zeros((cv.h, cv.w), bool); full[ya:yb, xa:xb] = m & (cv.tag[ya:yb, xa:xb] != 3) if shadow_dark: cv.to_shadow(full) cv.tag[full] = 3''') open(p,'w').write(s) EOF echo ok # output: ok</pre></details><details class="step"><summary><code>Write: aerial/study_canopy.py</code></summary><pre>"""study_canopy.py -- the crown-clump canopy stroke, at three crown sizes, beside the photo (box- downsampled to the same crown size in pixels) and the nearest Ferrari. nice -n 10 python3 study_canopy.py -> studies/canopy.png """ import os, sys sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib")) import numpy as np from PIL import Image from camera import Iso from pal import LIGHTS from painter import paint from subjects import forest_slope import study as S ROOT = os.path.dirname(os.path.abspath(__file__)) R = lambda p: os.path.join(ROOT, "refs", p) DEER = R("aerial_view_forested_mountain_slope/commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg") ALSEK = R("aerial_conifer_forest_hillside/openverse_Between_Dangerous_River_and_Alsek_River_c0688f25.jpg") NRCS = R("aerial_view_forested_mountain_slope/openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg") FER = lambda n: os.path.join(ROOT, "refs/ferrari_lw", n + ".png") W, H = 96, 64 # native pixels per study cell def mine(mpp, seed=1, light="afternoon", broadleaf=0.0, cell=None, target=(0.5, 0.47)): crown = 20 * 0.33 cell = cell or min(1.5, max(0.5, crown / 3.5)) size = max(260, mpp * W * 2.6) sc = forest_slope(size=size, cell=cell, seed=seed, clearing=(0.5, 0.5, max(18, mpp * 16)), broadleaf=broadleaf) tx, ty = target[0] * size, target[1] * size cam = Iso(target=(tx, ty, sc.T.height(tx, ty)), mpp=mpp, elev=30, yaw=0, w=W, h=H) img, info = paint(sc, cam, LIGHTS[light]) return Image.fromarray(img), info["colours"] def run(): rows = [] # row 1: crowns ~10 px (0.66 m/px): sprite regime a, n1 = mine(0.66) p = S.px_photo(DEER, (0, 600, 380, 853), W) # crown ~38 px at full res -> ~10 px f = Image.open(FER("V16")).convert("RGB").crop((520, 170, 520 + W, 170 + H)) rows.append(S.panel("canopy, crowns ~10 px (0.66 m/px): tiered spur strokes on a lit-cap gradient", [p, a, f], ["photo (Deer Mtn, dawn) at the same crown px", f"mine ({n1} colours)", "Ferrari V16 conifers"])) # row 2: crowns ~4 px (1.6 m/px): sprite regime, spire marks b, n2 = mine(1.6) p = S.px_photo(ALSEK, (0, 380, 580, 767), W) f = Image.open(FER("V16")).convert("RGB").crop((300, 150, 300 + W, 150 + H)) rows.append(S.panel("canopy, crowns ~4 px (1.6 m/px): lit-cap arrowheads over dark notches", [p, b, f], ["photo (Alsek, overcast) same crown px", f"mine ({n2})", "Ferrari V16 far treeline"])) # row 3: crowns ~1.5 px (4.4 m/px): canopy surface regime c, n3 = mine(4.4) p = S.px_photo(NRCS, (380, 0, 1024, 430), W) f = Image.open(FER("V14")).convert("RGB").crop((0, 370, W, 370 + H)) rows.append(S.panel("canopy, crowns ~1.5 px (4.4 m/px): canopy as a lit surface + apex dabs + dark pits", [p, c, f], ["photo (NRCS far slope) same scale", f"mine ({n3})", "Ferrari V14 lower forest"])) out = S.stack(rows) out.save(os.path.join(ROOT, "studies", "canopy.png")) print("studies/canopy.png", out.size) if __name__ == "__main__": run() </pre></details><details class="step"><summary><code>Bash: Run canopy study</code></summary><pre>cd ~/work/pixelart-studies/aerial && time nice -n 10 python3 study_canopy.py # output: studies/canopy.png (2344, 1708) nice -n 10 python3 study_canopy.py 14.11s user 4.11s system 93% cpu 19.430 total</pre></details><div class="step"><code>Read: aerial/studies/canopy.png</code></div></div>  *47. aerial/studies/canopy.png* <div class="steps"><details class="step"><summary><code>Bash: Tune canopy surface regime and tree variety</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_canopy.py'; s=open(p).read() s=s.replace("Ht = hmean * (0.7 + 0.6 * rng.random(len(X)))","Ht = hmean * (0.55 + 0.9 * rng.random(len(X)) ** 1.3)") s=s.replace("avail = 1.0 - occl * np.clip((v - 0.25) / 0.6, 0, 1)","avail = 1.0 - occl * np.clip((v - 0.15) / 0.55, 0, 1)") # surface painting: gentler shade side, rarer pits, far-regime marks start=s.index('def paint_canopy_surface'); s=s[:start]+'''def paint_canopy_surface(cv, mask, G, sun, sunvis, ndl, skyview, apex, pit, kind="conifer", band=None, thr=None, seed=0, crown_px=3.0): """the far forest, from the canopy surface's own light. * lit family (3..5) where the crown surface faces the sun; the shade side of a crown is the reflected-light step (2), not black: in every canopy photo the dark fraction is only ~20-25% (narrow seams, spacing / lit radius 2.3-2.5), the rest is lit cap or lit-from-sky flank; * the darkest steps only in the pits between crowns and where terrain shadow covers the mass; * marks: sunlit crown apices get the highlight with the pixel below one step down (the stroke's own contrast). When crowns are under ~2.5 px the surface is too coarse to carry apices, so the marks become a blue-noise stipple of 1x2 dashes (lit head, darker stem) at density 0.22 -- grain that stays one pixel, never a pattern.""" mat = CON if kind == "conifer" else BRD h, w = mask.shape if thr is None: thr = threshold_map(h, w, "blue", seed) lit = (ndl > 0.0) & (sunvis > 0.5) xl = 3 + np.clip(ndl / 0.8, 0, 1) * 1.4 xs = 1.0 + np.clip((skyview - 0.3) / 0.6, 0, 1) * 1.4 x = np.where(lit, xl, xs) s = np.floor(x + (thr - 0.5) * 0.7).astype(np.int32) s = np.where(lit, np.clip(s, 3, 4), np.clip(s, 0, 2)) if crown_px >= 2.5: ap = mask & apex s = np.where(ap & lit, 5, s) s = np.where(ap & ~lit, np.maximum(s, 2), s) below = np.zeros_like(ap); below[1:] = ap[:-1] s = np.where(below & mask & ~ap, np.where(lit, 3, np.maximum(s - 1, 0)), s) s = np.where(pit & mask, np.where(sunvis > 0.5, 1, 0), s) else: t2 = threshold_map(h, w, "blue", seed + 23) head = mask & (t2 < 0.22) s = np.where(head & lit, np.minimum(s + 1, 5), np.where(head, np.maximum(s, 2), s)) stem = np.zeros_like(head); stem[1:] = head[:-1] s = np.where(stem & mask & ~head, np.where(lit, 3, np.maximum(s - 1, 0)), s) dark = mask & (t2 > 0.9) s = np.where(dark, np.where(lit, 2, 0), s) cv.fill(mask, mat, s, band=band, tag=1) ''' open(p,'w').write(s) p='painter.py'; s=open(p).read() s=s.replace(''' C = sc.field(("canopy",), lambda: TC.canopy_height(T0, sc.trees))''',''' cpx = crown / fp0 def _c(): c = TC.canopy_height(T0, sc.trees) if cpx < 2.5: # crowns sub-pixel: keep the stand surface, drop crown-scale bumps c = ndi.gaussian_filter(c, 0.6 * fp0 / T0.cell) return c C = sc.field(("canopy", round(cpx, 1)), _c)''') s=s.replace('T = sc.field(("T+C",),','T = sc.field(("T+C", round(cpx, 1)),') s=s.replace('shadow = sc.field(("shadow", light.name, forest_mode),','shadow = sc.field(("shadow", light.name, forest_mode, round(crown / fp0, 1)),') s=s.replace('ctop = sc.field(("ctop",),','ctop = sc.field(("ctop", round(crown / fp0, 1)),') s=s.replace(" pit = rel < 0.5\n"," pit = rel < 0.35\n") s=s.replace("thr=threshold_map(h, w, \"blue\", seed + 11), seed=seed)","thr=threshold_map(h, w, \"blue\", seed + 11), seed=seed, crown_px=crown / fp0)") open(p,'w').write(s) EOF grep -n "fp0" painter.py | head # output: 60: fp0 = float(np.median(cam.footprint(np.array([1000.0])))) if cam.kind == "persp" else cam.mpp 65: cpx = crown / fp0 69: c = ndi.gaussian_filter(c, 0.6 * fp0 / T0.cell) 83: shadow = sc.field(("shadow", light.name, forest_mode, round(crown / fp0, 1)), lambda: T.sun_shadow(sun, soft=T.cell * 0.5)) 91: ctop = sc.field(("ctop", round(crown / fp0, 1)), lambda: ndi.maximum_filter(T.H, size=max(3, int(round(crown * 1.5 / T0.cell))))) 137: thr=threshold_map(h, w, "blue", seed + 11), seed=seed, crown_px=crown / fp0) [This command modified 2 files you've previously read: ../pixelart-studies/aerial/lib/painter.py, ../pixelart-studies/aerial/lib/tech_canopy.py. Call Read before editing.]</pre></details><details class="step"><summary><code>Bash: Candidate Ferrari analogue crops</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * F=lambda n: load(f'refs/ferrari_lw/{n}.png') hstack([up(crop(F('V16'),(530,40,626,104)),4), up(crop(F('V14'),(200,300,296,364)),4), up(crop(F('V04'),(0,220,96,284)),4),up(crop(F('V13'),(380,250,476,314)),4)]).save('scratch/fcrops.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/fcrops.png</code></div></div>  *48. aerial/scratch/fcrops.png* <div class="steps"><details class="step"><summary><code>Bash: Rerun canopy study with fixes</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='study_canopy.py'; s=open(p).read() s=s.replace('crop((520, 170, 520 + W, 170 + H))','crop((530, 40, 530 + W, 40 + H))') s=s.replace('p = S.px_photo(NRCS, (380, 0, 1024, 430), W)','p = S.px_photo(DEER, (0, 380, 1280, 700), W)') s=s.replace('"photo (NRCS far slope) same scale"','"photo (Deer Mtn far slopes) ~same scale"') s=s.replace('crop((0, 370, W, 370 + H))','crop((200, 300, 200 + W, 300 + H))') s=s.replace('"Ferrari V14 lower forest"','"Ferrari V14 far lowland (flat tone + stipple)"') open(p,'w').write(s) EOF nice -n 10 python3 study_canopy.py # output: studies/canopy.png (2344, 1708)</pre></details><div class="step"><code>Read: aerial/studies/canopy.png</code></div></div>  *49. aerial/studies/canopy.png* <div class="steps"><details class="step"><summary><code>Bash: Denser stands, wider crowns, calmer far marks</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' import re p='lib/subjects.py'; s=open(p).read() s=s.replace("stand = np.clip(0.85 + 0.8 * LF.fbm(X, Y, 45, seed=seed + 3), 0, 1)","stand = np.clip(1.15 + 0.9 * LF.fbm(X, Y, 45, seed=seed + 3), 0, 1)") s=s.replace('lt["w"] = np.where(lt["kind"] == 0, lt["h"] * 0.33, lt["h"] * 0.6)','lt["w"] = np.where(lt["kind"] == 0, lt["h"] * 0.4, lt["h"] * 0.6)') open(p,'w').write(s) p='lib/tech_canopy.py'; s=open(p).read() s=s.replace('Wc = np.where(kind == 0, Ht * (0.28 + 0.08 * rng.random(len(X))),','Wc = np.where(kind == 0, Ht * (0.34 + 0.1 * rng.random(len(X))),') s=s.replace("top = max(1, int(round(0.1 * h)))\n phase","top = max(1, int(round(0.06 * h)))\n phase") s=s.replace("r = 0.5 * (w - 1) * min(1.0, 0.2 + 1.0 * v)","r = 0.5 * (w - 1) * min(1.0, 0.3 + 1.3 * v)") s=s.replace("head = mask & (t2 < 0.22)\n s = np.where(head & lit, np.minimum(s + 1, 5),","head = mask & (t2 < 0.13)\n s = np.where(head & lit, np.minimum(s + 1, 4),") open(p,'w').write(s) p='lib/pal.py'; s=open(p).read() s=s.replace('"meadow": dict(alb=(118, 140, 72), steps=5, chroma=1.2, walk=10)','"meadow": dict(alb=(104, 136, 70), steps=5, chroma=1.15, walk=0)') open(p,'w').write(s) p='study_canopy.py'; s=open(p).read() s=s.replace("S.px_photo(DEER, (0, 380, 1280, 700), W)","S.px_photo(DEER, (0, 330, 930, 950), W)") s=s.replace("crown = 20 * 0.33","crown = 20 * 0.39") open(p,'w').write(s) EOF nice -n 10 python3 study_canopy.py # output: studies/canopy.png (2344, 1708)</pre></details><div class="step"><code>Read: aerial/studies/canopy.png</code></div></div>  *50. aerial/studies/canopy.png* <div class="steps"><details class="step"><summary><code>Bash: Use sprites down to 3px crowns</code></summary><pre>cd ~/work/pixelart-studies/aerial && sed -i '' 's/sprite_min=5.0/sprite_min=3.0/' lib/painter.py && sed -i '' 's/if w >= 5:/if w >= 4.5:/' lib/tech_canopy.py && nice -n 10 python3 study_canopy.py # output: studies/canopy.png (2344, 1708)</pre></details><details class="step"><summary><code>Bash: Crop row 2 of study</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " from PIL import Image; im=Image.open('studies/canopy.png'); im.crop((0,570,2344,1140)).save('scratch/row2.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/row2.png</code></div></div>  *51. aerial/scratch/row2.png* <div class="steps"><details class="step"><summary><code>Bash: Show lights and ramp function</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && grep -n "LIGHTS = {" -A8 pal.py | head -12; grep -n "def material_ramp" -A12 pal.py | head -14 # output: 63:LIGHTS = { 64- # sun colours and sky ambient in linear RGB (relative). Measured targets noted in NOTES.md. 65- "morning": Light("morning", 14, 105, sun=(1.25, 1.0, 0.72), sky=(0.20, 0.26, 0.40), haze=(196, 196, 206), haze_k=1 / 9000), 66- "noon": Light("noon", 58, 200, sun=(1.15, 1.08, 0.98), sky=(0.24, 0.30, 0.42), haze=(190, 205, 222), haze_k=1 / 12000), 67- "afternoon": Light("afternoon", 30, 245, sun=(1.2, 1.05, 0.85), sky=(0.21, 0.27, 0.42), haze=(185, 200, 220), haze_k=1 / 10000), 68- "evening": Light("evening", 7, 290, sun=(1.35, 0.78, 0.45), sky=(0.22, 0.20, 0.40), haze=(214, 170, 176), haze_k=1 / 7000), 69- "overcast": Light("overcast", 45, 200, sun=(0.18, 0.18, 0.19), sky=(0.62, 0.64, 0.68), haze=(200, 202, 206), haze_k=1 / 5000), 70-} 71- 117:def material_ramp(mat, light, hue_walk=True): 118- """colours (sRGB 0..255) of every step of a material under a light, before depth bands.""" 119- m = MATERIALS[mat] 120- alb = srgb_to_lin(m["alb"]) 121- n = m["steps"] 122- if m.get("emissive"): 123- base = np.array(m["alb"], float) 124- cols = np.array([base * (0.45 + 0.55 * k / (n - 1)) for k in range(n)]) 125- cols[-1] = (255, 250, 210) 126- return cols 127- E = step_irradiance(n, light) 128- col = alb[None] * E * light.exposure 129- # a gentle shoulder so snow and sunlit sand don't clip flat</pre></details><details class="step"><summary><code>Bash: Add sky colours and water ramp</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='pal.py'; s=open(p).read() # sky colours per light (measured: Cosumnes noon-ish sky top (120,180,236), horizon (177,202,232)) s=s.replace(''' self.exposure = exposure self.chroma = chroma''',''' self.exposure = exposure self.chroma = chroma self.sky_top = None; self.sky_hor = None''') s=s.replace('''} # ---------------------------------------------------------------- materials''','''} SKY = { # (zenith-ish at ~50 deg elevation, horizon) sRGB; afternoon measured on the Cosumnes drone photo "morning": ((132, 170, 214), (226, 208, 190)), "noon": ((112, 170, 230), (182, 206, 232)), "afternoon": ((120, 176, 234), (177, 202, 232)), "evening": ((104, 104, 168), (236, 170, 150)), "overcast": ((176, 182, 190), (204, 206, 210)), } for _k, (_t, _h) in SKY.items(): LIGHTS[_k].sky_top = np.array(_t, float); LIGHTS[_k].sky_hor = np.array(_h, float) def water_ramp(light, body=(28, 52, 58)): """water is the sky seen in a dark mirror. 0 shaded bank lip | 1 reflection of land/trees | 2 water body | 3 low-sky sheen | 4 bright sky (grazing) | 5 glint. Colours come from the sky and the water body, not from an albedo under light.""" b = np.array(body, float) * (0.6 + 0.4 * np.mean(light.sky_hor) / 200) t, h = light.sky_top, light.sky_hor sun = np.clip(lin_to_srgb(srgb_to_lin(h) * 1.6), 0, 255) cols = np.array([b * 0.45, b * 0.8 + t * 0.05, b * 0.85 + t * 0.25, b * 0.45 + t * 0.6, b * 0.15 + h * 0.9, sun * 0.3 + 255 * 0.7]) return push_chroma(np.clip(cols, 0, 255), 1.2) # ---------------------------------------------------------------- materials''') s=s.replace(''' E = step_irradiance(n, light) col = alb[None] * E * light.exposure''',''' if mat == "water": return water_ramp(light) E = step_irradiance(n, light) col = alb[None] * E * light.exposure''') open(p,'w').write(s) EOF python3 -c " import sys; sys.path.insert(0,'.') from pal import * for n in LIGHTS: print(n,[tuple(int(v) for v in c) for c in material_ramp('water',LIGHTS[n])])" # output: morning [(10, 24, 27), (24, 51, 59), (49, 88, 107), (83, 126, 161), (209, 194, 176), (255, 255, 247)] noon [(10, 24, 27), (22, 51, 60), (41, 88, 112), (65, 126, 173), (162, 193, 223), (244, 254, 255)] afternoon [(10, 23, 27), (22, 51, 60), (44, 89, 112), (71, 130, 175), (157, 190, 223), (242, 253, 255)] evening [(9, 23, 26), (22, 46, 55), (43, 69, 94), (70, 84, 134), (223, 157, 137), (255, 240, 232)] overcast [(10, 24, 27), (26, 51, 58), (63, 90, 99), (115, 133, 142), (186, 193, 198), (253, 254, 255)]</pre></details><details class="step"><summary><code>Write: aerial/lib/tech_water.py</code></summary><pre>"""tech_water.py -- the river ribbon (and lakes, tarns, sea) seen from above. What the photos say (measure/photo_stats.json 'river_*', Cosumnes drone, Minnesota wetland, Tierra del Fuego valley): * water from above is a dark mirror. Looking steeply down (near, ~40 deg) the river is DARKER than the land around it (L* 23 vs canopy 53, sunny field 68); toward grazing angles (mid/far) it turns to sky (L* 45, chroma 32, sky hue). Fresnel does this: 5% at 30 deg down, 18% at 15. * the far bank's trees reflect as a dark band hanging down into the water from the far bank (in ortho iso the band is exactly the trees' projected height, mirrored). * the near bank has a dark lip; the far waterline at grazing angles a light line. * flow reads as sparse streaks along the current; still water as flat bands. What Ferrari does (V02 rivers from high up, V11AM, V16 pond): water is the lightest thing on the land at a distance -- sky colours in flat bands joined by checker seams; meanders foreshorten into long horizontal runs with short vertical steps; near water sparkles with a 2-colour stipple of the hottest sky colours; the upper bank edge carries a dark 1-px line. Stylization applied: Fresnel reflectance x2.5 (Ferrari's water is always more sky than physics allows; his reflections drop only ~13 L* from what they mirror). Water ramp (pal.water_ramp): 0 lip | 1 land reflection | 2 body | 3 low-sky sheen | 4 bright sky | 5 glint. """ import numpy as np from dither import threshold_map, flat_bands WATER_BOOST = 2.5 def fresnel(cos_i, f0=0.02): return f0 + (1 - f0) * (1 - np.clip(cos_i, 0, 1)) ** 5 def paint_water(cv, mask, G, Trefl, sun, light, seed=0, band=None, flow=0.0, sky_val=None): """mask: water pixels. Trefl: terrain (+canopy) used to trace the reflected rays. flow in [0,1]: 0 still (lake), 1 river (streaks along the current).""" from pal import MAT_ID h, w = mask.shape ys, xs = np.nonzero(mask) step = np.zeros((h, w), np.int32) if len(ys) == 0: return step D = G["D"][ys, xs] R = D.copy(); R[:, 2] = -R[:, 2] P = np.c_[G["x"][ys, xs], G["y"][ys, xs], G["z"][ys, xs] + 0.3] t = Trefl.raymarch(P[None], R[None], t0=0.5, t1=3000)[0] land = np.isfinite(t) # what the reflected ray hits: land (dark, a little lighter if that land is sunlit) or sky el = np.arcsin(np.clip(R[:, 2], 0, 1)) # sky elevation seen in the mirror F = np.clip(fresnel(R[:, 2]) * WATER_BOOST, 0, 1) thr = threshold_map(h, w, "bayer4")[ys, xs] # continuous coordinate: 2 (body) .. 4 (bright sky) by F; sky near the horizon is brighter skyb = 0.55 + 0.45 * (1 - el / (np.pi / 2)) x = 2.0 + np.clip(F * skyb * 5.0, 0, 2.2) s = flat_bands(x, thr, 0.25) s = np.where(land, 1, s) s = np.clip(s, 1, 4) step[ys, xs] = s # ---- marks thr_b = threshold_map(h, w, "blue", seed) below = np.zeros_like(mask); below[:-1] = mask[1:] # pixel below is water above = np.zeros_like(mask); above[1:] = mask[:-1] near_lip = mask & ~below # lowest water row: near bank lip far_edge = mask & ~above # top water row: far waterline step[near_lip] = 0 fe = far_edge & (step >= 2) step[fe] = np.minimum(step[fe] + 1, 4) # light line at the far waterline # streaks along the current (river) / wind lines (lake): horizontal 2-5 px dashes one step lighter if flow > 0 or True: dens = 0.015 + 0.05 * flow seeds = mask & (thr_b < dens) & (step >= 1) & (step <= 3) yy, xx = np.nonzero(seeds) rng = np.random.default_rng(seed) L = rng.integers(2, 6, len(yy)) for y, x, l in zip(yy, xx, L): for k in range(l): if x + k < w and mask[y, x + k] and step[y, x + k] in (1, 2, 3): step[y, x + k] += 1 # glint when the sun is mirrored toward the camera (back light) Rs = np.array([sun[0], sun[1], -sun[2]]) gl = (D @ Rs) if D.ndim == 2 else None if gl is not None: g = np.zeros((h, w)); g[ys, xs] = gl glint = mask & (g > 0.985) & (thr_b < 0.5) step[glint] = 5 cv.fill(mask, "water", step, band=band, tag=2) return step </pre></details><details class="step"><summary><code>Bash: Integrate water into painter</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='painter.py'; s=open(p).read() s=s.replace(''' C = None if sc.trees is not None and forest_mode == "surface":''',''' C = None from terrain import Terrain Wl = None if sc.water is not None: Wl = np.where(np.isfinite(sc.water["level"]), sc.water["level"], -1e9) if sc.trees is not None and forest_mode == "surface":''') s=s.replace(''' T = sc.field(("T+C", round(cpx, 1)), lambda: Terrain(T0.H + C, T0.cell, T0.x0, T0.y0)) else: T = T0''',''' T = sc.field(("T+C", round(cpx, 1)), lambda: Terrain(T0.H + C if Wl is None else np.maximum(T0.H + C, Wl), T0.cell, T0.x0, T0.y0)) else: T = T0 if Wl is None else sc.field(("T+W",), lambda: Terrain(np.maximum(T0.H, Wl), T0.cell, T0.x0, T0.y0))''') s=s.replace(''' # ---- forest floor under the canopy''',''' # ---- water: the dark mirror if Wl is not None: import tech_water as TW wl = T0.sample(Wl, G["x"], G["y"]) wmask = G["hit"] & (wl > T0.sample(T0.H, G["x"], G["y"]) + 0.02) & (np.abs(G["z"] - wl) < 0.5) if sc.trees is not None: Cr = C if C is not None else sc.field(("canopy_refl",), lambda: TC.canopy_height(T0, sc.trees)) Trefl = sc.field(("Trefl",), lambda: Terrain(T0.H + Cr, T0.cell, T0.x0, T0.y0)) else: Trefl = T0 TW.paint_water(cv, wmask, G, Trefl, sun, light, seed=seed, band=band, flow=sc.water.get("flow", 0.0)) G["water"] = wmask # ---- forest floor under the canopy''') open(p,'w').write(s) EOF grep -n "from terrain import Terrain" painter.py # output: 64: from terrain import Terrain 76: from terrain import Terrain</pre></details><details class="step"><summary><code>Bash: River valley subject and test render</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='painter.py'; s=open(p).read() s=s.replace(''' floor = G["hit"] & (fdens > 0.5) ''',''' floor = G["hit"] & (fdens > 0.5) & ~G.get("water", np.zeros_like(G["hit"])) ''') open(p,'w').write(s) EOF cat >> subjects.py <<'EOF' def river_valley(size=900, cell=1.5, seed=2, width=14.0, meander=0.18, forest_sides=True, spacing=5.5, hmean=20.0, valley_w=0.35, broadleaf=0.3): """a flat-floored valley running north with a meandering river on meadows, forest on the sides.""" X, Y = grid(size, size, cell) cxv = size * 0.5 + size * 0.08 * LF.fbm(X * 0 + 1, Y, size * 0.8, seed=seed) # valley axis d = (X - cxv) / (size * valley_w) H = 0.05 * Y + 90 * np.clip(np.abs(d) - 0.5, 0, None) ** 1.5 + 25 * LF.eroded_fbm(X, Y, size * 0.5, seed=seed + 1) * np.clip(np.abs(d) - 0.3, 0, 1) \ + 0.6 * LF.fbm(X, Y, 25, seed=seed + 2) # meander: river centreline x(y) yy = Y[:, 0] rx = cxv[:, 0] + size * meander * 0.5 * np.sin(yy / (size * 0.22) * 2 * np.pi + 1.0) + size * 0.05 * LF.fbm(np.zeros_like(yy), yy, size * 0.3, seed=seed + 7) dist = np.abs(X - rx[:, None]) # channel distance should be measured perpendicular to the path: correct by the path slope slope = np.gradient(rx, cell) dist = dist / np.sqrt(1 + slope[:, None] ** 2) wloc = width * (1 + 0.25 * LF.fbm(X, Y, 80, seed=seed + 8)) bed = np.clip(1 - dist / (wloc / 2 + 2.0), 0, 1) H = H - 1.8 * np.sqrt(bed) level = np.where(dist < wloc / 2, H.max() * 0 + (0.05 * Y + 0.0 - 0.4 + 0.6 * LF.fbm(X, Y, 25, seed=seed + 2) * 0), np.nan) # water level: floor height at the centreline minus a little, smooth along y floor = 0.05 * Y - 0.5 level = np.where(dist < wloc / 2, floor, np.nan) T = Terrain(H, cell) side = np.clip((np.abs(d) - 0.42) / 0.12, 0, 1) patch = LF.fbm(X, Y, 90, seed=seed + 5) forest = np.clip(side + (patch > 0.35) * 0.9, 0, 1) * (dist > wloc / 2 + 6) forest = (forest > 0.5).astype(float) cover = dict(meadow=np.ones_like(H) * 0.6, soil=np.where(dist < wloc / 2 + 2.5, 0.7, 0.0), forest=forest) cover["broadleaf"] = np.clip(broadleaf + 0.6 * patch + 0.5 * (np.abs(d) < 0.45), 0, 1) rng = np.random.default_rng(seed) trees = TC.scatter_trees(T, forest, spacing, rng, kind_field=cover["broadleaf"], hmean=hmean) return Scene(T, cover, trees=trees, water=dict(level=level, flow=1.0), seed=seed) EOF cd .. && cat > scratch/t_river.py <<'EOF' import sys; sys.path.insert(0,'lib') import numpy as np from PIL import Image from camera import Iso from pal import LIGHTS from painter import paint from subjects import river_valley from look import * sc=river_valley() out=[] for mpp in [0.8,2.0]: cam=Iso(target=(450,450,sc.T.height(450,450)),mpp=mpp,elev=30,yaw=0,w=320,h=180) img,info=paint(sc,cam,LIGHTS['afternoon']); print(mpp,info['colours']) out.append(up(Image.fromarray(img),2)) vstack(out).save('scratch/t_river.png') EOF nice -n 10 python3 scratch/t_river.py # output: 0.8 23 2.0 26</pre></details><div class="step"><code>Read: aerial/scratch/t_river.png</code></div></div>  *52. aerial/scratch/t_river.png* <div class="steps"><details class="step"><summary><code>Bash: Tune water, point bars, broadleaf colour</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_water.py'; s=open(p).read() s=s.replace("WATER_BOOST = 2.5","WATER_BOOST = 1.8") open(p,'w').write(s) p='pal.py'; s=open(p).read() s=s.replace('"broadleaf": dict(alb=(96, 124, 56), steps=6, chroma=1.3, walk=30)','"broadleaf": dict(alb=(84, 118, 60), steps=6, chroma=1.2, walk=14)') open(p,'w').write(s) p='subjects.py'; s=open(p).read() s=s.replace("rx = cxv[:, 0] + size * meander * 0.5 * np.sin(yy / (size * 0.22) * 2 * np.pi + 1.0) + size * 0.05 * LF.fbm(np.zeros_like(yy), yy, size * 0.3, seed=seed + 7)", "ph = yy / (size * 0.24) * 2 * np.pi + 2.5 * LF.fbm(np.zeros_like(yy), yy, size * 0.35, seed=seed + 7)\n rx = cxv[:, 0] + size * meander * 0.5 * (np.sin(ph + 1.0) + 0.35 * np.sin(2.3 * ph))") s=s.replace(''' cover = dict(meadow=np.ones_like(H) * 0.6, soil=np.where(dist < wloc / 2 + 2.5, 0.7, 0.0), forest=forest)''',''' # point bars: gravel on the inside of bends only (where the channel curves away) curv = np.gradient(slope, cell) inside = np.sign(X - rx[:, None]) == -np.sign(curv[:, None]) bar = (dist < wloc / 2 + 3 + 6 * np.clip(np.abs(curv[:, None]) * size * 2, 0, 1)) & inside & (np.abs(curv[:, None]) * size > 0.08) dry = (LF.fbm(X, Y, 60, seed=seed + 11) > 0.25).astype(float) cover = dict(meadow=np.ones_like(H) * 0.6, drygrass=dry * 0.7, soil=np.where(bar, 0.9, 0.0), forest=forest)''') open(p,'w').write(s) EOF cd .. && nice -n 10 python3 scratch/t_river.py # output: 0.8 28 2.0 31</pre></details><div class="step"><code>Read: aerial/scratch/t_river.png</code></div></div>  *53. aerial/scratch/t_river.png* <div class="steps"><details class="step"><summary><code>Bash: Tune bars, dry grass, stipple</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='subjects.py'; s=open(p).read() s=s.replace("bar = (dist < wloc / 2 + 3 + 6 * np.clip(np.abs(curv[:, None]) * size * 2, 0, 1)) & inside & (np.abs(curv[:, None]) * size > 0.08)", "bar = (dist < wloc / 2 + 1.5 + 3.5 * np.clip(np.abs(curv[:, None]) * size, 0, 1) * (0.6 + LF.fbm(X, Y, 12, seed=seed + 12))) & inside & (np.abs(curv[:, None]) * size > 0.15)") s=s.replace("dry = (LF.fbm(X, Y, 60, seed=seed + 11) > 0.25).astype(float)","dry = (LF.fbm(X, Y, 60, seed=seed + 11) > 0.3).astype(float)") open(p,'w').write(s) p='pal.py'; s=open(p).read() s=s.replace('"drygrass": dict(alb=(172, 158, 118), steps=5, chroma=1.4)','"drygrass": dict(alb=(146, 142, 92), steps=5, chroma=1.15)') open(p,'w').write(s) p='painter.py'; s=open(p).read() s=s.replace("up=0.16, down=0.16, lo=lo, hi=hi)","up=0.11, down=0.11, lo=lo, hi=hi)") open(p,'w').write(s) EOF echo ok # output: ok</pre></details><details class="step"><summary><code>Bash: Find Minnesota wetland photo</code></summary><pre>cd ~/work/pixelart-studies/aerial && ls refs/aerial_river_valley_meadow | grep -i minn; python3 -c " from PIL import Image; im=Image.open('refs/aerial_river_valley_meadow/'+[f for f in __import__('os').listdir('refs/aerial_river_valley_meadow') if 'Minnesota_River_Valley_Wetland_jpg' in f][0]); print(im.size)" # output: commons_Minnesota_River_Valley_Wetland_jpg_a3bd8e9a.jpg openverse_Minnesota_River_Valley_Wetland_e3141e52.jpg (1280, 960)</pre></details><details class="step"><summary><code>Write: aerial/study_river.py</code></summary><pre>"""study_river.py -- the river ribbon with its bank light, at two scales, beside the photos and Ferrari. nice -n 10 python3 study_river.py -> studies/river.png """ import os, sys sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib")) from PIL import Image from camera import Iso from pal import LIGHTS from painter import paint from subjects import river_valley import study as S ROOT = os.path.dirname(os.path.abspath(__file__)) R = lambda p: os.path.join(ROOT, "refs", p) COS = R("drone_river_meadow_valley/commons_Cosumnes_River_drone_jpg_d9b23c68.jpg") MINN = R("aerial_river_valley_meadow/commons_Minnesota_River_Valley_Wetland_jpg_a3bd8e9a.jpg") FER = lambda n: os.path.join(ROOT, "refs/ferrari_lw", n + ".png") W, H = 96, 64 def run(light="afternoon"): sc = river_valley(seed=2) rows = [] for mpp, photo, box, cap, fer, fbox, fcap, title in [ (0.8, COS, (160, 300, 880, 780), "photo (Cosumnes, drone) same river px", "V02", (60, 280, 156, 344), "Ferrari V02 near river", "river ribbon, 0.8 m/px: dark mirror body, sky sheen streaks, near-bank lip, far waterline light"), (2.0, MINN, (250, 560, 1010, 1067), "photo (Minnesota wetland) meander", "V11AM", (130, 330, 226, 394), "Ferrari V11AM river", "river ribbon, 2 m/px: the ribbon as one light-dark stroke; point bars only on inside bends"), ]: cam = Iso(target=(450, 470, sc.T.height(450, 470)), mpp=mpp, elev=30, yaw=0, w=W, h=H) img, info = paint(sc, cam, LIGHTS[light]) box = (box[0], box[1], box[2], min(box[3], Image.open(photo).size[1])) p = S.px_photo(photo, box, W) f = Image.open(FER(fer)).convert("RGB").crop(fbox) rows.append(S.panel(title, [p, Image.fromarray(img), f], [cap, f"mine ({info['colours']} colours)", fcap])) out = S.stack(rows) out.save(os.path.join(ROOT, "studies", "river.png")); print("studies/river.png") if __name__ == "__main__": run() </pre></details><details class="step"><summary><code>Bash: Run river study</code></summary><pre>cd ~/work/pixelart-studies/aerial && nice -n 10 python3 study_river.py # output: studies/river.png</pre></details><div class="step"><code>Read: aerial/studies/river.png</code></div></div>  *54. aerial/studies/river.png* <div class="steps"><details class="step"><summary><code>Bash: Target river in study row 1</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='study_river.py'; s=open(p).read() s=s.replace(''' cam = Iso(target=(450, 470, sc.T.height(450, 470)), mpp=mpp, elev=30, yaw=0, w=W, h=H)''',''' import numpy as np lv = sc.water["level"]; j = int(470 / sc.T.cell); xs = np.nonzero(np.isfinite(lv[j]))[0] tx = float(xs.mean() * sc.T.cell) if len(xs) else 450.0 cam = Iso(target=(tx, 470, sc.T.height(tx, 470)), mpp=mpp, elev=30, yaw=0, w=W, h=H)''') open(p,'w').write(s) EOF nice -n 10 python3 study_river.py # output: studies/river.png</pre></details><div class="step"><code>Read: aerial/studies/river.png</code></div></div>  *55. aerial/studies/river.png* <div class="steps"><details class="step"><summary><code>Bash: Add steep bank face soil strip</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='subjects.py'; s=open(p).read() s=s.replace("soil=np.where(bar, 0.9, 0.0), forest=forest)","soil=np.where(bar | ((dist > wloc / 2) & (dist < wloc / 2 + 1.6)), 0.9, 0.0), forest=forest)") s=s.replace("H = H - 1.8 * np.sqrt(bed)","H = H - 1.8 * np.clip(bed * 2.2, 0, 1)") open(p,'w').write(s) EOF cd .. && nice -n 10 python3 study_river.py && python3 -c " from PIL import Image; im=Image.open('studies/river.png'); im.crop((780,0,1560,560)).save('scratch/r1.png')" # output: studies/river.png</pre></details><div class="step"><code>Read: aerial/scratch/r1.png</code></div></div>  *56. aerial/scratch/r1.png* <div class="steps"><details class="step"><summary><code>Bash: Cirque subject builder and test</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cat >> subjects.py <<'EOF' def cirque(size=1000, cell=2.0, seed=3, snow=0.5, erode=True, trees=True): """a glacial cirque opening south toward the camera: headwall with cliff bands and gullies, scree cones under the gullies, a tarn on the floor, snow in shaded hollows.""" X, Y = grid(size, size, cell) cx, cy, R = size * 0.5, size * 0.58, size * 0.3 dx, dy = X - cx, Y - cy r = np.hypot(dx, dy * 1.1); th = np.arctan2(dx, dy) # th = 0 north (back wall) open_ = np.clip(np.cos(th) * 0.8 + 0.45, 0, 1) # walls high at the back, open to the south wall = smooth = np.clip((r - R * 0.55) / (R * 0.6), 0, 1) H = 320 * (wall ** 1.6) * open_ + 0.04 * (cy - Y) * -1 H += 18 * LF.eroded_fbm(X, Y, 300, octaves=6, seed=seed) # gullies: radial grooves in the headwall gul = LF.ridged(th[..., None].squeeze() * 90 + 0 * X, r * 0.02, 1.0, octaves=2, seed=seed + 1) H -= 22 * (1 - gul) * np.clip((r - R * 0.6) / R, 0, 1) * open_ # cliff bands: ledges where it is steep (terrace the height on the walls) steep0 = np.clip((wall - 0.15) * 3, 0, 1) * open_ band = 22.0 Ht = np.floor(H / band) * band + band * np.clip((H / band % 1 - 0.35) / 0.65, 0, 1) ** 2 H = H * (1 - 0.6 * steep0) + Ht * 0.6 * steep0 # floor: a shallow basin for the tarn H -= 12 * np.exp(-((dx / (R * 0.45)) ** 2 + ((dy + R * 0.15) / (R * 0.32)) ** 2)) H += 3 * LF.fbm(X, Y, 40, seed=seed + 5) if erode: H = LF.droplet_erosion(H, cell, n_drops=150000, seed=seed) T = Terrain(H, cell) slope = T.slope_deg() conc = T.concavity(30) # tarn: fill the basin up to a level lvl = np.percentile(H[r < R * 0.5], 12) lab, n = ndi.label(H < lvl) ci, cj = int(cx / cell), int((cy - R * 0.15) / cell) tarn = lab == lab[cj, ci] if lab[cj, ci] else np.zeros_like(H, bool) level = np.where(tarn, lvl, np.nan) cliff = np.clip((slope - 38) / 8, 0, 1) # scree: moderately steep ground below the cliffs (and on the eroded fans) below_cliff = ndi.maximum_filter(cliff > 0.5, size=int(90 / cell)) & (slope > 18) & (slope < 42) scree = below_cliff.astype(float) * 0.9 rough = LF.fbm(X, Y, 50, seed=seed + 6) meadow = np.clip(1 - slope / 30, 0, 1) * 0.8 shade = 1 - T.sun_shadow(np.array([-0.5, -0.3, 0.8]) / np.linalg.norm([-0.5, -0.3, 0.8])) # a neutral 'north-ish shade' proxy snow_w = np.clip(snow * 1.4 - 0.3 + (-conc / 6.0) + 0.5 * (H - H.mean()) / np.ptp(H) + 0.3 * rough, 0, 1) * (slope < 44) cover = dict(meadow=meadow, scree=scree, rock=cliff * 1.2 + 0.25, snow=(snow_w > 0.55).astype(float) * 1.3) forest = ((slope < 25) & (r > R * 0.7) & (H < np.percentile(H, 35)) & (rough > 0.05)).astype(float) cover["forest"] = forest tr = None if trees: rng = np.random.default_rng(seed) tr = TC.scatter_trees(T, forest * 0.8, 6.0, rng, hmean=16) extras = dict(cliff=cliff, conc=conc) return Scene(T, cover, trees=tr, water=dict(level=level, flow=0.0), extras=extras, seed=seed) EOF cd .. && cat > scratch/t_cirque.py <<'EOF' import sys,time; sys.path.insert(0,'lib') import numpy as np from PIL import Image from camera import Iso from pal import LIGHTS from painter import paint from subjects import cirque from look import * t0=time.time(); sc=cirque(); print('build',time.time()-t0) cam=Iso(target=(500,560,sc.T.height(500,560)),mpp=2.4,elev=30,yaw=0,w=320,h=180) img,info=paint(sc,cam,LIGHTS['afternoon']); print(info['colours'],time.time()-t0) up(Image.fromarray(img),3).save('scratch/t_cirque.png') EOF nice -n 10 python3 scratch/t_cirque.py # output: build 4.970177173614502 29 10.335281133651733</pre></details><div class="step"><code>Read: aerial/scratch/t_cirque.png</code></div></div>  *57. aerial/scratch/t_cirque.png* <div class="steps"><details class="step"><summary><code>Bash: Debug view of cirque heightfield and cover</code></summary><pre>cd ~/work/pixelart-studies/aerial && cat > scratch/t_cirque_dbg.py <<'EOF' import sys,time; sys.path.insert(0,'lib') import numpy as np from PIL import Image from subjects import cirque from look import * sc=cirque() T=sc.T; s=T.slope_deg() def norm(a): a=(a-a.min())/(np.ptp(a)+1e-9); return (a*255).astype(np.uint8) names=['meadow','scree','rock','snow','forest'] W=np.stack([sc.cover[n] for n in names]); idx=np.argmax(W,0) cols=np.array([[90,160,60],[160,140,120],[110,100,100],[240,240,255],[20,70,30]]) m=cols[idx].astype(np.uint8) hs=norm(-np.gradient(T.H,axis=1)+np.gradient(T.H,axis=0)) ims=[Image.fromarray(np.flipud(norm(T.H))).resize((400,400)),Image.fromarray(np.flipud(hs)).resize((400,400)),Image.fromarray(np.flipud(m)).resize((400,400),Image.NEAREST)] hstack(ims).save('scratch/cirque_dbg.png') EOF nice -n 10 python3 scratch/t_cirque_dbg.py # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/cirque_dbg.png</code></div></div>  *58. aerial/scratch/cirque_dbg.png* <div class="steps"><details class="step"><summary><code>Bash: Rebuild cirque by radial profile</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='subjects.py'; s=open(p).read() start=s.index('def cirque('); s=s[:start] s+='''def cirque(size=1000, cell=2.0, seed=3, snow=0.5, erode=True, trees=True): """a glacial cirque opening south toward the camera, built from its radial profile: tarn floor | scree apron (30 deg) with cones under the gullies | headwall (55-65 deg) with cliff bands | crest. Snow lies in the gullies, on ledges and at the top of the apron in shade.""" X, Y = grid(size, size, cell) rng = np.random.default_rng(seed) cx, cy = size * 0.5, size * 0.56 dx, dy = X - cx, Y - cy r = np.hypot(dx, dy); th = np.arctan2(dx, dy) # th = 0: back wall (north) wob = LF.fbm(np.cos(th) * 3, np.sin(th) * 3, 1.0, seed=seed) # slow wobble of the wall line # gullies: notches at random angles ng = 13; ga = np.sort(rng.uniform(-2.3, 2.3, ng)); gw = rng.uniform(0.035, 0.07, ng); gd = rng.uniform(0.5, 1.0, ng) g = np.zeros_like(r) for a, w_, d in zip(ga, gw, gd): g = np.maximum(g, d * np.exp(-0.5 * ((th - a) / w_) ** 2)) R0 = 150 + 25 * wob - 45 * g # apron toe (cones reach further out under gullies) R1 = 245 + 30 * wob + 25 * g # headwall foot R2 = 350 + 25 * wob + 35 * g # crest open_ = np.clip(np.cos(th) * 0.75 + 0.5, 0.0, 1.0) ** 0.8 apron = np.clip((r - R0) / (R1 - R0), 0, 1) h_apron = 0.6 * (R1 - R0) * apron ** 1.3 * (1 + 0.4 * g) # concave-up cones wallt = np.clip((r - R1) / (R2 - R1), 0, 1) h_wall = 1.9 * (R2 - R1) * wallt ** 0.9 behind = np.clip(r - R2, 0, None) H = (h_apron + h_wall - 0.7 * behind) * open_ H -= 30 * g * wallt * open_ # gullies cut the wall # cliff bands: terrace the headwall band = 24.0 Ht = np.floor(H / band) * band + band * np.clip((H / band % 1 - 0.3) / 0.7, 0, 1) ** 1.5 wk = np.clip(wallt * 4, 0, 1) * np.clip((1 - wallt) * 6, 0, 1) * open_ H = H * (1 - 0.7 * wk) + Ht * 0.7 * wk # floor basin and regional tilt (the valley falls toward the camera) H -= 14 * np.exp(-((dx / 110) ** 2 + ((dy + 40) / 80) ** 2)) H += 0.08 * (Y - cy) * (1 - open_) + 0.05 * Y H += 16 * LF.eroded_fbm(X, Y, 260, octaves=6, seed=seed) * (0.3 + wallt) + 2 * LF.fbm(X, Y, 25, seed=seed + 5) if erode: H = LF.droplet_erosion(H, cell, n_drops=120000, seed=seed) T = Terrain(H, cell) slope = T.slope_deg() conc = T.concavity(20) lvl = np.percentile(H[r < 120], 20) lab, n = ndi.label(H < lvl) ci, cj = int(cx / cell), int((cy - 40) / cell) tarn = (lab == lab[cj, ci]) if lab[cj, ci] else np.zeros_like(H, bool) level = np.where(tarn, lvl, np.nan) rough = LF.fbm(X, Y, 50, seed=seed + 6) cliff = ((slope > 40) | ((wk > 0.3) & (slope > 30))).astype(float) ledge = (wk > 0.3) & (slope < 30) scree = ((apron > 0.05) & (apron < 1.0) & (r < R1 + 5) & (slope > 12)).astype(float) * open_ meadow = np.clip(1 - slope / 28, 0, 1) * 0.7 snow_w = snow * 1.2 + 0.9 * g * np.clip(wallt * 2, 0, 1) + 0.6 * ledge + 0.5 * np.clip((apron - 0.7) * 3, 0, 1) * g \\ + 0.25 * rough - 0.9 + 0.3 * np.clip(behind / 60, 0, 1) snow_m = (snow_w > 0.3) & (slope < 50) cover = dict(meadow=meadow, scree=scree * 0.95, rock=cliff * 1.1 + 0.3 * wallt + 0.2 * (behind > 0), snow=snow_m.astype(float) * 1.5) forest = ((slope < 22) & (r > 300) & (open_ < 0.6) & (rough > -0.05) & (Y < cy)).astype(float) cover["forest"] = forest tr = TC.scatter_trees(T, forest * 0.85, 6.0, rng, hmean=16) if trees else None extras = dict(cliff=cliff, conc=conc, apron=apron * (r < R1 + 5), gully=g, ledge=ledge.astype(float)) return Scene(T, cover, trees=tr, water=dict(level=level, flow=0.0), extras=extras, seed=seed) ''' open(p,'w').write(s) EOF cd .. && nice -n 10 python3 scratch/t_cirque_dbg.py && sed -i '' 's/target=(500,560/target=(500,600/; s/mpp=2.4/mpp=3.0/' scratch/t_cirque.py && nice -n 10 python3 scratch/t_cirque.py # output: build 2.636979818344116 30 7.507330894470215</pre></details><div class="step"><code>Read: aerial/scratch/cirque_dbg.png</code></div><div class="step"><code>Read: aerial/scratch/t_cirque.png</code></div></div>  *59. aerial/scratch/cirque_dbg.png*  *60. aerial/scratch/t_cirque.png* <div class="steps"><details class="step"><summary><code>Bash: Fix cirque cover and rock colour</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='subjects.py'; s=open(p).read() s=s.replace(''' cover = dict(meadow=meadow, scree=scree * 0.95, rock=cliff * 1.1 + 0.3 * wallt + 0.2 * (behind > 0), snow=snow_m.astype(float) * 1.5)''',''' crest = np.clip(1 - np.abs(r - R2) / 40, 0, 1) * open_ rockpatch = (rough > 0.2).astype(float) * 0.6 cover = dict(meadow=meadow, drygrass=(behind > 0) * 0.55 * (rough < 0.2), scree=scree * 0.95, rock=cliff * 1.1 + 0.6 * crest + rockpatch * (slope > 20), snow=snow_m.astype(float) * 1.5)''') open(p,'w').write(s) p='pal.py'; s=open(p).read() s=s.replace('"rock": dict(alb=(150, 142, 132), steps=6)','"rock": dict(alb=(136, 134, 136), steps=6, chroma=1.25)') s=s.replace('"scree": dict(alb=(160, 152, 140), steps=5)','"scree": dict(alb=(156, 150, 142), steps=5, chroma=1.2)') open(p,'w').write(s) EOF cd .. && sed -i '' 's/target=(500,600/target=(500,650/; s/mpp=3.0/mpp=2.4/' scratch/t_cirque.py && nice -n 10 python3 scratch/t_cirque.py # output: build 2.115165948867798 33 6.953117847442627</pre></details><div class="step"><code>Read: aerial/scratch/t_cirque.png</code></div></div>  *61. aerial/scratch/t_cirque.png* <div class="steps"><details class="step"><summary><code>Bash: Debug black region</code></summary><pre>cd ~/work/pixelart-studies/aerial && cat > scratch/dbg2.py <<'EOF' import sys; sys.path.insert(0,'lib') import numpy as np from camera import Iso from pal import LIGHTS, MAT_NAME from painter import paint from subjects import cirque sc=cirque() cam=Iso(target=(500,650,sc.T.height(500,650)),mpp=2.4,elev=30,yaw=0,w=320,h=180) img,info=paint(sc,cam,LIGHTS['afternoon'],return_canvas=True) G=info['G']; cv=info['canvas'] print('hit',G['hit'].mean(), 'mat0',(cv.mat==0).mean()) y,x=170,160 print(G['hit'][y,x], G['x'][y,x],G['y'][y,x],G['z'][y,x], cv.mat[y,x], cv.step[y,x], img[y,x]) print(np.unique(cv.mat[150:,100:200],return_counts=True)) print({k:v for k,v in MAT_NAME.items()}) EOF nice -n 10 python3 scratch/dbg2.py # output: hit 0.8411805555555556 mat0 0.15881944444444446 False 501.2 -1178.6508075688776 865.2664633523718 0 0 [0 0 0] (array([0], dtype=int32), array([3000])) {1: 'conifer', 2: 'broadleaf', 3: 'meadow', 4: 'drygrass', 5: 'rock', 6: 'scree', 7: 'snow', 8: 'water', 9: 'shallow', 10: 'sand', 11: 'wetsand', 12: 'foam', 13: 'soil', 14: 'roof', 15: 'wall', 16: 'fire', 17: 'smoke', 18: 'sky'}</pre></details><details class="step"><summary><code>Bash: Trace one missing ray</code></summary><pre>cd ~/work/pixelart-studies/aerial && cat > scratch/dbg3.py <<'EOF' import sys; sys.path.insert(0,'lib') import numpy as np from camera import Iso from subjects import cirque sc=cirque(erode=False,trees=False) T=sc.T cam=Iso(target=(500,650,T.height(500,650)),mpp=2.4,elev=30,yaw=0,w=320,h=180) O,D=cam.rays(); o=O[170,160]; d=D[170,160] print(o,d,T.H.min(),T.H.max(), T.height(500,650)) for t in np.arange(0,3000,100): p=o+d*t; print(round(t),p.round(1), round(float(T.height(p[0],p[1])),1)) EOF nice -n 10 python3 scratch/dbg3.py 2>&1 | head -40 # output: [ 501.2 -1178.65080757 863.87817447] [ 0. 0.8660254 -0.5 ] -51.79729792254097 367.03214006392614 31.19428247922547 0 [ 501.2 -1178.7 863.9] -47.3 100 [ 501.2 -1092. 813.9] -47.3 200 [ 501.2 -1005.4 763.9] -47.3 300 [ 501.2 -918.8 713.9] -47.3 400 [ 501.2 -832.2 663.9] -47.3 500 [ 501.2 -745.6 613.9] -47.3 600 [ 501.2 -659. 563.9] -47.3 700 [ 501.2 -572.4 513.9] -47.3 800 [ 501.2 -485.8 463.9] -47.3 900 [ 501.2 -399.2 413.9] -47.3 1000 [ 501.2 -312.6 363.9] -47.3 1100 [ 501.2 -226. 313.9] -47.3 1200 [ 501.2 -139.4 263.9] -47.3 1300 [501.2 -52.8 213.9] -47.3 1400 [501.2 33.8 163.9] -42.3 1500 [501.2 120.4 113.9] -32.7 1600 [501.2 207. 63.9] -18.2 1700 [501.2 293.6 13.9] -6.1 1800 [501.2 380.2 -36.1] 4.3 1900 [501.2 466.8 -86.1] 6.3 2000 [ 501.2 553.4 -136.1] 15.1 2100 [ 501.2 640. -186.1] 30.2 2200 [ 501.2 726.6 -236.1] 48.7 2300 [ 501.2 813.2 -286.1] 118.8 2400 [ 501.2 899.8 -336.1] 282.1 2500 [ 501.2 986.4 -386.1] 272.8 2600 [ 501.2 1073. -436.1] 264.5 2700 [ 501.2 1159.6 -486.1] 264.5 2800 [ 501.2 1246.2 -536.1] 264.5 2900 [ 501.2 1332.8 -586.1] 264.5</pre></details><details class="step"><summary><code>Bash: Test raymarch on plain and water terrains</code></summary><pre>cd ~/work/pixelart-studies/aerial && cat >> scratch/dbg3.py <<'EOF' print(T.raymarch(o[None],d[None])) from terrain import Terrain Wl=np.where(np.isfinite(sc.water['level']),sc.water['level'],-1e9) T2=Terrain(np.maximum(T.H,Wl),T.cell) print(T2.H.min(), T2.raymarch(o[None],d[None])) EOF nice -n 10 python3 scratch/dbg3.py 2>&1 | tail -2 # output: [1733.22851079] 9.385836212862273 [1708.83295584]</pre></details><details class="step"><summary><code>Bash: Repeat with eroded cirque</code></summary><pre>cd ~/work/pixelart-studies/aerial && sed -i '' 's/sc=cirque(erode=False,trees=False)/sc=cirque()/' scratch/dbg3.py && nice -n 10 python3 scratch/dbg3.py 2>&1 | tail -2 # output: [1736.28406462] 10.666902346828346 [inf]</pre></details><details class="step"><summary><code>Bash: Fix raymarch exit margin and tarn extent</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='lib/terrain.py'; s=open(p).read() s=s.replace("tin = np.maximum(np.minimum(ta, tb), t0); tout = np.maximum(ta, tb)","tin = np.maximum(np.minimum(ta, tb), t0); tout = np.maximum(ta, tb) + self.cell * 2 / np.maximum(np.abs(dz), 0.05)") open(p,'w').write(s) p='lib/subjects.py'; s=open(p).read() s=s.replace("tarn = (lab == lab[cj, ci]) if lab[cj, ci] else np.zeros_like(H, bool)","tarn = ((lab == lab[cj, ci]) if lab[cj, ci] else np.zeros_like(H, bool)) & (r < 160)") open(p,'w').write(s) EOF nice -n 10 python3 scratch/t_cirque.py # output: build 2.337144136428833 34 8.030943155288696</pre></details><div class="step"><code>Read: aerial/scratch/t_cirque.png</code></div></div>  *62. aerial/scratch/t_cirque.png* <div class="steps"><details class="step"><summary><code>Write: aerial/lib/tech_rock.py</code></summary><pre>"""tech_rock.py -- mountain ground from above: scree fans, cliff bands, snow fields. SCREE FAN (photos: Isfjorden talus cones, Pic de Jallouvre / Lac de Lessy, Watson River cirque; Ferrari V19 blockfields) * a fan is sorted: fine at the apex, coarse at the toe (the biggest blocks roll furthest); * from above, texture is the only thing that says 'scree': grain size in pixels grows down the fan; * it is striped along the fall line by debris channels and levees (darker lines radiating from the gully mouth); * individual blocks, once >= ~2 px, are drawn as Ferrari's stones: a light top row, a dark bottom row (the contrast is inside the stone; the mass value between stones stays flat). CLIFF BANDS (photos: Isfjorden, Cloud Peak/Glacier NP; Ferrari V14, V19) * a banded cliff from above is a stack of risers (planes, lit or shaded as one value) and ledges; * each ledge is a 1-px light line (lit lip, often snow- or grass-covered) with a dark line under it (the overhang / the riser in its own shadow) -- found against the light, lost in the dark; * gullies cut the bands as dark fall-line slots. SNOW (photos: North Cascades B&W, Neve glacier, Watson River, Marcus Merlon) * lit snow is nearly flat (one value, maybe two); all the drawing is in the SHADOWED HOLLOWS: smooth blue (sky-lit) shapes with a hard edge on the sun side and a soft reflected-light side; * the snow edge against rock is crisp; its downhill edge carries a 1-px darker lip (thickness); * near its edges rocks poke through as isolated dark pixels. """ import numpy as np from dither import threshold_map from noise import voronoi, cell_rand def paint_scree(cv, mask, G, apron, sunlit, ndl, cam, seed=0, band=None): """apron: 0 at the toe .. 1 at the apex (per pixel). Scree ramp (5): 0 gap | 1 shadow || 2 half | 3 lit | 4 top.""" h, w = mask.shape if not mask.any(): return mpp = G["mpp"] size = 0.12 + 2.4 * np.clip(1 - apron, 0, 1) ** 1.6 # clast size (m) px = size / np.maximum(mpp, 1e-3) thr = threshold_map(h, w, "blue", seed) base = np.where(sunlit, np.where(ndl > 0.45, 3, 2), 1) s = base.copy() # blocks (>= 1.6 px): world-space cells at three size classes x, y = G["x"], G["y"] for lo, hi, sc in ((1.6, 3.5, 1.0), (3.5, 7.0, 1.0), (7.0, 99, 1.0)): sel = mask & (px >= lo) & (px < hi) if not sel.any(): continue cs = float(np.median(size[sel])) F1, F2, cid, cx, cy = voronoi(x[sel], y[sel], seed=seed + int(lo * 10), scale=cs) edge = (F2 - F1) < 0.18 * cs # the gap between stones rel_y = (y[sel] - cy) / cs # +: far (upper) part of the stone on screen top = rel_y > 0.12 bot = rel_y < -0.22 v = cell_rand(cid, 1) lit = sunlit[sel] st = np.where(lit, 2 + (v > 0.35), 1 - (v > 0.8)) st = np.where(top & lit, np.minimum(st + 1, 4), st) st = np.where(bot, np.maximum(st - 1 - lit, 0), st) st = np.where(edge, 0, st) tmp = s[sel]; tmp[:] = st; s[sel] = tmp # grain (< 1.6 px): stipple whose density grows with clast size, plus fall-line channels fine = mask & (px < 1.6) dens = np.clip(px * 0.22, 0.04, 0.35) s = np.where(fine & (thr < dens * 0.5), np.maximum(base - 1, 0), s) s = np.where(fine & (thr > 1 - dens * 0.5) & sunlit, np.minimum(base + 1, 4), s) # debris channels: thin darker streaks along the fall line (world-space stripes across the fan) n = G["n"] ang = np.arctan2(n[..., 1], n[..., 0]) # downslope azimuth stripe = np.sin((x * np.sin(ang) - y * np.cos(ang)) / 3.0 + 3 * np.sin(y / 23.0 + x / 31.0)) ch = mask & (stripe > 0.93) & (apron > 0.15) s = np.where(ch, np.maximum(s - 1, 0), s) cv.fill(mask, "scree", s, band=band) def paint_cliffs(cv, rockmask, G, ledge, snowy, cam, band=None): """ledge lines on a banded cliff: a lit lip on each ledge pixel row and a dark line under it.""" h, w = rockmask.shape L = rockmask & ledge below = np.zeros_like(L); below[1:] = L[:-1] # the pixel just under a ledge pixel top_of_riser = rockmask & below & ~L st = cv.step.copy() # lip: rock top step, or snow if the ledge is snowy lip = L & ~snowy cv.step[lip] = np.clip(st[lip] + 1, 0, 5) cv.step[top_of_riser] = 0 sn = L & snowy if sn.any(): cv.fill(sn, "snow", 4, band=band) def paint_snow(cv, mask, G, sunlit, ndl, conc, seed=0, band=None): """snow ramp (6): 0 crevasse/contact | 1 hollow core | 2 reflected || 3 half | 4 lit | 5 glare.""" h, w = mask.shape thr = threshold_map(h, w, "bayer4") # lit snow: two flat values only (lit / glare on sun-facing) s = np.where(ndl > 0.55, 5, 4) s = np.where(ndl < 0.2, 3, s) # shadowed hollows: core near the terminator, reflected light deeper in (from the lit snow opposite) sh = ~sunlit core = sh & (ndl > -0.25) # just past the terminator s = np.where(sh, np.where(core, 1, 2), s) # hollows that the sun still reaches but are concave: a half step down (the shape of the hollow) s = np.where(~sh & (conc < -1.5) & (s >= 4) & (thr < 0.5), 3, s) # edges: crisp; downhill lip darker; rocks poking through near edges lower = np.zeros_like(mask); lower[:-1] = mask[1:] lip = mask & ~lower s = np.where(lip, np.where(sunlit, 3, 1), s) edge_zone = mask & ~(np_erode(mask, 2)) tb = threshold_map(h, w, "blue", seed + 9) poke = edge_zone & (tb < 0.12) cv.fill(mask, "snow", s, band=band) cv.fill(poke, "rock", np.where(sunlit, 2, 0)[poke] if False else 1, band=band) def np_erode(m, it): from scipy import ndimage as ndi return ndi.binary_erosion(m, iterations=it) </pre></details><details class="step"><summary><code>Bash: Hook scree, cliff, snow techniques into painter</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_rock.py'; s=open(p).read() s=s.replace('cv.fill(poke, "rock", np.where(sunlit, 2, 0)[poke] if False else 1, band=band)','cv.fill(poke, "rock", 1, band=band)') open(p,'w').write(s) p='painter.py'; s=open(p).read() s=s.replace(''' cv.fill(m, name, s, band=band) ''',''' cv.fill(m, name, s, band=band) G["mask_" + name] = m # ---- mountain techniques on top of the plain slope tone import tech_rock as TR lit_all = (ndl > 0.06) & (sunvis > 0.5) ex = sc.extras if "mask_scree" in G: apr = T0.sample(ex["apron"], G["x"], G["y"]) if "apron" in ex else np.full((h, w), 0.5) TR.paint_scree(cv, G["mask_scree"], G, apr, lit_all, ndl, cam, seed=seed, band=band) if "mask_rock" in G and "ledge" in ex: led = T0.sample(ex["ledge"], G["x"], G["y"]) > 0.5 snowy = T0.sample(sc.cover.get("snow", np.zeros_like(T0.H)), G["x"], G["y"]) > 0.3 TR.paint_cliffs(cv, G["mask_rock"], G, led, snowy, cam, band=band) if "mask_snow" in G: cc_s = T0.sample(ex["conc"], G["x"], G["y"]) if "conc" in ex else np.zeros((h, w)) TR.paint_snow(cv, G["mask_snow"], G, lit_all, ndl, cc_s, seed=seed, band=band) ''') open(p,'w').write(s) p='subjects.py'; s=open(p).read() s=s.replace("+ 0.25 * rough - 0.9 + 0.3 * np.clip(behind / 60, 0, 1)","+ 0.25 * rough - 0.75 + 0.3 * np.clip(behind / 60, 0, 1) + 0.25 * np.clip(-conc / 4, 0, 1)") open(p,'w').write(s) EOF cd .. && nice -n 10 python3 scratch/t_cirque.py # output: build 2.5459511280059814 34 8.474989175796509</pre></details><div class="step"><code>Read: aerial/scratch/t_cirque.png</code></div></div>  *63. aerial/scratch/t_cirque.png* <div class="steps"><details class="step"><summary><code>Bash: Material fractions debug</code></summary><pre>cd ~/work/pixelart-studies/aerial && cat > scratch/dbg4.py <<'EOF' import sys; sys.path.insert(0,'lib') import numpy as np from PIL import Image from camera import Iso from pal import LIGHTS, MAT_NAME from painter import paint from subjects import cirque from look import * sc=cirque() cam=Iso(target=(500,650,sc.T.height(500,650)),mpp=2.4,elev=30,yaw=0,w=320,h=180) img,info=paint(sc,cam,LIGHTS['afternoon'],return_canvas=True) cv=info['canvas'] u,c=np.unique(cv.mat,return_counts=True); print({MAT_NAME.get(k,k):round(v/cv.mat.size,3) for k,v in zip(u,c)}) rng=np.random.default_rng(0); cols=rng.integers(0,255,(20,3)).astype(np.uint8) up(Image.fromarray(cols[cv.mat]),2).save('scratch/matmap.png') s=sc.T.slope_deg(); print('slope pct', np.percentile(s,[50,75,90,97])) print('snow cover frac', (sc.cover['snow']>0.5).mean(), 'ledge', sc.extras['ledge'].mean(), 'scree', (sc.cover['scree']>0.5).mean()) EOF nice -n 10 python3 scratch/dbg4.py # output: {'conifer': 0.024, 'meadow': 0.236, 'drygrass': 0.037, 'rock': 0.54, 'scree': 0.118, 'snow': 0.02, 'water': 0.025} slope pct [27.31481492 47.00379224 63.5059925 73.16081703] snow cover frac 0.1252584651057167 ledge 0.0013665284202054972 scree 0.06790809598368135</pre></details><div class="step"><code>Read: aerial/scratch/matmap.png</code></div></div>  *64. aerial/scratch/matmap.png* <div class="steps"><details class="step"><summary><code>Bash: Cirque: less erosion, ledge phase, scree priority</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='subjects.py'; s=open(p).read() s=s.replace(''' H = H * (1 - 0.7 * wk) + Ht * 0.7 * wk''',''' H = H * (1 - 0.7 * wk) + Ht * 0.7 * wk phase = (H / band) % 1.0 ledge0 = (wk > 0.35) & (phase < 0.22)''') s=s.replace("H += 16 * LF.eroded_fbm(X, Y, 260, octaves=6, seed=seed) * (0.3 + wallt) + 2 * LF.fbm(X, Y, 25, seed=seed + 5)", "H += 10 * LF.eroded_fbm(X, Y, 260, octaves=6, seed=seed) * (0.15 + wallt) + 1.5 * LF.fbm(X, Y, 25, seed=seed + 5)") s=s.replace("H = LF.droplet_erosion(H, cell, n_drops=120000, seed=seed)","H = LF.droplet_erosion(H, cell, n_drops=40000, seed=seed)") s=s.replace("cliff = ((slope > 40) | ((wk > 0.3) & (slope > 30))).astype(float)\n ledge = (wk > 0.3) & (slope < 30)", "cliff = ((slope > 44) | ((wk > 0.3) & (slope > 32))).astype(float)\n ledge = ledge0") s=s.replace("scree = ((apron > 0.05) & (apron < 1.0) & (r < R1 + 5) & (slope > 12)).astype(float) * open_", "scree = ((apron > 0.02) & (r < R1 + 5) & (slope > 10) & (slope < 48)).astype(float) * np.clip(open_ * 1.5, 0, 1) * 1.4") open(p,'w').write(s) EOF cd .. && nice -n 10 python3 scratch/dbg4.py && nice -n 10 python3 scratch/t_cirque.py # output: {'conifer': 0.022, 'meadow': 0.228, 'drygrass': 0.077, 'rock': 0.454, 'scree': 0.147, 'snow': 0.047, 'water': 0.024} slope pct [27.48249731 42.66368635 59.04583586 68.57434674] snow cover frac 0.14159306138222558 ledge 0.04073290544659185 scree 0.06294397233477157 build 1.8178160190582275 34 9.507974863052368</pre></details><div class="step"><code>Read: aerial/scratch/t_cirque.png</code></div></div>  *65. aerial/scratch/t_cirque.png* <div class="steps"><details class="step"><summary><code>Bash: Find mountain reference files</code></summary><pre>cd ~/work/pixelart-studies/aerial && ls refs/talus_fan_mountain refs/scree_slope_from_above refs/glacial_cirque_tarn_aerial refs/cirque_lake_snow_mountain_from_above refs/aerial_view_snowfield_mountain | grep -v sources | grep -iE "isfj|scree_slope|ice_cubes|neve|unident|marcus|jallou|watson|backed" # output: commons_Neve_Glacier_North_Cascades_USGS_jpg_39b02357.jpg openverse_Marcus_Merlon_9dfe041f.jpg commons_Unidentified_alpine_lake_and_in_the_North_Cascad_4446f031.jpg commons_Backed_up_Against_the_Wall_jpg_09c2a7a3.jpg openverse_Ice_Cubes_b27d8526.jpg refs/scree_slope_from_above: commons_Scree_Slope_geograph_org_uk_3150164_jpg_e8e5c39c.jpg commons_Scree_slope_above_the_Offa_s_Dyke_Path_geograph__044fd096.jpg commons_Pic_de_Jallouvre_Lac_de_Lessy_jpg_864870ba.jpg commons_TalusConesIsfjorden_jpg_5b61cbaf.jpg</pre></details><details class="step"><summary><code>Bash: Check second batch refs</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs && pgrep -f imgfetch >/dev/null && echo running; ls -d */ | wc -l; ls talus_cone_aerial scree_fan_mountain_drone rock_glacier_aerial_view snow_gully_mountain_aerial helicopter_view_mountain_snow 2>/dev/null | head -60 # output: 45 helicopter_view_mountain_snow: _sheet.jpg openverse_1044e_Goat_Lake_mountain_top_high_9e9de182.jpg openverse_Aerial_View_of_Switzerland_s_Fast_Decreasing_Gla_cb375c6b.jpg openverse_Back_To_Wanaka_228bfea3.jpg openverse_California_Army_National_Guard_Chinook_crew_work_30586afc.jpg openverse_Exploring_The_Mount_Aspiring_Area_0496fad6.jpg openverse_Grand_Canyon_DEIS_Aerial_Colorado_River_Geikie_P_ba028cd7.jpg openverse_Grand_Canyon_DEIS_Aerial_Geikie_Peak_Scorpion_Ri_e07fab54.jpg openverse_Hopeful_36cd17ac.jpg openverse_Northern_Constabulary_Off_road_vehicles_ATV_Moun_0718268c.jpg openverse_Northern_Constabulary_Off_road_vehicles_ATV_Moun_fa555a3c.jpg openverse_On_Top_of_the_Remarables_d6c514e7.jpg openverse_Upper_Yosemite_Fall_in_the_Morning_California_cfadca28.jpg sources.tsv rock_glacier_aerial_view: _sheet.jpg openverse_2018_06_16_lhr_ewr_111_42569fe9.jpg openverse_2018_06_16_lhr_ewr_163_e2e523aa.jpg openverse_Additional_view_of_South_Tahoma_Glacier_terminus_c68444e3.jpg openverse_Additional_view_of_South_Tahoma_Glacier_terminus_cc8f13d3.jpg openverse_B_a_s_09e02b64.jpg openverse_Enchanted_Valley_in_the_Olympic_Mountains_at_Whi_0ef64688.jpg openverse_Landsat_Images_Land_on_US_Postal_Stamps_c82bf7b7.jpg openverse_Landsat_Images_Land_on_US_Postal_Stamps_e848e527.jpg openverse_Marcus_Merlon_9dfe041f.jpg openverse_Mountains_as_Far_as_the_Eye_Can_See_576ee22e.jpg openverse_Road_to_Lion_Head_Rock_ea5e5fd9.jpg sources.tsv scree_fan_mountain_drone: _sheet.jpg openverse_Alluvial_fan_in_the_valley_6d0c1877.jpg openverse_Debris_apron_from_rockfall_at_Brass_Point_East_S_9991bf9c.jpg openverse_Mount_Ngauruhoe_s_inner_crater_New_Zealand_5eaa3b44.jpg openverse_Rock_outcrops_Tyle_Du_4f6a34d7.jpg sources.tsv snow_gully_mountain_aerial: _sheet.jpg openverse_2015_Washington_State_Washington_Pass_Overlook_3b656acd.jpg openverse_BISHOP_S_HEADDRESS_Mitre_Peak_Concordia_Pakistan_36728096.jpg openverse_Eruption_of_Eyjafjallaj_kull_Volcano_Iceland_cfbeaf18.jpg openverse_Gardyloo_Gully_in_November_8d005472.jpg openverse_Huanglong_a_taoist_temple_nested_in_the_mountain_6740efe9.jpg openverse_Judge_Howay_Summit_Detail_a11ae099.jpg openverse_North_Suicide_Peak_Chugach_State_Park_Alaska_fe5146e3.jpg openverse_Rivers_and_Snow_in_the_Himalayas_China_and_India_2c4fc8c7.jpg openverse_THE_KINGS_HOUSE_IN_GLENCOE_f8b97d2c.jpg openverse_View_of_Ash_Plume_at_Eyjafjallaj_kull_Volcano_019641ba.jpg sources.tsv talus_cone_aerial: _sheet.jpg openverse_09_03_Broadleaved_Mainly_Betula_scrub_on_talus_c_defb9811.jpg openverse_Glaciar_rocoso_Valle_de_Marinet_Saint_Paul_sur_U_62bf8f78.jpg openverse_Glaciares_rocosos_Rochers_de_Lanserlia_Termignon_af5ace07.jpg openverse_Talus_cone_Canyon_de_Chelly_National_Monument_Ar_523431b7.jpg openverse_Talus_cone_Canyon_de_Chelly_National_Monument_Ar_f4387c7e.jpg</pre></details><div class="step"><code>Read: aerial/refs/talus_cone_aerial/_sheet.jpg</code></div></div>  *66. aerial/refs/talus_cone_aerial/_sheet.jpg* <div class="steps"><div class="step"><code>Read: aerial/refs/scree_fan_mountain_drone/_sheet.jpg</code></div></div>  *67. aerial/refs/scree_fan_mountain_drone/_sheet.jpg* <div class="steps"><details class="step"><summary><code>Write: aerial/study_mountain.py</code></summary><pre>"""study_mountain.py -- scree fan from above, cliff bands with ledges, snow fields read by their shadowed hollows; each beside a photo at the same pixel scale and the nearest Ferrari. nice -n 10 python3 study_mountain.py -> studies/scree.png, studies/cliff_snow.png """ import os, sys sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib")) import numpy as np from PIL import Image from camera import Iso from pal import LIGHTS from painter import paint from subjects import cirque import study as S ROOT = os.path.dirname(os.path.abspath(__file__)) R = lambda p: os.path.join(ROOT, "refs", p) FER = lambda n: os.path.join(ROOT, "refs/ferrari_lw", n + ".png") CHELLY = R("talus_cone_aerial/openverse_Talus_cone_Canyon_de_Chelly_National_Monument_Ar_f4387c7e.jpg") ISFJ = R("talus_fan_mountain/commons_TalusConesIsfjorden_jpg_5b61cbaf.jpg") CASC = R("cirque_lake_snow_mountain_from_above/commons_Unidentified_alpine_lake_and_in_the_North_Cascad_4446f031.jpg") NEVE = R("aerial_view_snowfield_mountain/commons_Neve_Glacier_North_Cascades_USGS_jpg_39b02357.jpg") W, H = 96, 64 def best_point(sc, key, near, rad=150): """a world point near `near` where cover/extras `key` is strongest (to frame a study).""" F = sc.cover.get(key, sc.extras.get(key)) T = sc.T j0, i0 = int(near[1] / T.cell), int(near[0] / T.cell); r = int(rad / T.cell) sub = F[max(0, j0 - r):j0 + r, max(0, i0 - r):i0 + r] from scipy import ndimage as ndi sm = ndi.uniform_filter(sub.astype(float), 15) j, i = np.unravel_index(np.argmax(sm), sm.shape) return (max(0, i0 - r) + i) * T.cell, (max(0, j0 - r) + j) * T.cell def shot(sc, pt, mpp, light="afternoon"): cam = Iso(target=(pt[0], pt[1], sc.T.height(*pt)), mpp=mpp, elev=30, yaw=0, w=W, h=H) img, info = paint(sc, cam, LIGHTS[light]) return Image.fromarray(img), info["colours"] def crop_fit(path, box): im = Image.open(path) return (box[0], box[1], min(box[2], im.size[0]), min(box[3], im.size[1])) def run(): sc = cirque(seed=3, snow=0.5) rows = [] # scree, two scales pt = best_point(sc, "scree", (500, 740)) for mpp, cap in ((0.5, "0.5 m/px: toe blocks (light top row / dark bottom row)"), (1.2, "1.2 m/px: grain stipple sorted down the fan + fall-line channels")): a, n = shot(sc, (pt[0], pt[1] - 20 * mpp), mpp) p = S.px_photo(CHELLY, crop_fit(CHELLY, (0, 380, 680, 833)), W) if mpp < 1 else S.px_photo(ISFJ, crop_fit(ISFJ, (150, 180, 870, 660)), W) f = Image.open(FER("V19")).convert("RGB").crop((230, 250, 230 + W, 250 + H)) rows.append(S.panel("scree fan, " + cap, [p, a, f], ["photo (Canyon de Chelly talus)" if mpp < 1 else "photo (Isfjorden talus cones)", f"mine ({n} colours)", "Ferrari V19 blockfield"])) out = S.stack(rows); out.save(os.path.join(ROOT, "studies", "scree.png")); print("studies/scree.png") rows = [] pt = best_point(sc, "ledge", (760, 680), rad=200) a, n = shot(sc, pt, 1.2) p = S.px_photo(CASC, crop_fit(CASC, (0, 0, 700, 467)), W) f = Image.open(FER("V19")).convert("RGB").crop((440, 60, 440 + W, 60 + H)) rows.append(S.panel("cliff bands, 1.2 m/px: risers as planes, each ledge a lit lip over a dark line, snow on ledges", [p, a, f], ["photo (North Cascades, B&W)", f"mine ({n})", "Ferrari V19 rock + snow ledges"])) pt = best_point(sc, "snow", (500, 820), rad=250) a, n = shot(sc, pt, 1.2) p = S.px_photo(NEVE, crop_fit(NEVE, (100, 250, 700, 650)), W) f = Image.open(FER("V17")).convert("RGB").crop((0, 200, W, 200 + H)) rows.append(S.panel("snow fields, 1.2 m/px: lit snow flat; all drawing in the blue shadowed hollows; crisp edges", [p, a, f], ["photo (Neve Glacier, B&W)", f"mine ({n})", "Ferrari V17 snow"])) out = S.stack(rows); out.save(os.path.join(ROOT, "studies", "cliff_snow.png")); print("studies/cliff_snow.png") if __name__ == "__main__": run() </pre></details><details class="step"><summary><code>Bash: Run mountain studies</code></summary><pre>cd ~/work/pixelart-studies/aerial && nice -n 10 python3 study_mountain.py # output: Exit code 1 studies/scree.png Traceback (most recent call last): File "~/work/pixelart-studies/aerial/study_mountain.py", line 78, in <module> run() File "~/work/pixelart-studies/aerial/study_mountain.py", line 71, in run f = Image.open(FER("V17")).convert("RGB").crop((0, 200, W, 200 + H)) ^^^^^^^^^^^^^^^^^^^^^^ File "~/miniconda3/lib/python3.12/site-packages/PIL/Image.py", line 3465, in open fp = builtins.open(filename, "rb") ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FileNotFoundError: [Errno 2] No such file or directory: '~/work/pixelart-studies/aerial/refs/ferrari_lw/V17.png'</pre></details><details class="step"><summary><code>Bash: Fetch missing Ferrari scenes and rerun</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs/ferrari_lw && for n in V17 V26SNOW V29 V19PM V16PM V01; do [ -f $n.png ] || { curl -sL -m 60 -o $n.json "https://www.effectgames.com/demos/canvascycle/images/$n.LBM.json"; }; done; cd .. && python3 - <<'EOF' import re,json,glob,numpy as np,os from PIL import Image for f in sorted(glob.glob('ferrari_lw/*.json')): if os.path.exists(f.replace('.json','.png')): continue t=open(f).read(); t=re.sub(r'([{,])\s*([A-Za-z_]+)\s*:', r'\1"\2":', t).replace("'",'"') d=json.loads(t); pal=np.array(d['colors'],dtype=np.uint8); px=np.array(d['pixels']).reshape(d['height'],d['width']) Image.fromarray(pal[px]).save(f.replace('.json','.png')); print(f) EOF cd .. && nice -n 10 python3 study_mountain.py # output: ferrari_lw/V16PM.json ferrari_lw/V17.json ferrari_lw/V19PM.json ferrari_lw/V26SNOW.json studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/studies/scree.png</code></div></div>  *68. aerial/studies/scree.png* <div class="steps"><details class="step"><summary><code>Bash: Revise scree block and channel marks</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_rock.py'; s=open(p).read() start=s.index(' # blocks (>= 1.6 px)'); end=s.index(' cv.fill(mask, "scree", s, band=band)') new=''' # blocks (>= 1.6 px): world-space cells at three size classes. Not every cell is a block: a # share proportional to how coarse the fan is here (the rest stays matrix grain), so the hand-off # from grain to blocks is a density ramp, not a line. x, y = G["x"], G["y"] sx = float(np.sign(np.dot(G.get("sun", np.array([-1.0, 0, 0])), [1, 0, 0])) or -1) for lo, hi in ((1.2, 3.0), (3.0, 6.0), (6.0, 99)): sel = mask & (px >= lo * 0.8) & (px < hi) if not sel.any(): continue cs = float(np.median(size[sel])) F1, F2, cid, cx, cy = voronoi(x[sel], y[sel], seed=seed + int(lo * 10), scale=cs) v = cell_rand(cid, 1); v2 = cell_rand(cid, 2) share = np.clip((px[sel] - lo * 0.8) / (lo * 0.8), 0, 1) * 0.75 isblock = v2 < share inner = (F2 - F1) > 0.22 * cs rel_y = (y[sel] - cy) / cs; rel_x = (x[sel] - cx) / cs * sx # + = toward the sun side lit = sunlit[sel] st = np.where(lit, 2 + (v > 0.45), 1) st = np.where((rel_y > 0.15) | (rel_x > 0.25), np.where(lit, np.minimum(st + 1, 4), 2), st) # top/sun-side lip st = np.where((rel_y < -0.25) | (rel_x < -0.35), np.where(lit, 1, 0), st) # underside / shade side st = np.where(~inner, np.where(lit, 1, 0), st) # the joint between stones cur = s[sel] s[sel] = np.where(isblock, st, cur) # grain: stipple whose density grows with clast size fine = mask dens = np.clip(px * 0.22, 0.04, 0.3) s = np.where(fine & (s == base) & (thr < dens * 0.5), np.maximum(base - 1, 0), s) s = np.where(fine & (s == base) & (thr > 1 - dens * 0.5) & sunlit, np.minimum(base + 1, 4), s) # debris channels: a dark fall-line groove with a light levee beside it (contrast in the stroke) n = G["n"] ang = np.arctan2(n[..., 1], n[..., 0]) ph = (x * np.sin(ang) - y * np.cos(ang)) / 2.2 + 2.5 * np.sin(y / 23.0 + x / 31.0) stripe = np.sin(ph) ch = mask & (stripe > 0.9) & (apron > 0.12) & (np.cos(ph / 3.1) > 0.2) lev = mask & (stripe < -0.9) & (apron > 0.12) & (np.cos(ph / 3.1) > 0.2) & sunlit s = np.where(ch, np.maximum(s - 1, 0), s) s = np.where(lev, np.minimum(s + 1, 4), s) ''' s=s[:start]+new+s[end:] open(p,'w').write(s) p='painter.py'; s=open(p).read() s=s.replace(" G.update(sunvis=sunvis, ndl=ndl, skyview=skyview, band=band)"," G.update(sunvis=sunvis, ndl=ndl, skyview=skyview, band=band, sun=sun)") open(p,'w').write(s) EOF cd .. && nice -n 10 python3 study_mountain.py # output: studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/studies/scree.png</code></div><div class="step"><code>Read: aerial/studies/cliff_snow.png</code></div></div>  *69. aerial/studies/scree.png*  *70. aerial/studies/cliff_snow.png* <div class="steps"><details class="step"><summary><code>Bash: Rock facets and snowy ledge strips</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cat >> landform.py <<'EOF' def facets(X, Y, scale, seed=0, tilt=0.6): """planar facet field: every Voronoi cell is a tilted plane (height relative to its centre), so rock surfaces break into flat faces with sharp edges -- Ferrari's 'rock is planes'.""" from noise import voronoi, cell_rand F1, F2, cid, cx, cy = voronoi(X, Y, seed=seed, scale=scale) a = (cell_rand(cid, 3) - 0.5) * 2 * tilt; b = (cell_rand(cid, 4) - 0.5) * 2 * tilt c = (cell_rand(cid, 5) - 0.5) * scale * 0.3 return a * (X - cx) + b * (Y - cy) + c EOF python3 - <<'EOF' p='subjects.py'; s=open(p).read() s=s.replace(" phase = (H / band) % 1.0\n"," H += 1.0 * LF.facets(X, Y, 26, seed=seed + 21, tilt=0.55) * np.clip(wallt * 3, 0, 1) * open_\n phase = (H / band) % 1.0\n") open(p,'w').write(s) p='tech_rock.py'; s=open(p).read() start=s.index('def paint_cliffs'); end=s.index('def paint_snow') s=s[:start]+'''def paint_cliffs(cv, rockmask, G, ledge, snowy, cam, band=None): """cliff bands: every ledge is a strip -- snow (lit 4 / shaded 2) or a lit rock lip -- and the first pixel of the riser under it is the darkest rock step (the overhang in its own shadow).""" h, w = rockmask.shape L = rockmask & ledge below = np.zeros_like(L); below[1:] = L[:-1] top_of_riser = rockmask & below & ~L lit = G["sunvis"] > 0.5 st = cv.step.copy() lip = L & ~snowy cv.step[lip] = np.clip(np.maximum(st[lip] + 1, 3), 0, 5) cv.step[top_of_riser] = 0 sn = L & snowy if sn.any(): cv.fill(sn, "snow", np.where(lit, 4, 2), band=band) # the snow strip's front edge: one step down (its thickness catching less light) low = np.zeros_like(sn); low[:-1] = sn[1:] edge = sn & ~low cv.fill(edge, "snow", np.where(lit, 3, 1), band=band) '''+s[end:] open(p,'w').write(s) EOF echo ok # output: ok</pre></details><details class="step"><summary><code>Bash: Add sky and rerun mountain study</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='painter.py'; s=open(p).read() s=s.replace(''' pal = Palette(light) img, ncol = pal.render(cv.mat, cv.step, cv.band)''',''' # ---- sky (and the void of an iso frame beyond the terrain): flat bands, seams dithered miss = ~G["hit"] & (cv.mat == 0) sky_rgb = None if miss.any(): from dither import flat_bands el = np.arcsin(np.clip(G["D"][..., 2], -1, 1)) xsky = np.clip(el / np.radians(35), 0, 1) * 7.0 cv.fill(miss, "sky", flat_bands(xsky, thr_4, 0.3), band=0) tcol = np.linspace(0, 1, 8)[:, None] sky_rgb = light.sky_hor[None] * (1 - tcol) + light.sky_top[None] * tcol pal = Palette(light) img, ncol = pal.render(cv.mat, cv.step, cv.band, sky_rgb=sky_rgb)''') open(p,'w').write(s) EOF cd .. && nice -n 10 python3 study_mountain.py # output: studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/studies/cliff_snow.png</code></div></div>  *71. aerial/studies/cliff_snow.png* <div class="steps"><details class="step"><summary><code>Bash: Rock contrast, ledge, snow coherence fixes</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='painter.py'; s=open(p).read() s=s.replace('s = TG.fall_line_flecks(s, m, G, threshold_map(h, w, "blue", seed + 5), density=0.08, lit_ok=lit)','s = TG.fall_line_flecks(s, m, G, threshold_map(h, w, "blue", seed + 5), density=0.035, lit_ok=lit)') open(p,'w').write(s) p='tech_rock.py'; s=open(p).read() s=s.replace(" cv.step[top_of_riser] = 0\n sn = L & snowy"," cv.step[top_of_riser] = np.maximum(cv.step[top_of_riser] - 1, 0)\n sn = L & snowy") s=s.replace("poke = edge_zone & (tb < 0.12)","poke = edge_zone & (tb < 0.04)") open(p,'w').write(s) p='subjects.py'; s=open(p).read() s=s.replace(" snow_m = (snow_w > 0.3) & (slope < 50)"," snow_w = ndi.gaussian_filter(snow_w, 2.0)\n snow_m = (snow_w > 0.3) & (slope < 52)") open(p,'w').write(s) p='pal.py'; s=open(p).read() s=s.replace('"rock": dict(alb=(136, 134, 136), steps=6, chroma=1.25)','"rock": dict(alb=(128, 124, 126), steps=6, chroma=1.35, walk=24)') s=s.replace('"scree": dict(alb=(156, 150, 142), steps=5, chroma=1.2)','"scree": dict(alb=(148, 142, 136), steps=5, chroma=1.3, walk=20)') s=s.replace('"snow": dict(alb=(245, 247, 250), steps=6)','"snow": dict(alb=(245, 247, 250), steps=6, chroma=1.3)') open(p,'w').write(s) EOF echo done # output: done</pre></details><details class="step"><summary><code>Bash: Talus cone subject for scree study</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cat >> subjects.py <<'EOF' def talus_cone(size=220, cell=0.5, seed=4, L=90.0): """one talus cone under a gully in a cliff, on a meadow: the scree study's controlled subject. apron = 1 at the apex (gully mouth) .. 0 at the toe.""" X, Y = grid(size, size, cell) cx, yc = size * 0.5, size * 0.62 # cliff foot line (y) and gully x # cliff: rises steeply north of yc, notched by a gully at cx gul = np.exp(-0.5 * ((X - cx) / 7.0) ** 2) cliffH = np.clip(Y - yc + 6 * gul, 0, None) * 2.2 cliffH += 1.0 * LF.facets(X, Y, 9, seed=seed + 1, tilt=0.5) * (Y > yc) # cone: apex at (cx, yc + 4) at height 0.62*L, falling at ~32 deg radially d = np.hypot(X - cx, (Y - yc - 4) * 1.0) apron = np.clip(1 - d / L, 0, 1) * (Y < yc + 10) cone = 0.62 * L * apron ** 1.15 H = np.maximum(cliffH, cone) + 0.02 * Y + 0.4 * LF.fbm(X, Y, 8, seed=seed + 2) T = Terrain(H, cell) slope = T.slope_deg() scree = (apron > 0.01) & (cliffH < cone + 0.5) rock = (cliffH >= cone + 0.5) & (slope > 35) cover = dict(meadow=np.full_like(H, 0.5), scree=scree * 1.2, rock=rock * 1.3 + (Y > yc + 2) * 0.6) rng = np.random.default_rng(seed) n = 18 tx = rng.uniform(0, size, n); ty = rng.uniform(0, yc - 20, n) keep = np.hypot(tx - cx, ty - yc) > L * 1.05 tr = dict(x=tx[keep], y=ty[keep]); tr["z"] = T.height(tr["x"], tr["y"]) tr["h"] = rng.uniform(10, 18, keep.sum()); tr["w"] = tr["h"] * 0.4 tr["kind"] = np.zeros(keep.sum(), int); tr["seed"] = rng.integers(0, 1 << 20, keep.sum()) return Scene(T, cover, trees=tr, extras=dict(apron=apron), seed=seed) EOF cd .. && python3 - <<'EOF' p='study_mountain.py'; s=open(p).read() s=s.replace("from subjects import cirque","from subjects import cirque, talus_cone") s=s.replace(''' pt = best_point(sc, "scree", (500, 740)) for mpp, cap in ((0.5, "0.5 m/px: toe blocks (light top row / dark bottom row)"), (1.2, "1.2 m/px: grain stipple sorted down the fan + fall-line channels")): a, n = shot(sc, (pt[0], pt[1] - 20 * mpp), mpp)''',''' tc = talus_cone() for mpp, cap in ((0.5, "0.5 m/px, one cone: sorted fine at the apex -> blocks at the toe"), (1.2, "1.2 m/px: grain stipple sorted down the fan + fall-line channels")): a, n = shot(tc, (110, 110 + 8 * mpp), mpp)''') open(p,'w').write(s) EOF nice -n 10 python3 study_mountain.py # output: studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/studies/scree.png</code></div></div>  *72. aerial/studies/scree.png* <div class="steps"><details class="step"><summary><code>Bash: Frame the toe and print rock ramps</code></summary><pre>cd ~/work/pixelart-studies/aerial && sed -i '' 's/a, n = shot(tc, (110, 110 + 8 \* mpp), mpp)/a, n = shot(tc, (110, 78 if mpp < 1 else 110), mpp)/' study_mountain.py && python3 -c " import sys; sys.path.insert(0,'lib') from pal import * for m in ['rock','scree','snow']: r=material_ramp(m,LIGHTS['afternoon']); print(m,[tuple(int(v) for v in c) for c in r], [round(x) for x in lab(r)[:,0]])" && nice -n 10 python3 study_mountain.py # output: rock [(32, 29, 43), (63, 61, 77), (83, 86, 105), (108, 107, 119), (141, 134, 139), (182, 168, 168)] [12, 27, 37, 46, 57, 70] scree [(35, 36, 47), (97, 99, 111), (125, 122, 126), (163, 151, 147), (210, 187, 177)] [15, 42, 52, 64, 78] snow [(59, 71, 95), (116, 129, 154), (155, 170, 200), (197, 203, 221), (245, 243, 249), (254, 255, 254)] [30, 54, 69, 82, 96, 100] studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/studies/scree.png</code></div></div>  *73. aerial/studies/scree.png* <div class="steps"><details class="step"><summary><code>Bash: Replace voronoi blocks with stone sprites</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_rock.py'; s=open(p).read() # remove voronoi block section: keep grain & channels start=s.index(' # blocks (>= 1.6 px)'); end=s.index(' # grain: stipple') s=s[:start]+s[end:] s=s.replace("dens = np.clip(px * 0.22, 0.04, 0.3)","dens = np.clip(px * 0.15, 0.04, 0.2)") s+=''' def stone_sprite(w, lit, side): """Ferrari's stone: a flat lit top row with its ends cut at 45 deg, a mid body, a dark bottom row; the sun-side end one step lighter, the shade-side end one step darker. Scree ramp steps.""" w = max(2, int(w)); h = max(2, int(round(w * 0.65))) a = np.ones((h + 1, w + 1), bool); st = np.zeros((h + 1, w + 1), np.int32) a[:, w] = False; a[h, :] = False top, mid, bot = (4, 3, 1) if lit else (2, 1, 0) for y in range(h): for x in range(w): if y == 0 and (x == 0 or x == w - 1) and w >= 3: a[y, x] = False; continue # 45-deg ends st[y, x] = top if y == 0 else (bot if y == h - 1 else mid) if (x == w - 1 and side > 0) or (x == 0 and side < 0): st[y, x] = min(st[y, x] + 1, 4) if y < h - 1 else st[y, x] if (x == 0 and side > 0) or (x == w - 1 and side < 0): st[y, x] = max(st[y, x] - 1, 0) # cast shadow: one pixel of dark matrix on the shade side, at the base sx = w if side > 0 else 0 if side < 0: a[h - 1, w] = True; st[h - 1, w] = 0 else: a = np.pad(a, ((0, 0), (1, 0))); st = np.pad(st, ((0, 0), (1, 0))) a[h - 1, 0] = True; st[h - 1, 0] = 0 from pal import MAT_ID return dict(a=a, mat=np.full(a.shape, MAT_ID["scree"]), step=st, ax=a.shape[1] / 2, ay=h - 1) def scatter_blocks(T, scree, apron, rng, max_size=2.6, spacing=None): """blocks on a talus: size grows toward the toe, coverage 0 at the apex -> ~45% at the toe.""" spacing = spacing or max_size * 1.3 x0, y0, x1, y1 = T.extent X, Y = np.meshgrid(np.arange(x0, x1, spacing), np.arange(y0, y1, spacing)) X = X.ravel() + rng.uniform(-0.5, 0.5, X.size) * spacing; Y = Y.ravel() + rng.uniform(-0.5, 0.5, Y.size) * spacing sc = T.sample(scree, X, Y); ap = T.sample(apron, X, Y) cover = np.clip((1 - ap) ** 1.5 * 0.6, 0, 0.6) keep = (sc > 0.5) & (rng.random(X.size) < cover) X, Y, ap = X[keep], Y[keep], ap[keep] size = (0.25 + max_size * (1 - ap) ** 1.6) * rng.uniform(0.6, 1.2, len(X)) return dict(x=X, y=Y, z=T.height(X, Y), s=size) def paint_blocks(cv, blocks, cam, G, sun, sunvis_fn, band=None): if blocks is None or len(blocks["x"]) == 0: return sx, sy, dep = cam.project(np.c_[blocks["x"], blocks["y"], blocks["z"]]) fp = cam.footprint(dep) wpx = blocks["s"] / fp side = 1 if np.dot(sun, cam.right) > 0 else -1 lit = sunvis_fn(blocks["x"], blocks["y"]) > 0.5 on = (sx > -5) & (sx < cv.w + 5) & (sy > -5) & (sy < cv.h + 5) & (wpx >= 1.6) for i in np.nonzero(on)[0][np.argsort(-dep[on])]: spr = stone_sprite(round(wpx[i]), lit[i], side) cv.blit(spr, sx[i], sy[i], dep[i], ground_t=G["t"], tol=blocks["s"][i] * 2 + fp[i] * 2, band=band) ''' open(p,'w').write(s) p='painter.py'; s=open(p).read() s=s.replace(''' TR.paint_scree(cv, G["mask_scree"], G, apr, lit_all, ndl, cam, seed=seed, band=band)''',''' TR.paint_scree(cv, G["mask_scree"], G, apr, lit_all, ndl, cam, seed=seed, band=band) if "apron" in ex and "scree" in sc.cover: blocks = sc.field(("blocks",), lambda: TR.scatter_blocks(T0, sc.cover["scree"], ex["apron"], np.random.default_rng(seed))) TR.paint_blocks(cv, blocks, cam, G, sun, lambda x, y: T.sample(shadow, x, y), band=None)''') open(p,'w').write(s) EOF cd .. && nice -n 10 python3 study_mountain.py # output: Exit code 1 Traceback (most recent call last): File "~/work/pixelart-studies/aerial/study_mountain.py", line 78, in <module> run() File "~/work/pixelart-studies/aerial/study_mountain.py", line 55, in run a, n = shot(tc, (110, 78 if mpp < 1 else 110), mpp) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "~/work/pixelart-studies/aerial/study_mountain.py", line 40, in shot img, info = paint(sc, cam, LIGHTS[light]) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File "~/work/pixelart-studies/aerial/lib/painter.py", line 126, in paint TR.paint_scree(cv, G["mask_scree"], G, apr, lit_all, ndl, cam, seed=seed, band=band) File "~/work/pixelart-studies/aerial/lib/tech_rock.py", line 46, in paint_scree ph = (x * np.sin(ang) - y * np.cos(ang)) / 2.2 + 2.5 * np.sin(y / 23.0 + x / 31.0) ^ NameError: name 'x' is not defined. Did you mean: 'px'?</pre></details><details class="step"><summary><code>Bash: Fix missing variables and rerun</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='lib/tech_rock.py'; s=open(p).read() s=s.replace(" # grain: stipple"," x, y = G[\"x\"], G[\"y\"]\n # grain: stipple",1) open(p,'w').write(s) EOF nice -n 10 python3 study_mountain.py # output: studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/studies/scree.png</code></div></div>  *74. aerial/studies/scree.png* <div class="steps"><details class="step"><summary><code>Bash: Loosen stone occlusion tolerance</code></summary><pre>cd ~/work/pixelart-studies/aerial && sed -i '' 's/tol=blocks\["s"\]\[i\] \* 2 + fp\[i\] \* 2/tol=blocks["s"][i] * 6 + fp[i] * 8/' lib/tech_rock.py && nice -n 10 python3 study_mountain.py && python3 -c " from PIL import Image; im=Image.open('studies/scree.png'); im.crop((780,0,1560,560)).save('scratch/s1.png')" # output: studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/scratch/s1.png</code></div></div>  *75. aerial/scratch/s1.png* <div class="steps"><details class="step"><summary><code>Bash: Stones with cast shadow, calmer matrix</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_rock.py'; s=open(p).read() start=s.index(' # cast shadow: one pixel of dark matrix'); end=s.index(' from pal import MAT_ID\n return dict(a=a, mat=np.full(a.shape, MAT_ID["scree"])') s=s[:start]+''' # cast shadow on the matrix: a dark row under the stone, shifted to the shade side (contact + shadow) a = np.pad(a, ((0, 1), (1, 1))); st = np.pad(st, ((0, 1), (1, 1))) for x in range(w + 2): xs = x - side if 0 <= xs < a.shape[1] and 1 <= x <= w: a[h, xs] = True; st[h, xs] = 0 if lit else 0 '''+s[end:] s=s.replace("return dict(a=a, mat=np.full(a.shape, MAT_ID[\"scree\"]), step=st, ax=a.shape[1] / 2, ay=h - 1)","return dict(a=a, mat=np.full(a.shape, MAT_ID[\"scree\"]), step=st, ax=a.shape[1] / 2, ay=h)") s=s.replace("def scatter_blocks(T, scree, apron, rng, max_size=2.6, spacing=None):","def scatter_blocks(T, scree, apron, rng, max_size=3.4, spacing=None):") s=s.replace("cover = np.clip((1 - ap) ** 1.5 * 0.6, 0, 0.6)","cover = np.clip((1 - ap) ** 1.2 * 0.75, 0, 0.7)") s=s.replace("dens = np.clip(px * 0.15, 0.04, 0.2)","dens = np.clip(px * 0.15, 0.04, 0.2) * np.clip(apron * 1.5, 0.3, 1)") open(p,'w').write(s) EOF cd .. && nice -n 10 python3 study_mountain.py && python3 -c " from PIL import Image; im=Image.open('studies/scree.png'); im.crop((780,0,1560,560)).save('scratch/s1.png')" # output: studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/scratch/s1.png</code></div></div>  *76. aerial/scratch/s1.png* <div class="steps"><div class="step"><code>Read: aerial/studies/cliff_snow.png</code></div></div>  *77. aerial/studies/cliff_snow.png* <div class="steps"><details class="step"><summary><code>Bash: Controlled cliff and snowfield subjects</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cat >> subjects.py <<'EOF' def banded_cliff(size=260, cell=0.6, seed=5, band=9.0, snow=0.6): """a banded cliff (sedimentary risers and ledges) cut by gullies, facing the camera (south).""" X, Y = grid(size, size, cell) rng = np.random.default_rng(seed) base = 1.25 * Y + 6 * LF.fbm(X, Y, 90, seed=seed) # ~51 deg overall g = np.zeros_like(X) for gx in rng.uniform(20, size - 20, 5): g = np.maximum(g, np.exp(-0.5 * ((X - gx - 8 * np.sin(Y / 30)) / rng.uniform(3, 6)) ** 2)) base -= 10 * g ph = base / band frac = ph % 1.0 # riser steep (70% of each band), ledge nearly flat (30%): terrace profile H = (np.floor(ph) + np.clip(frac / 0.7, 0, 1)) * band * 0.9 + 0.1 * base H += 0.6 * LF.facets(X, Y, 6, seed=seed + 3, tilt=0.4) T = Terrain(H, cell) slope = T.slope_deg() ledge = (frac > 0.72) & (slope < 40) rough = LF.fbm(X, Y, 20, seed=seed + 4) snowm = (ledge & (rough + snow * 0.8 > 0.35)) | ((g > 0.5) & (rough + snow > 0.55)) cover = dict(rock=np.full_like(H, 1.0), snow=snowm * 1.5, meadow=(ledge & ~snowm & (rough > 0.3)) * 1.2) return Scene(T, cover, extras=dict(ledge=ledge.astype(float), conc=T.concavity(6), gully=g), seed=seed) def snowfield(size=400, cell=1.0, seed=6, cover_level=0.55): """a snow-covered slope with hollows, a bergschrund-like upper edge and rock ribs showing through.""" X, Y = grid(size, size, cell) H = 0.6 * Y + 25 * LF.eroded_fbm(X, Y, 180, octaves=6, seed=seed) + 10 * LF.ridged(X, Y, 90, seed=seed + 1) T = Terrain(H, cell) conc = T.concavity(12) slope = T.slope_deg() ribs = (conc > 1.2 + 2.0 * (cover_level - 0.5)) | (slope > 48) snow = (~ribs).astype(float) * 1.5 return Scene(T, dict(rock=np.full_like(H, 0.8), snow=snow), extras=dict(conc=conc), seed=seed) EOF cd .. && python3 - <<'EOF' p='study_mountain.py'; s=open(p).read() s=s.replace("from subjects import cirque, talus_cone","from subjects import cirque, talus_cone, banded_cliff, snowfield") s=s.replace(''' pt = best_point(sc, "ledge", (760, 680), rad=200) a, n = shot(sc, pt, 1.2)''',''' bc = banded_cliff() a, n = shot(bc, (130, 130), 1.0)''') s=s.replace(''' pt = best_point(sc, "snow", (500, 820), rad=250) a, n = shot(sc, pt, 1.2)''',''' sf = snowfield() a, n = shot(sf, (200, 200), 1.6)''') s=s.replace('"cliff bands, 1.2 m/px:','"cliff bands, 1 m/px:').replace('"snow fields, 1.2 m/px:','"snow fields, 1.6 m/px:') open(p,'w').write(s) EOF nice -n 10 python3 study_mountain.py # output: studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/studies/cliff_snow.png</code></div></div>  *78. aerial/studies/cliff_snow.png* <div class="steps"><details class="step"><summary><code>Bash: Irregular bands, more snow relief</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='subjects.py'; s=open(p).read() s=s.replace(" base = 1.25 * Y + 6 * LF.fbm(X, Y, 90, seed=seed) # ~51 deg overall", " base = 1.25 * Y + 22 * LF.fbm(X, Y, 70, seed=seed) + 8 * LF.eroded_fbm(X, Y, 40, seed=seed + 7)") s=s.replace(" ph = base / band\n"," ph = base / band + 0.35 * LF.fbm(X, Y, 25, seed=seed + 8)\n") s=s.replace(" ledge = (frac > 0.72) & (slope < 40)"," ledge = (frac > 0.72) & (slope < 42) & (LF.fbm(X, Y, 14, seed=seed + 9) > -0.35)") s=s.replace(" H = 0.6 * Y + 25 * LF.eroded_fbm(X, Y, 180, octaves=6, seed=seed) + 10 * LF.ridged(X, Y, 90, seed=seed + 1)", " H = 0.6 * Y + 45 * LF.eroded_fbm(X, Y, 160, octaves=6, seed=seed) + 30 * LF.ridged(X, Y, 110, seed=seed + 1)") open(p,'w').write(s) p='tech_rock.py'; s=open(p).read() s=s.replace(" s = np.where(~sh & (conc < -1.5) & (s >= 4) & (thr < 0.5), 3, s)"," s = np.where(~sh & (conc < -2.0) & (s >= 4), 3, s)") open(p,'w').write(s) EOF cd .. && nice -n 10 python3 study_mountain.py # output: studies/scree.png studies/cliff_snow.png</pre></details><div class="step"><code>Read: aerial/studies/cliff_snow.png</code></div></div>  *79. aerial/studies/cliff_snow.png* <div class="steps"><details class="step"><summary><code>Bash: Elongated rock facets, more snow cover</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='subjects.py'; s=open(p).read() s=s.replace(" H += 0.6 * LF.facets(X, Y, 6, seed=seed + 3, tilt=0.4)\n"," H += 0.9 * LF.facets(X * 1.6, Y * 0.5, 9, seed=seed + 3, tilt=0.35)\n") s=s.replace("def snowfield(size=400, cell=1.0, seed=6, cover_level=0.55):","def snowfield(size=400, cell=1.0, seed=6, cover_level=0.8):") open(p,'w').write(s) EOF cd .. && nice -n 10 python3 study_mountain.py >/dev/null && python3 -c " from PIL import Image; im=Image.open('studies/cliff_snow.png'); im.crop((780,0,1560,1136)).resize((390,568)).save('scratch/cs.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/cs.png</code></div></div>  *80. aerial/scratch/cs.png* <div class="steps"><details class="step"><summary><code>Write: aerial/lib/tech_objects.py</code></summary><pre>"""tech_objects.py -- huts and fires legible at small scale (village-scale clearing). What the photos say (Seiser Alm huts, beach huts from above, the Flying-over-a-village drone shot, the ice cabin): from 30-45 deg down a hut is read by FOUR things, in this order of importance: 1. the roof as two planes of very different value (one lit, one in shade: 30-50 L* apart), 2. its cast shadow on the ground (longer than the hut is tall at low sun) -- the shadow is what stands the hut up, 3. one light wall edge under the eave on the sun side (the wall is mostly hidden under the roof), 4. a trodden-earth apron around it and paths between huts (bare soil, lighter than meadow). Fires: at day a fire from above is a pale smoke plume more than a flame; the flame is 1-2 px of the hottest colour with a darker ember ring; at dusk the glow lights a 3-6 px pool of ground (warm). Ferrari (V15 harbor town, V01 island fires, V05 ruins): buildings are planes of flat colour with a 1-px light ridge / edge line and black openings; fire is a 3-4 colour ramp cycled; the ground around it takes the glow as a dithered pool. Technique: small objects are rasterised from their 3-D planes by point splatting into the index canvas (each face carries its own step from n.l, quantised into the family), then the marks are added: ridge highlight (1 px), eave shadow line (1 px dark under the roof edge), door (black). """ import numpy as np from pal import MAT_ID def _splat(cv, P, mat, step, cam, G, tag=5, band=None, bias=0.0): sx, sy, z = cam.project(P) ix = np.floor(sx).astype(int); iy = np.floor(sy).astype(int) ok = (ix >= 0) & (ix < cv.w) & (iy >= 0) & (iy < cv.h) ix, iy, z, step = ix[ok], iy[ok], z[ok] - bias, np.broadcast_to(step, ok.shape)[ok] # painter's z-buffer at pixel level: keep nearest order = np.argsort(-z) ix, iy, z, step = ix[order], iy[order], z[order], step[order] vis = z < cv.z[iy, ix] if G is not None: vis &= z < G["t"][iy, ix] + 0.8 # not behind the terrain ix, iy, z, step = ix[vis], iy[vis], z[vis], step[vis] cv.mat[iy, ix] = MAT_ID[mat]; cv.step[iy, ix] = step; cv.z[iy, ix] = z; cv.tag[iy, ix] = tag if band is not None: cv.band[iy, ix] = band def _quad(o, u, v, n): """points covering the parallelogram o + a u + b v, a,b in [0,1], n x n samples.""" a, b = np.meshgrid(np.linspace(0, 1, n), np.linspace(0, 1, n)) return o[None] + a.reshape(-1, 1) * u[None] + b.reshape(-1, 1) * v[None] def _tri(o, u, v, n): a, b = np.meshgrid(np.linspace(0, 1, n), np.linspace(0, 1, n)) m = (a + b) <= 1.0 return o[None] + a[m].reshape(-1, 1) * u[None] + b[m].reshape(-1, 1) * v[None] def face_step(nrm, sun, sunlit, nsteps=4): """roof/wall ramp of 4: 0 dark opening/eave | 1 shade plane || 2 half | 3 lit plane.""" d = float(np.dot(nrm, sun)) if not sunlit or d <= 0.05: return 1 return 3 if d > 0.45 else 2 def hut(cv, cam, G, sun, x, y, z, L=5.0, Wd=4.0, wall=2.0, ridge=2.2, yaw=0.0, sunlit=True, band=None, shadow=True): """a gabled hut: rectangle L (along its ridge) x Wd, walls `wall` high, ridge `ridge` above the eaves.""" c, s = np.cos(yaw), np.sin(yaw) ex = np.array([c, s, 0.0]); ey = np.array([-s, c, 0.0]); ez = np.array([0, 0, 1.0]) o = np.array([x, y, z]) n = int(max(8, 4 * max(L, Wd) / max(cam.footprint(np.array([1.0])).item(), 0.05))) hl, hw = L / 2, Wd / 2 ov = 0.45 # eave overhang # --- cast shadow first (onto the ground layer): project the hut's box + roof onto z along -sun if shadow and sun[2] > 0.03: k = (wall + ridge * 0.6) / sun[2] pts = [] for dx in (-hl - ov, hl + ov): for dy in (-hw - ov, hw + ov): base = o + dx * ex + dy * ey pts.append(base); pts.append(base - sun * k * (wall / (wall + ridge * 0.6))) for dx in (-hl - ov, hl + ov): top = o + dx * ex + ez * (wall + ridge) pts.append(top - sun * (wall + ridge) / sun[2] + ez * 0) pts = np.array(pts); pts[:, 2] = z sx, sy, _ = cam.project(pts) from matplotlib.path import Path from scipy.spatial import ConvexHull hull = ConvexHull(np.c_[sx, sy]) poly = Path(np.c_[sx, sy][hull.vertices]) x0, x1 = int(max(0, sx.min())), int(min(cv.w, sx.max() + 1)); y0, y1 = int(max(0, sy.min())), int(min(cv.h, sy.max() + 1)) if x1 > x0 and y1 > y0: YY, XX = np.mgrid[y0:y1, x0:x1] inside = poly.contains_points(np.c_[XX.ravel() + 0.5, YY.ravel() + 0.5]).reshape(YY.shape) full = np.zeros((cv.h, cv.w), bool); full[y0:y1, x0:x1] = inside full &= cv.tag != 5 cv.to_shadow(full) # --- walls (4 quads) walls = [(o - hl * ex - hw * ey, L * ex, -ey), (o - hl * ex + hw * ey, L * ex, ey), (o - hl * ex - hw * ey, Wd * ey, -ex), (o + hl * ex - hw * ey, Wd * ey, ex)] for w0, u, nrm in walls: st = 3 if (sunlit and np.dot(nrm, sun) > 0.25) else (2 if sunlit and np.dot(nrm, sun) > 0.0 else 1) st = min(st, 3) _splat(cv, _quad(w0, u, ez * wall, n), "wall", np.full(n * n, st), cam, G, band=band) # door on the camera-facing long wall fw = walls[0] if np.dot(-ey, -cam.fwd) > np.dot(ey, -cam.fwd) else walls[1] d0 = fw[0] + fw[1] * 0.42 _splat(cv, _quad(d0 + fw[2] * 0.02, fw[1] * 0.16, ez * wall * 0.75, 6), "wall", np.zeros(36, int), cam, G, band=band, bias=0.05) # --- gables (triangles) and roof planes for sgn in (-1, 1): g0 = o + sgn * hl * ex - hw * ey + ez * wall pts = _tri(g0, Wd * ey, hw * ey + ridge * ez, n) st = 2 if (sunlit and np.dot(sgn * ex, sun) > 0.1) else 1 _splat(cv, pts, "wall", np.full(len(pts), st), cam, G, band=band) rl = np.hypot(hw + ov, ridge + ov * ridge / hw) for sgn in (-1, 1): eave = o - (hl + ov) * ex + sgn * (hw + ov) * ey + ez * (wall - ov * ridge / hw) up = -sgn * (hw + ov) * ey + (ridge + ov * ridge / hw) * ez nrm = np.cross(ex, up) * (-sgn); nrm = nrm / np.linalg.norm(nrm) if nrm[2] < 0: nrm = -nrm st = face_step(nrm, sun, sunlit) P = _quad(eave, (L + 2 * ov) * ex, up, n) steps = np.full(len(P), st) # marks: eave line one step darker; ridge 1 px highlight on the lit plane a = np.tile(np.linspace(0, 1, n), n); b = np.repeat(np.linspace(0, 1, n), n) steps = np.where(b < 1.0 / n * 1.5, np.maximum(st - 1, 0), steps) if st >= 2: steps = np.where(b > 1 - 1.5 / n, 3, steps) _splat(cv, P, "roof", steps, cam, G, band=band, bias=0.12) def fire(cv, cam, G, x, y, z, t=0, night=False, band=None, smoke=True, sun=None): """a campfire: ember ring + 1-2 px flame; a glow pool on the ground (night); smoke plume drifting downwind as sparse light pixels whose density falls with height (day).""" sx, sy, dep = cam.project(np.array([x, y, z])) fp = cam.footprint(np.array([dep])).item() ix, iy = int(sx), int(sy) rng = np.random.default_rng(t) r_glow = (6.0 if night else 2.2) / fp R = int(np.ceil(r_glow)) + 1 for dy in range(-R, R + 1): for dx in range(-R, R + 1): px, py = ix + dx, iy + dy if not (0 <= px < cv.w and 0 <= py < cv.h): continue d = np.hypot(dx, dy * 1.8) # ground ellipse (foreshortened) if d <= r_glow and cv.tag[py, px] != 5: f = d / max(r_glow, 1e-3) if night: # dithered glow pool: fire ramp step 0/1 on the ground, density falling outward if rng.random() > f * 1.1: cv.mat[py, px] = MAT_ID["fire"]; cv.step[py, px] = 1 if f < 0.45 else 0 elif d <= max(1.0, 0.9 / fp): cv.mat[py, px] = MAT_ID["soil"]; cv.step[py, px] = 0 # ash ring # ember + flame for (dx, dy, st) in [(0, 0, 2), (-1, 0, 1), (1, 0, 1), (0, -1, 3), (0, 1, 1)]: px, py = ix + dx, iy + dy if 0 <= px < cv.w and 0 <= py < cv.h: if fp > 1.0 and (dx, dy) not in ((0, 0), (0, -1)): continue cv.mat[py, px] = MAT_ID["fire"]; cv.step[py, px] = st; cv.tag[py, px] = 5 if smoke: wind = np.array([1.0, 0.35]) for k in range(int(18 / max(fp, 0.3))): hgt = k * fp * 0.9 dxs = wind[0] * hgt * 0.8 / fp + rng.normal(0, 0.6 + 0.12 * k) dys = -hgt * np.cos(np.radians(cam.pitch)) / fp + wind[1] * k * 0.3 px, py = int(round(ix + dxs)), int(round(iy - 2 + dys)) if 0 <= px < cv.w and 0 <= py < cv.h and rng.random() < 0.9 - k * 0.025: cv.mat[py, px] = MAT_ID["smoke"]; cv.step[py, px] = 2 if (k % 3) else 1; cv.tag[py, px] = 5 if rng.random() < 0.5 and px + 1 < cv.w: cv.mat[py, px + 1] = MAT_ID["smoke"]; cv.step[py, px + 1] = 1 def trodden_ground(cover, T, pts, radius, paths=True, width=1.4): """bare soil apron around each point and footpaths joining neighbours (minimum spanning chain).""" x0, y0, x1, y1 = T.extent Y, X = np.mgrid[0:T.ny, 0:T.nx] * T.cell soil = np.zeros_like(X) for (px, py) in pts: soil = np.maximum(soil, np.clip(1.2 - np.hypot(X - px, Y - py) / radius, 0, 1)) if paths and len(pts) > 1: P = np.array(pts) used = [0]; rest = list(range(1, len(P))) while rest: best = min(((i, j) for i in used for j in rest), key=lambda ij: np.hypot(*(P[ij[0]] - P[ij[1]]))) a, b = P[best[0]], P[best[1]] ab = b - a; ll = np.hypot(*ab) + 1e-9 t = np.clip(((X - a[0]) * ab[0] + (Y - a[1]) * ab[1]) / ll ** 2, 0, 1) wig = 0.8 * np.sin(t * 7 + a[0]) d = np.hypot(X - (a[0] + t * ab[0]), Y - (a[1] + t * ab[1])) + wig * 0 soil = np.maximum(soil, (d < width) * 0.9) used.append(best[1]); rest.remove(best[1]) return soil </pre></details><details class="step"><summary><code>Bash: Huts, fire, village subject and test</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='painter.py'; s=open(p).read() s=s.replace(''' # ---- sky (and the void''',''' # ---- huts and fires if sc.huts or sc.fires: import tech_objects as TO for hh in sorted(sc.huts, key=lambda q: -cam.project(np.array([q["x"], q["y"], 0.0]))[2]): zz = float(T0.height(hh["x"], hh["y"])) lit_h = float(T0.sample(shadow, hh["x"], hh["y"])) > 0.5 TO.hut(cv, cam, G, sun, hh["x"], hh["y"], zz, L=hh.get("L", 5.0), Wd=hh.get("W", 4.0), wall=hh.get("wall", 2.0), ridge=hh.get("ridge", 2.2), yaw=hh.get("yaw", 0.0), sunlit=lit_h) for k, ff in enumerate(sc.fires): TO.fire(cv, cam, G, ff["x"], ff["y"], float(T0.height(ff["x"], ff["y"])), t=seed + k, night=light.name in ("evening",), sun=sun) # ---- sky (and the void''') open(p,'w').write(s) p='subjects.py'; s=open(p).read() s+=''' def village(size=360, cell=0.5, seed=7, n_huts=5, hmean=18.0): """a clearing in conifer forest with a few huts, footpaths, a fire in the middle.""" import tech_objects as TO sc = forest_slope(size=size, cell=cell, seed=seed, slope=0.12, clearing=(0.5, 0.5, 42), lone_trees=4, hmean=hmean) rng = np.random.default_rng(seed + 1) cx = cy = size * 0.5 huts = [] ang0 = rng.uniform(0, 2 * np.pi) for k in range(n_huts): a = ang0 + k * 2 * np.pi / n_huts + rng.uniform(-0.3, 0.3); r = rng.uniform(14, 24) huts.append(dict(x=cx + np.cos(a) * r, y=cy + np.sin(a) * r * 0.9, yaw=a + np.pi / 2 + rng.uniform(-0.2, 0.2), L=rng.uniform(4.5, 6.5), W=rng.uniform(3.5, 4.5))) fires = [dict(x=cx + 1.0, y=cy - 1.0)] soil = TO.trodden_ground(sc.cover, sc.T, [(h["x"], h["y"]) for h in huts] + [(cx, cy)], radius=5.5) sc.cover["soil"] = soil * 0.95 # keep trees off huts and paths tr = sc.trees keep = sc.T.sample(soil, tr["x"], tr["y"]) < 0.3 for h in huts: keep &= np.hypot(tr["x"] - h["x"], tr["y"] - h["y"]) > 6 sc.trees = {k: v[keep] for k, v in tr.items()} sc.huts = huts; sc.fires = fires return sc ''' open(p,'w').write(s) EOF cd .. && cat > scratch/t_village.py <<'EOF' import sys; sys.path.insert(0,'lib') from PIL import Image from camera import Iso from pal import LIGHTS from painter import paint from subjects import village from look import * sc=village() out=[] for mpp,l in [(0.25,'afternoon'),(0.5,'afternoon'),(0.5,'evening')]: cam=Iso(target=(180,176,sc.T.height(180,180)),mpp=mpp,elev=30,yaw=0,w=160,h=100) img,info=paint(sc,cam,LIGHTS[l]); print(mpp,l,info['colours']) out.append(up(Image.fromarray(img),4)) vstack(out).save('scratch/t_village.png') EOF nice -n 10 python3 scratch/t_village.py # output: Command did not complete within its 120s timeout and was moved to the background (ID: b242sggt4). Output is being written to: (tmp) You will be notified when it completes. To check interim output, use Read on that file path. Session cwd remains ~/work/voxsim; directory changes made by the backgrounded command do not apply to subsequent commands.</pre></details><details class="step"><summary><code>Bash: Wait for village render</code></summary><pre>sleep 100; cat (tmp) # output: <tool_use_error>Blocked: sleep 100 followed by: cat (tmp) To wait for a condition, use Monitor with an until-loop (e.g. `until <check>; do sleep 2; done`). To wait for a command you started, use run_in_background: true. Do not chain shorter sleeps to work around this block.</tool_use_error></pre></details><div class="step"><code>ToolSearch: select:Monitor</code></div><details class="step"><summary><code>Bash: Wait for village render file</code></summary><pre>until [ -f ~/work/pixelart-studies/aerial/scratch/t_village.png ] && [ $(find ~/work/pixelart-studies/aerial/scratch/t_village.png -mmin -5 | wc -l) -gt 0 ]; do sleep 3; done; cat (tmp) # output: Command running in background with ID: bo6ykh4gf. Output is being written to: (tmp) You will be notified when it completes. To check interim output, use Read on that file path.</pre></details></div> Meanwhile I'll build the far (perspective, high-oblique) view technique: aerial perspective bands and ridge silhouettes. <div class="steps"><details class="step"><summary><code>Bash: List haze reference photos</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' import sys; sys.path.insert(0,'lib'); from look import * import numpy as np from skimage.color import rgb2lab # measure haze: L* and chroma of ridges vs distance on a haze photo import glob fs=sorted(glob.glob('refs/aerial_view_mountain_range_haze/*.jpg'))+sorted(glob.glob('refs/aerial_valley_haze_mountains/*.jpg')) for f in fs: print(f.split('/')[-1][:60], load(f).size) EOF # output: _sheet.jpg (1440, 1504) commons_Aerial_photograph_ca_1936_CCC_CAMP_AT_BIG_MEADOW_ebb (1280, 1032) commons_Aerial_view_of_Newfoundland_Mountains_from_the_s_6e7 (1280, 855) commons_Aerial_view_of_the_coast_of_Tenerife_Canary_Isla_065 (1280, 1290) commons_Air_Mens_Memorial_St_Edward_s_Leek_jpg_339c20f8.jpg (1280, 960) commons_Big_Cobbler_Mountain_Near_Orlean_Virginia_143117_511 (1280, 960) commons_Blue_Ridge_Mountains_Shenandoah_National_Park_Ne_031 (1280, 960) commons_Shivaliks_Himalayas_Aerial_Dehaze_Himachal_Feb20_5f3 (1280, 853) openverse_Big_wind_farm_5c9dcfa1.jpg (1024, 768) openverse_Etherial_Arctic_5a41e524.jpg (1024, 680) openverse_Likas_Bay_View_From_Kokol_Hill_07619863.jpg (1024, 768) openverse_Mexican_Volcanoes_82ea5f5a.jpg (1024, 680) openverse_Queenstown_From_Above_e5f0af85.jpg (1024, 669) openverse_View_From_Bambangan_Village_Inanam_ad183928.jpg (1024, 768) _sheet.jpg (1440, 1504) commons_Aerial_photograph_ca_1936_CCC_CAMP_AT_BIG_MEADOW_ebb (1280, 1032) commons_Arghandab_River_Valley_between_Kandahar_and_Lash_8f9 (1280, 852) commons_Big_Cobbler_Mountain_Near_Orlean_Virginia_143117_511 (1280, 960) commons_Blue_Ridge_Mountains_Shenandoah_National_Park_Ne_031 (1280, 960) commons_Namib_Desert_Satellite_picture_tif_aaf84ed1.jpg (1280, 1043) commons_Namib_Desert_Sentinel_2_jpg_ee746760.jpg (1280, 1043) openverse_2015_06_19_ewr_lax_424y_cdaf4a7e.jpg (1024, 639) openverse_2015_06_19_ewr_lax_424z_dce8dc55.jpg (1024, 639) openverse_Above_The_Clouds_And_Mountains_48044e56.jpg (683, 1024) openverse_Everything_changes_ff36269c.jpg (1023, 682) openverse_Mountains_and_Valleys_b98573ab.jpg (1024, 681) openverse_Murray_and_Central_Valley_Views_a2661567.jpg (1024, 684) openverse_Pinedale_Anticline_Natural_Gas_Field_upper_Green_0 (1024, 683)</pre></details><details class="step"><summary><code>Bash: View two haze photos</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * a=load('refs/aerial_view_mountain_range_haze/commons_Blue_Ridge_Mountains_Shenandoah_National_Park_Ne_0316aaa1.jpg' if False else [f for f in __import__('glob').glob('refs/aerial_view_mountain_range_haze/*Blue_Ridge*')][0]) b=load([f for f in __import__('glob').glob('refs/aerial_view_mountain_range_haze/*Queenstown*')][0]) hstack([a.resize((640,480)),b.resize((640,418))]).save('scratch/haze2.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/haze2.png</code></div></div>  *81. aerial/scratch/haze2.png* <div class="steps"><details class="step"><summary><code>Bash: Measure aerial perspective in photos</code></summary><pre>cd ~/work/pixelart-studies/aerial && cat > measure_haze.py <<'EOF' """measure_haze.py -- aerial perspective looking down: per image row (near at the bottom, far at the top) the land's median L*, its dark end (p5, 'black point') and chroma, on high-oblique photos. python3 measure_haze.py -> measure/haze.json""" import glob, json, os import numpy as np from PIL import Image from skimage.color import rgb2lab ROOT = os.path.dirname(os.path.abspath(__file__)) PH = {"blue_ridge": ("aerial_view_mountain_range_haze/*Blue_Ridge*", 0.30, 1.0), "newfoundland": ("aerial_view_mountain_range_haze/*Newfoundland*", 0.25, 1.0), "shivaliks": ("aerial_view_mountain_range_haze/*Shivaliks*", 0.2, 1.0)} out = {} for k, (pat, top, bot) in PH.items(): fs = glob.glob(os.path.join(ROOT, "refs", pat)) if not fs: continue im = np.asarray(Image.open(fs[0]).convert("RGB").resize((320, 240)), float) / 255 lab = rgb2lab(im); h = lab.shape[0] rows = [] for f in np.linspace(top, bot - 0.02, 8): y = int(f * h); b = lab[y:y + 6] L = b[..., 0].ravel(); C = np.hypot(b[..., 1], b[..., 2]).ravel() rows.append(dict(row_frac=round(float(f), 2), L_med=round(float(np.median(L)), 1), L_p5=round(float(np.percentile(L, 5)), 1), L_p95=round(float(np.percentile(L, 95)), 1), chroma=round(float(np.median(C)), 1), b_med=round(float(np.median(b[..., 2])), 1))) out[k] = rows print(k); [print(" ", r) for r in rows] json.dump(out, open(os.path.join(ROOT, "measure", "haze.json"), "w"), indent=1) EOF python3 measure_haze.py # output: blue_ridge {'row_frac': 0.3, 'L_med': 51.5, 'L_p5': 47.9, 'L_p95': 56.7, 'chroma': 15.6, 'b_med': -14.4} {'row_frac': 0.4, 'L_med': 43.9, 'L_p5': 40.5, 'L_p95': 51.1, 'chroma': 12.3, 'b_med': -10.5} {'row_frac': 0.49, 'L_med': 36.8, 'L_p5': 30.9, 'L_p95': 46.2, 'chroma': 8.8, 'b_med': -7.3} {'row_frac': 0.59, 'L_med': 28.6, 'L_p5': 22.2, 'L_p95': 42.1, 'chroma': 8.0, 'b_med': -6.3} {'row_frac': 0.69, 'L_med': 23.8, 'L_p5': 14.7, 'L_p95': 49.1, 'chroma': 7.3, 'b_med': -4.3} {'row_frac': 0.79, 'L_med': 18.8, 'L_p5': 7.3, 'L_p95': 58.8, 'chroma': 6.1, 'b_med': -1.2} {'row_frac': 0.88, 'L_med': 9.6, 'L_p5': 3.0, 'L_p95': 48.4, 'chroma': 3.8, 'b_med': -1.4} {'row_frac': 0.98, 'L_med': 1.8, 'L_p5': 0.5, 'L_p95': 6.3, 'chroma': 1.6, 'b_med': -0.2} newfoundland {'row_frac': 0.25, 'L_med': 83.7, 'L_p5': 25.5, 'L_p95': 95.2, 'chroma': 7.9, 'b_med': 7.8} {'row_frac': 0.35, 'L_med': 84.5, 'L_p5': 24.2, 'L_p95': 96.6, 'chroma': 9.4, 'b_med': 9.3} {'row_frac': 0.46, 'L_med': 85.7, 'L_p5': 21.2, 'L_p95': 94.5, 'chroma': 9.7, 'b_med': 9.5} {'row_frac': 0.56, 'L_med': 75.6, 'L_p5': 23.4, 'L_p95': 91.3, 'chroma': 8.3, 'b_med': 8.1} {'row_frac': 0.67, 'L_med': 80.8, 'L_p5': 20.9, 'L_p95': 91.7, 'chroma': 9.0, 'b_med': 8.8} {'row_frac': 0.77, 'L_med': 77.6, 'L_p5': 30.9, 'L_p95': 89.9, 'chroma': 8.6, 'b_med': 8.3} {'row_frac': 0.88, 'L_med': 89.1, 'L_p5': 69.4, 'L_p95': 95.0, 'chroma': 10.1, 'b_med': 10.0} {'row_frac': 0.98, 'L_med': 83.6, 'L_p5': 63.6, 'L_p95': 93.2, 'chroma': 9.6, 'b_med': 9.5} shivaliks {'row_frac': 0.2, 'L_med': 87.9, 'L_p5': 82.9, 'L_p95': 91.0, 'chroma': 9.3, 'b_med': -9.3} {'row_frac': 0.31, 'L_med': 86.9, 'L_p5': 83.5, 'L_p95': 90.9, 'chroma': 10.1, 'b_med': -9.7} {'row_frac': 0.42, 'L_med': 69.0, 'L_p5': 64.1, 'L_p95': 75.8, 'chroma': 25.9, 'b_med': -25.7} {'row_frac': 0.53, 'L_med': 71.3, 'L_p5': 60.3, 'L_p95': 79.5, 'chroma': 18.3, 'b_med': -18.1} {'row_frac': 0.65, 'L_med': 55.4, 'L_p5': 49.1, 'L_p95': 74.1, 'chroma': 25.0, 'b_med': -24.9} {'row_frac': 0.76, 'L_med': 59.6, 'L_p5': 41.4, 'L_p95': 65.5, 'chroma': 20.4, 'b_med': -20.3} {'row_frac': 0.87, 'L_med': 46.0, 'L_p5': 40.2, 'L_p95': 51.7, 'chroma': 23.1, 'b_med': -23.0} {'row_frac': 0.98, 'L_med': 43.0, 'L_p5': 35.9, 'L_p95': 47.5, 'chroma': 23.5, 'b_med': -23.5}</pre></details><details class="step"><summary><code>Bash: Inspect painter forest code</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && grep -n "C = None" -A 22 painter.py | head -40; grep -n "if sc.trees is not None and forest_mode == \"surface\":" -A 16 painter.py | tail -18 # output: 63: C = None 64- from terrain import Terrain 65- Wl = None 66- if sc.water is not None: 67- Wl = np.where(np.isfinite(sc.water["level"]), sc.water["level"], -1e9) 68- if sc.trees is not None and forest_mode == "surface": 69- cpx = crown / fp0 70- def _c(): 71- c = TC.canopy_height(T0, sc.trees) 72- if cpx < 2.5: # crowns sub-pixel: keep the stand surface, drop crown-scale bumps 73- c = ndi.gaussian_filter(c, 0.6 * fp0 / T0.cell) 74- return c 75- C = sc.field(("canopy", round(cpx, 1)), _c) 76- from terrain import Terrain 77- T = sc.field(("T+C", round(cpx, 1)), lambda: Terrain(T0.H + C if Wl is None else np.maximum(T0.H + C, Wl), T0.cell, T0.x0, T0.y0)) 78- else: 79- T = T0 if Wl is None else sc.field(("T+W",), lambda: Terrain(np.maximum(T0.H, Wl), T0.cell, T0.x0, T0.y0)) 80- G = T.gbuffer(cam) 81- h, w = G["hit"].shape 82- cv = Canvas(w, h) 83- sun = light.vec 84- seed = sc.seed 85- thr_b = threshold_map(h, w, "blue", seed) -- 159: if sc.trees is not None and forest_mode == "surface": 160- csamp = T0.sample(C, G["x"], G["y"]) 161- th = float(np.median(sc.trees["h"])) 162- onc = G["hit"] & (csamp > 2.0) 163- rel = csamp / np.maximum(T0.sample(ndi.maximum_filter(C, size=max(3, int(round(crown / T0.cell)) + 1)), G["x"], G["y"]), 1) 164- apex = rel > 0.93 165- pit = rel < 0.35 166- kindf = T0.sample(sc.cover["broadleaf"], G["x"], G["y"]) if "broadleaf" in sc.cover else np.zeros_like(csamp) 167- for kname, km in (("conifer", kindf < 0.5), ("broadleaf", kindf >= 0.5)): 168- m = onc & km 169- if m.any(): 170- TC.paint_canopy_surface(cv, m, G, sun, sunvis, ndl, skyview, apex, pit, kind=kname, band=band, 171- thr=threshold_map(h, w, "blue", seed + 11), seed=seed, crown_px=crown / fp0) 172- elif sc.trees is not None: 173- TC.paint_trees(cv, sc.trees, cam, G, sun, lambda x, y: T.sample(shadow, x, y), 174- band_fn=(lambda t: int(band_of(t, bands))) if len(bands) > 1 else None) 175-</pre></details><details class="step"><summary><code>Bash: Show village render output</code></summary><pre>cat (tmp) # output: 0.25 afternoon 25 0.5 afternoon 24 0.5 evening 25 [exited with code 0]</pre></details><div class="step"><code>Read: aerial/scratch/t_village.png</code></div></div>  *82. aerial/scratch/t_village.png* <div class="steps"><details class="step"><summary><code>Bash: Village: soil priority, no lone trees</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='lib/subjects.py'; s=open(p).read() s=s.replace("clearing=(0.5, 0.5, 42), lone_trees=4, hmean=hmean)","clearing=(0.5, 0.5, 42), lone_trees=0, hmean=hmean)") s=s.replace('sc.cover["soil"] = soil * 0.95','sc.cover["soil"] = soil * 1.4') open(p,'w').write(s) EOF echo ok # output: ok</pre></details></div> Now the far regime: forest as stand surface without instances, band collapse, and a range subject. <div class="steps"><details class="step"><summary><code>Bash: Stand-surface forest and band collapse</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='painter.py'; s=open(p).read() s=s.replace(''' if sc.trees is not None and forest_mode == "surface": cpx = crown / fp0''',''' stand_only = sc.trees is None and "forest" in sc.cover if stand_only: # far regime without instances: the forest is a stand surface (tree height where forest) hstand = sc.extras.get("tree_h", 18.0) C = sc.field(("stand",), lambda: ndi.gaussian_filter(sc.cover["forest"] * hstand, 1.0)) T = sc.field(("T+S",), lambda: Terrain(T0.H + C if Wl is None else np.maximum(T0.H + C, Wl), T0.cell, T0.x0, T0.y0)) crown = 6.0 elif sc.trees is not None and forest_mode == "surface": cpx = crown / fp0''') s=s.replace(''' else: T = T0 if Wl is None else sc.field(("T+W",)''',''' if C is None: T = T0 if Wl is None else sc.field(("T+W",)''') s=s.replace(''' if sc.trees is not None and forest_mode == "surface": csamp = T0.sample(C, G["x"], G["y"])''',''' if stand_only: csamp = T0.sample(C, G["x"], G["y"]) onc = G["hit"] & (csamp > hstand * 0.4) & ~G.get("water", np.zeros_like(G["hit"])) kindf = T0.sample(sc.cover["broadleaf"], G["x"], G["y"]) if "broadleaf" in sc.cover else np.zeros_like(csamp) nope = np.zeros_like(onc) for kname, km in (("conifer", kindf < 0.5), ("broadleaf", kindf >= 0.5)): m = onc & km if m.any(): TC.paint_canopy_surface(cv, m, G, sun, sunvis, ndl, skyview, nope, nope, kind=kname, band=band, thr=threshold_map(h, w, "blue", seed + 11), seed=seed, crown_px=1.0) if sc.trees is not None and forest_mode == "surface": csamp = T0.sample(C, G["x"], G["y"])''') # forest floor should not apply in stand_only mode (canopy covers) s=s.replace(''' if C is not None: floor &= T0.sample(C, G["x"], G["y"]) < 2.0''',''' if C is not None: floor &= T0.sample(C, G["x"], G["y"]) < 2.0''') # band collapse before palette s=s.replace(''' pal = Palette(light) img, ncol''',''' # far bands: aerial perspective flattens each mass -- in band >= 2 a material keeps only its two # family tones (lit, shade) plus the darkest accent in band 2; band 3 is lit/shade only for b_ in (2, 3): mb = (cv.band == b_) & (cv.mat > 0) & (cv.mat != MAT_ID["sky"]) if mb.any(): for m_ in np.unique(cv.mat[mb]): n_ = MATERIALS[[k for k, v in MAT_ID.items() if v == m_][0]]["steps"]; ns_ = n_ // 2 sel = mb & (cv.mat == m_) st_ = cv.step[sel] lo_keep = 0 if b_ == 2 else ns_ - 1 cv.step[sel] = np.where(st_ >= ns_, np.minimum(st_, ns_ + 1), np.maximum(np.minimum(st_, ns_ - 1), lo_keep)) pal = Palette(light, band_f=sc.extras.get("band_f", (0.0, 0.22, 0.45, 0.68))) img, ncol''') open(p,'w').write(s) EOF grep -n "pal = Palette" painter.py # output: 225: pal = Palette(light, band_f=sc.extras.get("band_f", (0.0, 0.22, 0.45, 0.68)))</pre></details><details class="step"><summary><code>Bash: Range valley far view test</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cat >> subjects.py <<'EOF' def range_valley(size=9000, cell=15.0, seed=8, treeline=1650.0, snowline=2350.0, lake=False, coast=False): """a few km of mountain range around a glacial valley running north (away from a south-looking-north camera): ridged peaks, eroded flanks, a U-shaped floor with a river, forest to the treeline, meadows and scree above, snow on shaded ground above the snowline.""" X, Y = grid(size, size, cell) ax = size * 0.5 + 600 * LF.fbm(X * 0, Y, 5000, seed=seed) d = (X - ax) / 1400.0 ridges = 1700 * LF.ridged(X, Y, 3200, octaves=7, seed=seed + 1) + 500 * LF.eroded_fbm(X, Y, 2500, seed=seed + 2) trough = 1 - np.exp(-(d ** 2) * 1.2) # U-shaped valley H = 900 + ridges * trough + 60 * d ** 2 + 0.03 * Y H = LF.droplet_erosion(H, cell, n_drops=160000, seed=seed) T = Terrain(H, cell) slope = T.slope_deg() conc = T.concavity(120) # river on the valley floor floor = H.min() rx = ax[:, 0] + 250 * np.sin(Y[:, 0] / 900.0) dist = np.abs(X - rx[:, None]) wet = dist < 25 H2 = np.where(dist < 60, np.minimum(H, ndi.gaussian_filter(H, 6) - 3 * (dist < 25)), H) T = Terrain(H2, cell) level = np.where(wet, ndi.gaussian_filter(H2, 3) + 0.8, np.nan) rough = LF.fbm(X, Y, 400, seed=seed + 4) z = H2 + 120 * rough forest = ((z < treeline) & (slope < 38) & ~wet).astype(float) meadow = np.clip(1 - slope / 35, 0, 1) * 0.8 scree = ((slope > 25) & (slope < 40) & (z > treeline)).astype(float) * 0.9 rock = (slope > 38).astype(float) * 1.1 + 0.2 snow = ((z > snowline) & (slope < 48) | ((z > snowline - 250) & (conc < -25) & (slope < 45))).astype(float) * 1.5 cover = dict(meadow=meadow, scree=scree, rock=rock, snow=snow, forest=forest, broadleaf=((z < treeline - 500) & (rough > 0.1)).astype(float)) return Scene(T, cover, water=dict(level=level, flow=1.0), extras=dict(conc=conc, tree_h=20.0), seed=seed) EOF cd .. && cat > scratch/t_far.py <<'EOF' import sys,time; sys.path.insert(0,'lib') import numpy as np from PIL import Image from camera import Persp from pal import LIGHTS from painter import paint from subjects import range_valley from look import * t0=time.time(); sc=range_valley(); print('build',time.time()-t0) T=sc.T eye=(4500, 300, 3300) cam=Persp.at(eye, yaw=0, pitch=24, vfov=38, w=320, h=180) img,info=paint(sc,cam,LIGHTS['afternoon'],bands=[2500,4500,7000]); print(info['colours'],time.time()-t0) up(Image.fromarray(img),3).save('scratch/t_far.png') EOF nice -n 10 python3 scratch/t_far.py # output: build 25.009413957595825 80 74.1300139427185</pre></details><div class="step"><code>Read: aerial/scratch/t_far.png</code></div></div>  *83. aerial/scratch/t_far.png* <div class="steps"><details class="step"><summary><code>Bash: Dithered depth bands, cavity tone, wider far river</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='painter.py'; s=open(p).read() s=s.replace(" band = band_of(G[\"t\"], bands)"," band = band_of(G[\"t\"] * (1 + (thr_4 - 0.5) * 0.14), bands) # seams between depth bands are dithered") # cavity darkening in the lit family for rock/scree/meadow/snow at far scales s=s.replace(''' cv.fill(m, name, s, band=band) G["mask_" + name] = m''',''' if name in ("rock", "scree", "meadow", "drygrass"): cav = cc < -np.clip(G["mpp"] * 2.5, 2.0, 40.0) # gullies: one step down, both families s = np.where(m & cav, np.maximum(s - 1, lo), s) rid = cc > np.clip(G["mpp"] * 2.5, 2.0, 40.0) # spurs: one step up in the light s = np.where(m & rid & lit, np.minimum(s + 1, hi), s) cv.fill(m, name, s, band=band) G["mask_" + name] = m''') open(p,'w').write(s) p='subjects.py'; s=open(p).read() s=s.replace(" wet = dist < 25\n H2 = np.where(dist < 60, np.minimum(H, ndi.gaussian_filter(H, 6) - 3 * (dist < 25)), H)"," wet = dist < 45\n H2 = np.where(dist < 90, np.minimum(H, ndi.gaussian_filter(H, 6) - 3 * (dist < 45)), H)") open(p,'w').write(s) EOF grep -n "cc = T.sample(conc" painter.py # output: 98: cc = T.sample(conc, G["x"], G["y"])</pre></details><details class="step"><summary><code>Bash: Rerun far view</code></summary><pre>cd ~/work/pixelart-studies/aerial && nice -n 10 python3 scratch/t_far.py # output: build 37.8309109210968 86 104.69187998771667</pre></details><div class="step"><code>Read: aerial/scratch/t_far.png</code></div></div>  *84. aerial/scratch/t_far.png* <div class="steps"><details class="step"><summary><code>Bash: Palette budget merging, narrower seams, lower snowline</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='pal.py'; s=open(p).read() s=s.replace(''' out = np.round(cols[inv.reshape(h, w)]).astype(np.uint8) ncol = len(np.unique(out.reshape(-1, 3), axis=0)) return out, ncol''',''' out = np.round(cols[inv.reshape(h, w)]).astype(np.uint8) if budget: out = limit_palette(out, budget) ncol = len(np.unique(out.reshape(-1, 3), axis=0)) return out, ncol''') s=s.replace(" def render(self, mat, step, band, sky_rgb=None):"," def render(self, mat, step, band, sky_rgb=None, budget=None):") s+=''' def limit_palette(img, budget): """palette economy: while more than `budget` colours are used, merge the closest pair (Lab distance, weighted so rare colours go first) into the more used one. Keys that were distinct in the index canvas but nearly identical in colour (far bands, shared ramps) are what get merged.""" flat = img.reshape(-1, 3) u, inv, cnt = np.unique(flat, axis=0, return_inverse=True, return_counts=True) if len(u) <= budget: return img L = lab(u.astype(float)) alive = np.ones(len(u), bool); target = np.arange(len(u)) while alive.sum() > budget: idx = np.nonzero(alive)[0] D = np.linalg.norm(L[idx, None] - L[None, idx], axis=-1) + np.eye(len(idx)) * 1e9 D = D * np.sqrt(np.minimum(cnt[idx][:, None], cnt[idx][None, :])) i, j = np.unravel_index(np.argmin(D), D.shape) a, b = idx[i], idx[j] if cnt[a] < cnt[b]: a, b = b, a alive[b] = False; target[target == b] = a; cnt[a] += cnt[b] return u[target][inv.ravel()].reshape(img.shape).astype(np.uint8) ''' open(p,'w').write(s) p='painter.py'; s=open(p).read() s=s.replace("img, ncol = pal.render(cv.mat, cv.step, cv.band, sky_rgb=sky_rgb)","img, ncol = pal.render(cv.mat, cv.step, cv.band, sky_rgb=sky_rgb, budget=budget)") s=s.replace('def paint(sc, cam, light, bands=None, forest_mode="auto", sprite_min=3.0, return_canvas=False):','def paint(sc, cam, light, bands=None, forest_mode="auto", sprite_min=3.0, return_canvas=False, budget=64):') s=s.replace("(1 + (thr_4 - 0.5) * 0.14)","(1 + (thr_4 - 0.5) * 0.06)") open(p,'w').write(s) p='subjects.py'; s=open(p).read() s=s.replace("treeline=1650.0, snowline=2350.0","treeline=1650.0, snowline=2150.0") open(p,'w').write(s) EOF echo ok # output: ok</pre></details><details class="step"><summary><code>Bash: Scene disk cache, rerun far view</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cat >> subjects.py <<'EOF' def cached(name, fn, **kw): """build a scene once and keep it on disk (aerial/cache/), keyed by name + kwargs.""" import os, pickle, hashlib d = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "cache") os.makedirs(d, exist_ok=True) key = hashlib.sha1((name + repr(sorted(kw.items()))).encode()).hexdigest()[:12] p = os.path.join(d, f"{name}_{key}.pkl") if os.path.exists(p): with open(p, "rb") as f: return pickle.load(f) sc = fn(**kw) sc._cache = {} with open(p + ".tmp", "wb") as f: pickle.dump(sc, f) os.replace(p + ".tmp", p) return sc EOF cd .. && sed -i '' 's/from subjects import range_valley/from subjects import range_valley, cached/; s/sc=range_valley()/sc=cached("range", range_valley)/' scratch/t_far.py && nice -n 10 python3 scratch/t_far.py # output: build 41.98319983482361 64 91.02043795585632</pre></details><div class="step"><code>Read: aerial/scratch/t_far.png</code></div></div>  *85. aerial/scratch/t_far.png* <div class="steps"><details class="step"><summary><code>Bash: Sea technique and painter hook</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cat >> tech_water.py <<'EOF' def paint_sea(cv, G, T0, level, sun, light, seed=0, band=None, surf_zones=(0.6, 1.4, 2.4), t=0): """a coast from above. Photos (Costa Brava, Hailing Island, Ocean Coast, Lisbon coast, beach from above): the sea is zoned by DEPTH, not by distance: turquoise over sand where it is shallow, dark over rock and kelp, deep blue beyond. Surf is a set of broken white lines parallel to the depth contours (each breaker a 1-2 px bright crest with a darker trough on its seaward side), the swash a thin bright edge on the sand, the wet sand a darker band just above it. Ferrari (V29 seascape, V07 rough seas): foam as white-to-blue 3-step dashes, diffusion-dithered for the chaotic surf; flat bands for calm water; the shore contact a dark line.""" from pal import MAT_ID h, w = G["hit"].shape depth = level - T0.sample(T0.H, G["x"], G["y"]) sea = G["hit"] & (depth > 0) thr = threshold_map(h, w, "blue", seed) thr4 = threshold_map(h, w, "bayer4") # depth zones: shallow ramp 3 (0-0.6 m) .. 0 (2.5-4 m), then the deep water ramp x = np.clip(3.4 - depth / 1.1, 0, 3.4) sh = sea & (depth < 4.2) st = flat_bands(x, thr4, 0.3) cv.fill(sh, "shallow", np.clip(st, 0, 3), band=band, tag=2) deep = sea & ~sh dstep = np.where(depth > 9, 1, 2) dstep = np.where(deep & (thr < 0.04), 3, dstep) # sparse sky glints cv.fill(deep, "water", dstep, band=band, tag=2) # surf: lines along depth contours, broken by noise; a darker trough one pixel below (seaward, near) from noise import fbm brk = fbm(G["x"], G["y"], seed=seed + 3, scale=14.0) for k, dz in enumerate(surf_zones): width = 0.18 + 0.05 * k crest = sea & (np.abs(depth - dz - 0.25 * np.sin(G["x"] / 9.0 + t + k)) < width) & (brk > 0.35 + 0.08 * k) cv.fill(crest, "foam", 2, band=band, tag=2) tail = np.zeros_like(crest); tail[:-1] = crest[1:] # pixel above crest = landward foam fringe cv.fill(tail & sea & ~crest & (thr < 0.55), "foam", 1, band=band, tag=2) trough = np.zeros_like(crest); trough[1:] = crest[:-1] # pixel below = seaward trough tr = trough & sea & ~crest cv.step[tr] = np.maximum(cv.step[tr] - 1, 0) # swash: the water edge; wet sand: land just above the level land = G["hit"] & ~sea up_ = np.zeros_like(sea); up_[1:] = sea[:-1]; dn = np.zeros_like(sea); dn[:-1] = sea[1:] lf = np.zeros_like(sea); lf[:, 1:] = sea[:, :-1]; rt = np.zeros_like(sea); rt[:, :-1] = sea[:, 1:] edge = sea & ~(up_ & dn & lf & rt) sand = T0.sample(sea_cover_sand(cv), G["x"], G["y"]) if False else None cv.fill(edge & (depth < 0.5), "foam", 2, band=band, tag=2) hgt = -depth wet = land & (hgt < 0.5) & (cv.mat == MAT_ID["sand"]) cv.fill(wet, "wetsand", np.where(thr < 0.2, 0, 1), band=band) return sea def sea_cover_sand(cv): return None EOF python3 - <<'EOF' p='tech_water.py'; s=open(p).read() s=s.replace(''' sand = T0.sample(sea_cover_sand(cv), G["x"], G["y"]) if False else None ''','') s=s.replace(''' def sea_cover_sand(cv): return None ''','') open(p,'w').write(s) EOF python3 - <<'EOF' p='painter.py'; s=open(p).read() s=s.replace(''' if Wl is not None: import tech_water as TW''',''' if sc.water is not None and sc.water.get("sea") is not None: import tech_water as TW G["water"] = TW.paint_sea(cv, G, T0, sc.water["sea"], sun, light, seed=seed, band=band) elif Wl is not None: import tech_water as TW''') s=s.replace(''' if sc.water is not None: Wl = np.where(np.isfinite(sc.water["level"]), sc.water["level"], -1e9)''',''' if sc.water is not None and sc.water.get("sea") is not None: Wl = np.full_like(T0.H, sc.water["sea"]) elif sc.water is not None: Wl = np.where(np.isfinite(sc.water["level"]), sc.water["level"], -1e9)''') open(p,'w').write(s) p='pal.py'; s=open(p).read() s=s.replace('"shallow": dict(alb=(60, 130, 120), steps=4),','"shallow": dict(alb=(70, 150, 140), steps=4, chroma=1.4),') s=s.replace('"foam": dict(alb=(250, 250, 250), steps=3),','"foam": dict(alb=(250, 250, 250), steps=3, chroma=1.0),') s=s.replace('"sand": dict(alb=(215, 195, 150), steps=5),','"sand": dict(alb=(205, 188, 150), steps=5, chroma=1.2),') open(p,'w').write(s) EOF grep -n "sea" painter.py | head # output: 25: self.water = water # dict(mask=grid bool or level=float, kind='river'|'lake'|'sea') 66: if sc.water is not None and sc.water.get("sea") is not None: 67: Wl = np.full_like(T0.H, sc.water["sea"]) 109: band = band_of(G["t"] * (1 + (thr_4 - 0.5) * 0.06), bands) # seams between depth bands are dithered 119: s = TG.slope_tone(ndl, sunvis, skyview, name, thr_4 if hard else thr_b, seam=0.22 if hard else 0.35) 153: if sc.water is not None and sc.water.get("sea") is not None: 155: G["water"] = TW.paint_sea(cv, G, T0, sc.water["sea"], sun, light, seed=seed, band=band) 214: # ---- sky (and the void of an iso frame beyond the terrain): flat bands, seams dithered</pre></details><details class="step"><summary><code>Bash: Coast subject and test</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && cat >> subjects.py <<'EOF' def coast(size=700, cell=1.0, seed=9, trees=True): """a sand cove between two rocky headlands; land to the north, sea to the south (toward the camera). Beach profile: ~3 deg foreshore, berm, dunes with dune grass, then forest; headlands are faceted rock ridges running out into the sea with reefs and kelp-dark rock below water.""" X, Y = grid(size, size, cell) cxn = size * 0.5 shore = size * 0.42 + 40 * LF.fbm(X, Y * 0, 300, seed=seed) + 70 * np.exp(-((X - cxn) / 160) ** 2) # cove bay yy = Y - shore # + inland, - seaward H = np.where(yy > 0, 0.05 * yy + 4 * np.clip(yy / 60, 0, 1) + 3 * LF.fbm(X, Y, 50, seed=seed + 1) * np.clip(yy / 40, 0, 1), 0.028 * yy) # beach 3 deg underwater slope H = H + 0.004 * np.clip(yy, None, 0) ** 2 * -0.02 # steepening offshore # headlands heads = np.zeros_like(X) for hx, ang in ((size * 0.14, -0.35), (size * 0.86, 0.3)): u = (X - hx) * np.cos(ang) - (Y - shore) * np.sin(ang) v = (X - hx) * np.sin(ang) + (Y - shore) * np.cos(ang) ridge = np.exp(-(u / (55 + 15 * LF.fbm(X, Y, 80, seed=seed + 2))) ** 2) * np.clip((v + 190) / 150, 0, 1) heads = np.maximum(heads, ridge) rockH = 26 * heads + 3.0 * LF.facets(X, Y, 11, seed=seed + 4, tilt=0.6) * (heads > 0.2) + 6 * LF.ridged(X, Y, 60, seed=seed + 5) * heads H = np.maximum(H, rockH - 5) # reefs / rock pools offshore of the headlands reef = (heads > 0.08) & (LF.fbm(X, Y, 18, seed=seed + 6) > 0.1) H = np.where(reef & (H < 0), H + 1.8, H) T = Terrain(H, cell) slope = T.slope_deg() rock = ((heads > 0.35) | reef).astype(float) * 1.2 + (slope > 30) * 1.0 beachz = (yy > -1) & (yy < 45) dunes = (yy >= 30) & (yy < 90) forest = ((yy > 90 + 20 * LF.fbm(X, Y, 60, seed=seed + 7)) & (heads < 0.35)).astype(float) cover = dict(sand=beachz * 1.0, drygrass=dunes * 1.05 + (heads > 0.25) * (slope < 25) * 1.3, rock=rock, forest=forest, meadow=np.full_like(H, 0.2)) rng = np.random.default_rng(seed) tr = TC.scatter_trees(T, forest, 5.0, rng, hmean=16) if trees else None return Scene(T, cover, trees=tr, water=dict(sea=0.0), seed=seed) EOF cd .. && cat > scratch/t_coast.py <<'EOF' import sys; sys.path.insert(0,'lib') from PIL import Image from camera import Iso from pal import LIGHTS from painter import paint from subjects import coast, cached from look import * sc=cached("coast", coast) out=[] for mpp in [0.5,1.4]: cam=Iso(target=(350,300,0),mpp=mpp,elev=30,yaw=0,w=320,h=180) img,info=paint(sc,cam,LIGHTS['afternoon']); print(mpp,info['colours']) out.append(up(Image.fromarray(img),2)) vstack(out).save('scratch/t_coast.png') EOF nice -n 10 python3 scratch/t_coast.py # output: 0.5 17 1.4 39</pre></details><div class="step"><code>Read: aerial/scratch/t_coast.png</code></div></div>  *86. aerial/scratch/t_coast.png* <div class="steps"><details class="step"><summary><code>Bash: Lace surf pattern</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_water.py'; s=open(p).read() start=s.index(' for k, dz in enumerate(surf_zones):'); end=s.index(' # swash: the water edge') s=s[:start]+''' # the lace: foam density falls off landward of each crest (whitewater spreading and thinning) for k, dz in enumerate(surf_zones): dd = depth - dz - 0.12 * np.sin(G["x"] / 11.0 + t + 1.7 * k) # <0 landward of the crest on = brk > 0.2 + 0.1 * k crest = sea & on & (np.abs(dd) < 0.035 + 0.01 * k) lace_d = np.clip(1 + dd / (0.35 + 0.1 * k), 0, 1) * (dd < 0) # 1 at the crest .. 0 inshore lace = sea & on & ~crest & (thr < lace_d ** 2 * 0.7) cv.fill(lace, "foam", np.where(thr < lace_d ** 2 * 0.25, 1, 0), band=band, tag=2) cv.fill(crest, "foam", 2, band=band, tag=2) trough = np.zeros_like(crest); trough[1:] = crest[:-1] tr = trough & sea & ~crest & (cv.mat != MAT_ID["foam"]) cv.step[tr] = np.maximum(cv.step[tr] - 1, 0) '''+s[end:] open(p,'w').write(s) EOF cd .. && nice -n 10 python3 scratch/t_coast.py # output: 0.5 17 1.4 38</pre></details><div class="step"><code>Read: aerial/scratch/t_coast.png</code></div></div>  *87. aerial/scratch/t_coast.png* <div class="steps"><details class="step"><summary><code>Bash: Find hut and coast ref filenames</code></summary><pre>cd ~/work/pixelart-studies/aerial && ls refs/drone_hut_clearing_forest refs/drone_rocky_coast_forest refs/aerial_view_coast_beach_forest | grep -iE "seiser|ocean_coast|costa|hailing|flying|golden|lisbon|minq"; ls refs/aerial_village_clearing_forest | grep -i flying # output: commons_Lisbon_coast_aerial_view_jpg_5b71da22.jpg commons_Les_Minquiers_jpg_e2c86bb6.jpg openverse_Golden_morning_0ad831b7.jpg openverse_Seiser_Alm_75682842.jpg openverse_Costa_Brava_edc96a9a.jpg openverse_Ocean_Coast_394f2559.jpg openverse_Flying_over_a_village_ecad1e64.jpg</pre></details><details class="step"><summary><code>Bash: Look at hut and coast refs</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * a=load('refs/drone_hut_clearing_forest/openverse_Seiser_Alm_75682842.jpg'); print(a.size) b=load('refs/aerial_village_clearing_forest/openverse_Flying_over_a_village_ecad1e64.jpg'); print(b.size) c=load('refs/drone_rocky_coast_forest/openverse_Ocean_Coast_394f2559.jpg'); print(c.size) F=lambda n: load(f'refs/ferrari_lw/{n}.png') hstack([a.resize((480,int(480*a.size[1]/a.size[0]))), b.resize((480,int(480*b.size[1]/b.size[0]))), c.resize((480,int(480*c.size[1]/c.size[0])))]).save('scratch/hc.png') hstack([F('V15').resize((320,240)),F('V01').resize((320,240)),F('V29').resize((320,240)),F('V07').resize((320,240))]).save('scratch/fhc.png') " # output: Exit code 1 Traceback (most recent call last): File "<string>", line 8, in <module> File "<string>", line 6, in <lambda> File "~/work/pixelart-studies/aerial/lib/look.py", line 6, in load return Image.open(path).convert("RGB") ^^^^^^^^^^^^^^^^ File "~/miniconda3/lib/python3.12/site-packages/PIL/Image.py", line 3465, in open fp = builtins.open(filename, "rb") ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ FileNotFoundError: [Errno 2] No such file or directory: 'refs/ferrari_lw/V07.png' (1023, 629) (1024, 768) (960, 720)</pre></details><details class="step"><summary><code>Bash: Fetch V07 and view refs</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs && for n in V07 V29PM V28; do curl -sL -m 60 -o ferrari_lw/$n.json "https://www.effectgames.com/demos/canvascycle/images/$n.LBM.json"; done; python3 - <<'EOF' import re,json,glob,numpy as np,os from PIL import Image for f in sorted(glob.glob('ferrari_lw/*.json')): if os.path.exists(f.replace('.json','.png')): continue t=open(f).read(); t=re.sub(r'([{,])\s*([A-Za-z_]+)\s*:', r'\1"\2":', t).replace("'",'"') d=json.loads(t); pal=np.array(d['colors'],dtype=np.uint8); px=np.array(d['pixels']).reshape(d['height'],d['width']) Image.fromarray(pal[px]).save(f.replace('.json','.png')); print(f) EOF cd .. && python3 -c " import sys; sys.path.insert(0,'lib'); from look import * a=load('refs/drone_hut_clearing_forest/openverse_Seiser_Alm_75682842.jpg') b=load('refs/aerial_village_clearing_forest/openverse_Flying_over_a_village_ecad1e64.jpg') c=load('refs/drone_rocky_coast_forest/openverse_Ocean_Coast_394f2559.jpg') F=lambda n: load(f'refs/ferrari_lw/{n}.png') hstack([a.resize((480,295)), b.resize((480,360)), c.resize((480,360))]).save('scratch/hc.png') hstack([F('V15').resize((320,240)),F('V01').resize((320,240)),F('V29').resize((320,240)),F('V07').resize((320,240))]).save('scratch/fhc.png') " # output: ferrari_lw/V07.json ferrari_lw/V28.json ferrari_lw/V29PM.json</pre></details><div class="step"><code>Read: aerial/scratch/hc.png</code></div><div class="step"><code>Read: aerial/scratch/fhc.png</code></div></div>  *88. aerial/scratch/fhc.png*  *89. aerial/scratch/hc.png* <div class="steps"><details class="step"><summary><code>Write: aerial/study_objects.py</code></summary><pre>"""study_objects.py -- huts + fire in a clearing (day and dusk), and the coast (surf lace, shallows by depth), each beside the photo at the same pixel scale and the nearest Ferrari. nice -n 10 python3 study_objects.py -> studies/huts_fire.png, studies/coast.png """ import os, sys sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "lib")) from PIL import Image from camera import Iso from pal import LIGHTS from painter import paint from subjects import village, coast, cached import study as S ROOT = os.path.dirname(os.path.abspath(__file__)) R = lambda p: os.path.join(ROOT, "refs", p) FER = lambda n: os.path.join(ROOT, "refs/ferrari_lw", n + ".png") SEISER = R("drone_hut_clearing_forest/openverse_Seiser_Alm_75682842.jpg") VILL = R("aerial_village_clearing_forest/openverse_Flying_over_a_village_ecad1e64.jpg") OCEAN = R("drone_rocky_coast_forest/openverse_Ocean_Coast_394f2559.jpg") LISB = R("aerial_view_coast_beach_forest/commons_Lisbon_coast_aerial_view_jpg_5b71da22.jpg") W, H = 96, 64 def shot(sc, pt, z, mpp, light): cam = Iso(target=(pt[0], pt[1], z), mpp=mpp, elev=30, yaw=0, w=W, h=H) img, info = paint(sc, cam, LIGHTS[light]) return Image.fromarray(img), info["colours"] def run(): sc = village() z = float(sc.T.height(180, 180)) rows = [] a, n = shot(sc, (180, 178), z, 0.3, "afternoon") p = S.px_photo(VILL, (760, 0, 1024, 176), W) f = Image.open(FER("V15")).convert("RGB").crop((40, 120, 40 + W, 120 + H)) rows.append(S.panel("huts, 0.3 m/px: two roof planes of different value, the cast shadow, a lit eave wall, trodden apron + paths", [p, a, f], ["photo (village from the air)", f"mine ({n} colours)", "Ferrari V15 harbor town"])) a, n = shot(sc, (180, 178), z, 0.5, "evening") p = S.px_photo(SEISER, (300, 140, 480, 260), W) f = Image.open(FER("V01")).convert("RGB").crop((440, 20, 440 + W, 20 + H)) rows.append(S.panel("huts + fire at dusk, 0.5 m/px: long shadows, 1-2 px flame over an ember ring, glow pool, drifting smoke", [p, a, f], ["photo (Seiser Alm huts, low sun)", f"mine ({n})", "Ferrari V01 island fires"])) S.stack(rows).save(os.path.join(ROOT, "studies", "huts_fire.png")); print("studies/huts_fire.png") cs = cached("coast", coast) rows = [] a, n = shot(cs, (350, 290), 0.0, 0.5, "afternoon") p = S.px_photo(OCEAN, (560, 0, 960, 270), W) f = Image.open(FER("V29")).convert("RGB").crop((380, 340, 380 + W, 340 + H)) rows.append(S.panel("coast, 0.5 m/px: shallows zoned by depth, surf crests with landward lace, swash edge, wet sand", [p, a, f], ["photo (beach from a drone)", f"mine ({n})", "Ferrari V29 seascape surf"])) a, n = shot(cs, (350, 300), 0.0, 1.4, "afternoon") p = S.px_photo(LISB, (0, 250, 1024, 682), W) f = Image.open(FER("V07")).convert("RGB").crop((0, 300, W, 300 + H)) rows.append(S.panel("coast, 1.4 m/px: headlands as faceted rock, the cove's surf as parallel broken lines", [p, a, f], ["photo (Lisbon coast, aerial)", f"mine ({n})", "Ferrari V07 rough seas"])) S.stack(rows).save(os.path.join(ROOT, "studies", "coast.png")); print("studies/coast.png") if __name__ == "__main__": run() </pre></details><details class="step"><summary><code>Bash: Run objects and coast study</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c "from PIL import Image; print(Image.open('refs/aerial_view_coast_beach_forest/commons_Lisbon_coast_aerial_view_jpg_5b71da22.jpg').size)" && nice -n 10 python3 study_objects.py # output: (1280, 1267) studies/huts_fire.png studies/coast.png</pre></details><div class="step"><code>Read: aerial/studies/huts_fire.png</code></div><div class="step"><code>Read: aerial/studies/coast.png</code></div></div>  *90. aerial/studies/huts_fire.png*  *91. aerial/studies/coast.png* <div class="steps"><details class="step"><summary><code>Bash: Fix study crops</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='study_objects.py'; s=open(p).read() s=s.replace('crop((40, 120, 40 + W, 120 + H))','crop((150, 140, 150 + W, 140 + H))') s=s.replace('S.px_photo(SEISER, (300, 140, 480, 260), W)','S.px_photo(SEISER, (660, 280, 980, 493), W)') s=s.replace('crop((440, 20, 440 + W, 20 + H))','crop((300, 20, 300 + W, 20 + H))') s=s.replace('a, n = shot(cs, (350, 290), 0.0, 0.5, "afternoon")','a, n = shot(cs, (330, 318), 0.0, 0.5, "afternoon")') s=s.replace('S.px_photo(OCEAN, (560, 0, 960, 270), W)','S.px_photo(OCEAN, (480, 120, 960, 440), W)') s=s.replace('crop((380, 340, 380 + W, 340 + H))','crop((430, 330, 430 + W, 330 + H))') s=s.replace('S.px_photo(LISB, (0, 250, 1024, 682), W)','S.px_photo(LISB, (300, 700, 1280, 1267), W)') s=s.replace('crop((0, 300, W, 300 + H))','crop((200, 390, 200 + W, 390 + H))') open(p,'w').write(s) EOF nice -n 10 python3 study_objects.py # output: studies/huts_fire.png studies/coast.png</pre></details><details class="step"><summary><code>Bash: Combine both studies at half size</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " from PIL import Image a=Image.open('studies/huts_fire.png'); b=Image.open('studies/coast.png') w=1172; c=Image.new('RGB',(w, (a.size[1]+b.size[1])//2)); c.paste(a.resize((w,a.size[1]//2)),(0,0)); c.paste(b.resize((w,b.size[1]//2)),(0,a.size[1]//2)); c.save('scratch/hc2.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/hc2.png</code></div></div>  *92. aerial/scratch/hc2.png* <div class="steps"><details class="step"><summary><code>Bash: Lighter lace, better crops</code></summary><pre>cd ~/work/pixelart-studies/aerial && sed -i '' 's/crop((150, 140, 150 + W, 140 + H))/crop((140, 290, 140 + W, 290 + H))/; s/shot(cs, (330, 318), 0.0, 0.5/shot(cs, (330, 336), 0.0, 0.5/' study_objects.py && sed -i '' 's/cv.fill(lace, "foam", np.where(thr < lace_d \*\* 2 \* 0.25, 1, 0), band=band, tag=2)/cv.fill(lace, "foam", np.where(thr < lace_d ** 2 * 0.25, 2, 1), band=band, tag=2)/' lib/tech_water.py && grep -n 'fill(lace' lib/tech_water.py && nice -n 10 python3 study_objects.py # output: 120: cv.fill(lace, "foam", np.where(thr < lace_d ** 2 * 0.25, 2, 1), band=band, tag=2) studies/huts_fire.png studies/coast.png</pre></details><details class="step"><summary><code>Bash: List cirque and valley refs</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs && ls glacial_cirque_tarn_aerial alpine_tarn_from_above aerial_view_alpine_valley_river aerial_view_alpine_lake_cirque 2>/dev/null | grep -v sources # output: aerial_view_alpine_lake_cirque: _sheet.jpg openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_3edaed3b.jpg openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_7b07c4f7.jpg openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_918ece8e.jpg openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_eaa078db.jpg openverse_Aerials_Venue_Deer_Valley_Utah_2002_Winter_Olymp_ca79f8b7.jpg openverse_Fall_colors_snow_on_Steens_Mountain_ad7b1bd1.jpg openverse_In_the_Valley_of_Seven_Lakes_ff4a31fc.jpg openverse_Kepler_Track_thin_white_line_a5b89a11.jpg openverse_Mt_Pilatus_Switzerland_9addddcf.jpg openverse_Pea_Soup_Lake_484e3082.jpg openverse_Swiss_Alps_View_from_Pilatus_8cfa3c50.jpg openverse_Vancouver_e_Whistler_Vancouver_and_Whistler_d40c3bca.jpg aerial_view_alpine_valley_river: _sheet.jpg commons_Aerial_View_of_an_Alpine_Valley_Italy_1918_Art_I_c147e886.jpg commons_Aerial_view_of_forested_valleys_and_alpine_meado_e212e960.jpg commons_Alberschwende_Bregenzer_Ache_Doren_Langen_Alpine_d491fadd.jpg commons_Alberschwende_Brueggelekopf_Lorena_Gaisskopf_Bil_fdae2fc7.jpg commons_Bergtocht_van_Gimillan_1805m_naar_Colle_Tsa_S_ts_a92dffe9.jpg commons_Carson_River_and_Indian_Creek_Reservoir_Alpine_C_fb8c9390.jpg commons_Northern_End_of_San_Luis_Valley_Colorado_7235128_2593868f.jpg openverse_Aerial_view_of_the_Dolomites_valley_efa9f75c.jpg openverse_Aerials_Venue_Deer_Valley_Utah_2002_Winter_Olymp_ca79f8b7.jpg openverse_In_the_Valley_of_Seven_Lakes_ff4a31fc.jpg openverse_Mt_Pilatus_123cb383.jpg openverse_Swiss_Alps_View_from_Pilatus_8cfa3c50.jpg openverse_Wild_river_P2251874_cfadd654.jpg alpine_tarn_from_above: _sheet.jpg commons_Alpine_lake_above_the_Watson_River_Yukon_9238014_a51d6048.jpg commons_Descriptive_time_tables_Soo_Atlantic_Soo_Winnipe_305e6580.jpg commons_Flight_from_Lima_to_Quito_the_Cordillera_Blance__9df0a047.jpg commons_Mountain_View_over_the_Central_Fells_Lake_Distri_d0e238a1.jpg commons_Opabin_Plateau_Alpine_Tarn_jpg_0fabcef6.jpg openverse_0I7A9852_2_jpg_6bd2802f.jpg openverse_Alpine_tarn_d02b7083.jpg openverse_Dusky_Track_Elevation_Profile_408186d0.jpg openverse_Lamoille_Canyon_Ruby_Mountains_Near_Elko_Nevada_94bb7e51.jpg openverse_Morning_in_the_mountains_4d55b7e9.jpg openverse_Ruby_Mountains_Seen_from_Interstate_80_Near_Elko_a2d2b031.jpg openverse_Ruchkopf_Gletscherbach_cf8126a4.jpg glacial_cirque_tarn_aerial: _sheet.jpg commons_Backed_up_Against_the_Wall_jpg_09c2a7a3.jpg commons_Hoher_Sonnblick_aerial_jpg_dde6f4cb.jpg commons_Saint_Chely_Tarn_jpg_d5bbd782.jpg commons_Sawtooth_aerial_jpg_1204b958.jpg openverse_Cirque_ular_Lake_b5e2169e.jpg openverse_Colorado_Mount_Evans_Summit_Lake_4b219546.jpg openverse_Colorado_Mount_Evans_Summit_Lake_b4046daa.jpg openverse_Ice_Cubes_b27d8526.jpg openverse_Lake_Helen_Lassen_NP_California_e57b7048.jpg openverse_Twin_Lakes_area_along_the_Beartooth_Highway_Bear_f050ab4d.jpg openverse_iss018e005660_84f83961.jpg</pre></details><details class="step"><summary><code>Bash: Candidate plate photos</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs && python3 -c " import sys; sys.path.insert(0,'../lib'); from look import * fs=['alpine_tarn_from_above/commons_Alpine_lake_above_the_Watson_River_Yukon_9238014_a51d6048.jpg','glacial_cirque_tarn_aerial/commons_Sawtooth_aerial_jpg_1204b958.jpg','glacial_cirque_tarn_aerial/openverse_Cirque_ular_Lake_b5e2169e.jpg','aerial_view_alpine_valley_river/commons_Aerial_view_of_forested_valleys_and_alpine_meado_e212e960.jpg','aerial_view_alpine_valley_river/openverse_Aerial_view_of_the_Dolomites_valley_efa9f75c.jpg','glacial_cirque_tarn_aerial/commons_Hoher_Sonnblick_aerial_jpg_dde6f4cb.jpg'] ims=[load(f).resize((400,260)) for f in fs] vstack([hstack(ims[:3]),hstack(ims[3:])]).save('../scratch/cands.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/cands.png</code></div></div>  *93. aerial/scratch/cands.png* <div class="steps"><details class="step"><summary><code>Bash: Grid over Sawtooth photo</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " from PIL import Image, ImageDraw im=Image.open('refs/glacial_cirque_tarn_aerial/commons_Sawtooth_aerial_jpg_1204b958.jpg').convert('RGB'); print(im.size) t=im.resize((640,int(640*im.size[1]/im.size[0]))); d=ImageDraw.Draw(t) for x in range(0,640,64): d.line([(x,0),(x,t.size[1])],fill=(255,0,0)) for y in range(0,t.size[1],64): d.line([(0,y),(640,y)],fill=(255,0,0)) t.save('scratch/saw_grid.png')" # output: (1280, 850)</pre></details><div class="step"><code>Read: aerial/scratch/saw_grid.png</code></div></div>  *94. aerial/scratch/saw_grid.png* <div class="steps"><details class="step"><summary><code>Bash: Measure Sawtooth tones</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='measure_photos.py'; s=open(p).read() s=s.replace(''' ("sky_top", RIV''',''' ("saw_rock_lit", "glacial_cirque_tarn_aerial/commons_Sawtooth_aerial_jpg_1204b958.jpg", (900, 300, 1100, 420), "tone"), ("saw_rock_shade", "glacial_cirque_tarn_aerial/commons_Sawtooth_aerial_jpg_1204b958.jpg", (330, 420, 470, 560), "tone"), ("saw_tarn", "glacial_cirque_tarn_aerial/commons_Sawtooth_aerial_jpg_1204b958.jpg", (820, 420, 960, 490), "tone"), ("saw_snow_shade", "glacial_cirque_tarn_aerial/commons_Sawtooth_aerial_jpg_1204b958.jpg", (520, 650, 580, 690), "tone"), ("saw_far_forest_hazed", "glacial_cirque_tarn_aerial/commons_Sawtooth_aerial_jpg_1204b958.jpg", (0, 280, 180, 400), "tone"), ("saw_near_forest", "glacial_cirque_tarn_aerial/commons_Sawtooth_aerial_jpg_1204b958.jpg", (1000, 700, 1200, 840), "tone"), ("sky_top", RIV''') open(p,'w').write(s) EOF nice -n 10 python3 measure_photos.py 2>&1 | grep saw # output: saw_rock_lit {'L_med': 84.67, 'L_p10': 76.74, 'L_p90': 89.81, 'chroma_med': 7.47, 'hue_deg': 67.42} saw_rock_shade {'L_med': 51.16, 'L_p10': 44.6, 'L_p90': 57.33, 'chroma_med': 16.02, 'hue_deg': 244.88} saw_tarn {'L_med': 46.46, 'L_p10': 44.27, 'L_p90': 66.04, 'chroma_med': 19.59, 'hue_deg': 253.72} saw_snow_shade {'L_med': 76.16, 'L_p10': 62.58, 'L_p90': 80.12, 'chroma_med': 10.0, 'hue_deg': 243.05} saw_far_forest_hazed {'L_med': 56.17, 'L_p10': 52.05, 'L_p90': 69.13, 'chroma_med': 13.49, 'hue_deg': 245.91} saw_near_forest {'L_med': 51.72, 'L_p10': 38.68, 'L_p90': 75.53, 'chroma_med': 5.57, 'hue_deg': 131.12}</pre></details><details class="step"><summary><code>Write: aerial/plates.py</code></summary><pre>"""plates.py -- the techniques composed into scene plates, each judged beside an oblique photo of similar framing (photo box-downsampled to the same native size, both shown 3x nearest). nice -n 10 python3 plates.py # all plates (4 worker processes) nice -n 10 python3 plates.py cirque # one Writes plates/<name>.png (photo | mine at 3x) and plates/<name>_native.png. """ import os, sys ROOT = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, os.path.join(ROOT, "lib")) os.environ.setdefault("OMP_NUM_THREADS", "1") import numpy as np from PIL import Image from camera import Iso, Persp from pal import LIGHTS from painter import paint import subjects as SJ import study as S R = lambda p: os.path.join(ROOT, "refs", p) PLATES = { # name: (scene builder, kwargs, camera fn, light, photo, photo box, bands, size, caption) "forest_slope_iso": (SJ.forest_slope, dict(size=700, cell=1.0, seed=11, clearing=(0.5, 0.52, 45), slope=0.35, lone_trees=10), lambda sc: Iso((350, 330, sc.T.height(350, 330)), 1.3, 30, 0), "afternoon", "aerial_view_forested_mountain_slope/commons_Deer_Mountain_Village_at_Dawn_jpg_a363c568.jpg", (0, 330, 1280, 1050), None, 1, "forested slope with a clearing, iso 1.3 m/px"), "river_valley_iso": (SJ.river_valley, dict(seed=2), lambda sc: Iso((450, 470, sc.T.height(450, 470)), 1.6, 30, 0), "afternoon", "drone_river_meadow_valley/commons_Cosumnes_River_drone_jpg_d9b23c68.jpg", (0, 200, 1280, 920), None, 1, "river valley with meadows, iso 1.6 m/px"), "cirque_iso": (SJ.cirque, dict(seed=3, snow=0.6), lambda sc: Iso((500, 640, sc.T.height(500, 640)), 2.2, 30, 0), "afternoon", "glacial_cirque_tarn_aerial/commons_Sawtooth_aerial_jpg_1204b958.jpg", (0, 110, 1280, 830), None, 1, "glacial cirque, tarn, snow, iso 2.2 m/px"), "scree_cliffs_iso": (SJ.cirque, dict(seed=3, snow=0.6), lambda sc: Iso((500, 760, sc.T.height(500, 760)), 1.0, 30, 0), "morning", "talus_fan_mountain/commons_TalusConesIsfjorden_jpg_5b61cbaf.jpg", (0, 0, 1024, 576), None, 1, "headwall, cliff bands and scree apron, iso 1.0 m/px, morning"), "coast_iso": (SJ.coast, dict(seed=9), lambda sc: Iso((350, 330, 0.0), 1.3, 30, 0), "afternoon", "drone_rocky_coast_forest/openverse_Ocean_Coast_394f2559.jpg", (0, 0, 960, 540), None, 1, "sand cove between rocky headlands, iso 1.3 m/px"), "village_iso": (SJ.village, dict(), lambda sc: Iso((180, 176, sc.T.height(180, 180)), 0.35, 30, 0), "afternoon", "aerial_village_clearing_forest/openverse_Flying_over_a_village_ecad1e64.jpg", (0, 0, 1024, 576), None, 1, "village clearing with huts and a fire, iso 0.35 m/px"), "village_dusk_iso": (SJ.village, dict(), lambda sc: Iso((180, 176, sc.T.height(180, 180)), 0.35, 30, 0), "evening", "drone_hut_clearing_forest/openverse_Seiser_Alm_75682842.jpg", (0, 60, 1023, 636), None, 1, "the same clearing at dusk: long shadows, fire glow"), "range_far": (SJ.range_valley, dict(seed=8), lambda sc: Persp.at((4500, 300, 3300), yaw=0, pitch=24, vfov=38), "afternoon", "aerial_view_alpine_valley_river/commons_Aerial_view_of_forested_valleys_and_alpine_meado_e212e960.jpg", (0, 0, 1280, 720), [2500, 4500, 7000], 1, "range and glacial valley, high oblique, a few km"), "range_far_evening": (SJ.range_valley, dict(seed=8), lambda sc: Persp.at((4500, 300, 3300), yaw=0, pitch=24, vfov=38), "evening", "aerial_view_mountain_range_haze/commons_Blue_Ridge_Mountains_Shenandoah_National_Park_Ne_0316aaa1.jpg", (0, 200, 1280, 920), [2500, 4500, 7000], 1, "the same range at evening: violet haze, lifted black point"), "cirque_far": (SJ.cirque, dict(seed=3, snow=0.6), lambda sc: Persp.at((500, -350, 900), yaw=0, pitch=30, vfov=40), "afternoon", "glacial_cirque_tarn_aerial/commons_Hoher_Sonnblick_aerial_jpg_dde6f4cb.jpg", (0, 0, 1280, 720), [700, 1100, 1500], 1, "the cirque as a far view"), } def build(name, big=False): fn, kw, camfn, light, photo, box, bands, _, cap = PLATES[name] sc = SJ.cached(fn.__name__, fn, **kw) cam = camfn(sc) if big: # 640x360: same framing, twice the pixels if cam.kind == "iso": cam = Iso(cam.target, cam.mpp / 2, cam.pitch, cam.yaw, w=640, h=360) else: cam = Persp.at(cam.eye, yaw=cam.yaw, pitch=cam.pitch, vfov=38 if "range" in name else 40, w=640, h=360) else: cam.w, cam.h = 320, 180 img, info = paint(sc, cam, LIGHTS[light], bands=bands) mine = Image.fromarray(img) pp = R(photo) if not os.path.exists(pp): import glob g = glob.glob(os.path.join(os.path.dirname(pp), os.path.basename(pp)[:40] + "*")) pp = g[0] im = Image.open(pp).convert("RGB") b = (box[0], box[1], min(box[2], im.size[0]), min(box[3], im.size[1])) ph = im.crop(b).resize(mine.size, Image.BOX) suffix = "_640" if big else "" mine.save(os.path.join(ROOT, "plates", f"{name}{suffix}_native.png")) k = 3 if not big else 2 out = S.panel(f"{cap} -- {light}, {info['colours']} colours, {mine.size[0]}x{mine.size[1]} shown {k}x", [ph, mine], ["oblique photo, same framing, box-downsampled", "mine"], k=k) out.save(os.path.join(ROOT, "plates", f"{name}{suffix}.png")) return name, info["colours"] if __name__ == "__main__": names = sys.argv[1:] or list(PLATES) big = "--big" in names names = [n for n in names if n != "--big"] or list(PLATES) # build caches serially (avoid two workers building the same scene) for n in names: fn, kw = PLATES[n][0], PLATES[n][1] SJ.cached(fn.__name__, fn, **kw) from multiprocessing import Pool with Pool(4) as p: for r in p.starmap(build, [(n, big) for n in names]): print(r) </pre></details><details class="step"><summary><code>Bash: Render all plates</code></summary><pre>cd ~/work/pixelart-studies/aerial && nice -n 10 python3 plates.py > scratch/plates.log 2>&1; tail -15 scratch/plates.log # output: Command running in background with ID: b46abz9gl. Output is being written to: (tmp) You will be notified when it completes. To check interim output, use Read on that file path. Session cwd remains ~/work/voxsim; directory changes made by the backgrounded command do not apply to subsequent commands.</pre></details></div> Meanwhile, the sources.tsv consolidation for refs. <div class="steps"><details class="step"><summary><code>Bash: Consolidate sources.tsv</code></summary><pre>cd ~/work/pixelart-studies/aerial/refs && head -3 aerial_view_forested_mountain_slope/sources.tsv; python3 - <<'EOF' import glob, os, csv rows=[] for f in sorted(glob.glob('*/sources.tsv')): d=os.path.dirname(f) for line in open(f): parts=line.rstrip('\n').split('\t') if parts[0]=='file': continue rows.append([os.path.join(d, parts[0])]+parts[1:]) with open('sources.tsv','w') as o: o.write('file\ttitle\tlicense\tauthor\tpage\n') for r in rows: o.write('\t'.join(r)+'\n') for f in sorted(glob.glob('ferrari_lw/*.png')): o.write(f"{f}\tMark J. Ferrari, Living Worlds scene {os.path.basename(f)[:-4]}\tstudy reference only (c) Mark Ferrari\tMark J. Ferrari\thttps://www.effectgames.com/demos/canvascycle/ (Joseph Huckaby, Canvas Cycle)\n") print(len(rows)) EOF # output: openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_eaa078db.jpg Adirondack Mountains - Whiteface Mountain - Lake Placid - New York CC BY-NC-SA 2.0 Onasill ~ Bill- 81M views https://www.flickr.com/photos/7156765@N05/44824012515 openverse_20120720_NRCS_LSC_0489_1cd3d6e1.jpg 20120720-NRCS-LSC-0489 CC PDM 1.0 USDAgov https://www.flickr.com/photos/41284017@N08/7633947396 openverse_Adirondack_Mountains_Whiteface_Mountain_Lake_Pla_918ece8e.jpg Adirondack Mountains - Whiteface Mountain - Lake Placid - New York - Vista CC BY-NC-SA 2.0 Onasill ~ Bill https://www.flickr.com/photos/7156765@N05/45451638832 478</pre></details><details class="step"><summary><code>Write: aerial/sheets.py</code></summary><pre>"""sheets.py -- parameter sweeps: subject x distance/scale, subject x light/hour, subject x seed. nice -n 10 python3 sheets.py [scale|light|seed|far] (4 worker processes, 1 thread each) Writes sheets/sheet_<kind>.png (cells 160x100 native, shown 2x, labelled). """ import os, sys ROOT = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, os.path.join(ROOT, "lib")) os.environ.setdefault("OMP_NUM_THREADS", "1") import numpy as np from PIL import Image from camera import Iso, Persp from pal import LIGHTS from painter import paint import subjects as SJ import study as S CW, CH = 160, 100 HOURS = ["morning", "noon", "afternoon", "evening", "overcast"] SUBJ = { # name: (builder, kwargs, target fn(sc) -> (x, y), default mpp) "forest": (SJ.forest_slope, dict(size=700, cell=1.0, seed=11, clearing=(0.5, 0.52, 45), slope=0.35, lone_trees=10), lambda sc, s: (350, 340), 1.0), "river": (SJ.river_valley, dict(seed=2), lambda sc, s: (450, 470), 1.2), "cirque": (SJ.cirque, dict(seed=3, snow=0.6), lambda sc, s: (500, 640), 2.4), "scree": (SJ.talus_cone, dict(seed=4), lambda sc, s: (110, 95), 0.6), "cliff": (SJ.banded_cliff, dict(seed=5), lambda sc, s: (130, 130), 1.0), "snow": (SJ.snowfield, dict(seed=6), lambda sc, s: (200, 200), 1.6), "coast": (SJ.coast, dict(seed=9), lambda sc, s: (350, 320), 1.0), "village": (SJ.village, dict(), lambda sc, s: (180, 176), 0.35), } def cell(subject, mpp=None, light="afternoon", seed=None, label=""): fn, kw, tgt, m0 = SUBJ[subject] kw = dict(kw) if seed is not None: kw["seed"] = seed sc = SJ.cached(fn.__name__, fn, **kw) x, y = tgt(sc, seed) z = 0.0 if subject == "coast" else float(sc.T.height(x, y)) cam = Iso((x, y, z), mpp or m0, 30, 0, w=CW, h=CH) img, info = paint(sc, cam, LIGHTS[light]) return S.label(S.up(Image.fromarray(img), 2), f"{label} ({info['colours']}c)") def far_cell(light, pitch=24, label=""): sc = SJ.cached("range_valley", SJ.range_valley, seed=8) cam = Persp.at((4500, 300, 3300), yaw=0, pitch=pitch, vfov=38, w=CW * 2, h=CH * 2) img, info = paint(sc, cam, LIGHTS[light], bands=[2500, 4500, 7000]) return S.label(Image.fromarray(img), f"{label} ({info['colours']}c)") def grid(cells, cols, title): w, h = cells[0].size rows = (len(cells) + cols - 1) // cols out = Image.new("RGB", (cols * (w + 4) + 4, rows * (h + 4) + 34), S.BG) from PIL import ImageDraw ImageDraw.Draw(out).text((6, 8), title, fill=S.FG, font=S._font(15)) for i, c in enumerate(cells): out.paste(c, (4 + (i % cols) * (w + 4), 30 + (i // cols) * (h + 4))) return out def run(kind): from multiprocessing import Pool jobs = [] if kind == "scale": scales = [0.3, 0.6, 1.2, 2.4, 4.8] for s in ["forest", "river", "cirque", "coast", "village"]: m0 = SUBJ[s][3] for f in (0.5, 1, 2, 4, 8) if s != "village" else (0.5, 1, 2, 4, 8): mpp = m0 * f / 2 if s != "forest" else scales[[0.5, 1, 2, 4, 8].index(f)] jobs.append((s, mpp, "afternoon", None, f"{s} {mpp:.2f} m/px")) cols, title = 5, "subject x scale (iso 30 deg, afternoon): the canopy hands off from spur strokes -> spire marks -> canopy surface" elif kind == "light": for s in ["forest", "river", "cirque", "coast", "village", "snow"]: for hr in HOURS: jobs.append((s, None, hr, None, f"{s} {hr}")) cols, title = 5, "subject x light/hour: one index canvas per cell, re-lit by the palette" elif kind == "seed": for s, seeds in (("cirque", [3, 13, 23, 33]), ("coast", [9, 19, 29, 39]), ("village", [7, 17, 27, 37]), ("scree", [4, 14, 24, 34]), ("cliff", [5, 15, 25, 35]), ("river", [2, 12, 22, 32])): for sd in seeds: jobs.append((s, None, "afternoon", sd, f"{s} seed {sd}")) cols, title = 4, "subject x seed" if kind in ("scale", "light", "seed"): # serial cache builds first for j in jobs: fn, kw = SUBJ[j[0]][0], dict(SUBJ[j[0]][1]) if j[3] is not None: kw["seed"] = j[3] SJ.cached(fn.__name__, fn, **kw) with Pool(4) as p: cells = p.starmap(cell, jobs) else: SJ.cached("range_valley", SJ.range_valley, seed=8) with Pool(4) as p: cells = p.starmap(far_cell, [(hr, 24, f"range far {hr}") for hr in HOURS] + [("afternoon", 38, "range far, pitch 38")]) cols, title = 3, "far view x light/hour (and a steeper pitch)" g = grid(cells, cols, title) g.save(os.path.join(ROOT, "sheets", f"sheet_{kind}.png")) print("sheets/sheet_%s.png" % kind, g.size) if __name__ == "__main__": for k in (sys.argv[1:] or ["scale", "light", "seed", "far"]): run(k) </pre></details><details class="step"><summary><code>Bash: Wait for plates to finish</code></summary><pre>until ! pgrep -f "plates.py" >/dev/null; do sleep 5; done; cat ~/work/pixelart-studies/aerial/scratch/plates.log | tail -20 # output: ('forest_slope_iso', 11) ('river_valley_iso', 31) ('cirque_iso', 35) ('scree_cliffs_iso', 18) ('coast_iso', 37) ('village_iso', 28) ('village_dusk_iso', 29) ('range_far', 64) ('range_far_evening', 64) ('cirque_far', 36)</pre></details><div class="step"><code>Read: aerial/plates/forest_slope_iso.png</code></div></div>  *95. aerial/plates/forest_slope_iso.png* <div class="steps"><div class="step"><code>Read: aerial/plates/cirque_iso.png</code></div></div>  *96. aerial/plates/cirque_iso.png* <div class="steps"><details class="step"><summary><code>Bash: Contact of remaining plates</code></summary><pre>cd ~/work/pixelart-studies/aerial/plates && python3 -c " from PIL import Image names=['river_valley_iso','scree_cliffs_iso','coast_iso','village_iso','range_far','cirque_far'] ims=[Image.open(n+'.png') for n in names] w=1300; hs=[int(i.size[1]*w/i.size[0]) for i in ims] o=Image.new('RGB',(w,sum(hs))) y=0 for i,h in zip(ims,hs): o.paste(i.resize((w,h)),(0,y)); y+=h o.save('../scratch/plates_all.png')" # output: (Bash completed with no output)</pre></details><div class="step"><code>Read: aerial/scratch/plates_all.png</code></div></div>  *97. aerial/scratch/plates_all.png* <div class="steps"><details class="step"><summary><code>Bash: Forest relief/tone, cirque/range/river fixes</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='tech_canopy.py'; s=open(p).read() s=s.replace(''' tone = np.where(trees["seed"] % 5 == 0, -1, np.where(trees["seed"] % 7 == 0, 1, 0))''',''' tone = np.where(trees["seed"] % 5 == 0, -1, np.where(trees["seed"] % 7 == 0, 1, 0)) # the slope under the stand carries through: trees on sun-facing ground one step up, on ground # turned away one step down (at 30 deg down the terrain form is read through the canopy's value) if "gn" in trees: tn = trees["gn"] @ sun tone = np.clip(tone + np.where(tn > 0.75, 1, 0) - np.where(tn < 0.45, 1, 0) - np.where(tn < 0.2, 1, 0), -2, 1)''') open(p,'w').write(s) p='painter.py'; s=open(p).read() s=s.replace(''' elif sc.trees is not None: TC.paint_trees(''',''' elif sc.trees is not None: if "gn" not in sc.trees: sc.trees["gn"] = T0.sample(T0.normals(), sc.trees["x"], sc.trees["y"]) TC.paint_trees(''') open(p,'w').write(s) p='subjects.py'; s=open(p).read() # forest_slope: more relief + gaps s=s.replace(" H = slope * Y + 0.07 * size * LF.eroded_fbm(X, Y, size * 0.7, octaves=6, seed=seed + 1) + 3 * LF.fbm(X, Y, 40, seed=seed + 4)", " H = slope * Y + relief * size * LF.eroded_fbm(X, Y, size * 0.6, octaves=7, seed=seed + 1) + 3 * LF.fbm(X, Y, 40, seed=seed + 4)") s=s.replace("spacing=5.0, hmean=20.0, lone_trees=12):","spacing=5.0, hmean=20.0, lone_trees=12, relief=0.07, gaps=0.0):") s=s.replace(" forest = np.where(clear, 0.0, 1.0)\n cover = dict(meadow=np.where(clear, 1.0, 0.4), forest=forest)", " if gaps:\n clear = clear | (LF.fbm(X, Y, 90, seed=seed + 12) > 0.62 - gaps)\n forest = np.where(clear, 0.0, 1.0)\n cover = dict(meadow=np.where(clear, 1.0, 0.4), forest=forest)") # cirque: gentler behind + hills s=s.replace(" H = (h_apron + h_wall - 0.7 * behind) * open_"," H = (h_apron + h_wall - 0.3 * np.minimum(behind, 220) + 50 * LF.fbm(X, Y, 300, seed=seed + 30) * np.clip(behind / 100, 0, 1)) * open_") # range: broader meadows s=s.replace(" meadow = np.clip(1 - slope / 35, 0, 1) * 0.8\n scree = ((slope > 25) & (slope < 40) & (z > treeline)).astype(float) * 0.9", " meadow = np.clip(1.3 - slope / 40, 0, 1) * 0.9\n scree = ((slope > 28) & (slope < 40) & (z > treeline + 200)).astype(float) * 0.9") # river valley: ragged forest edges and groves s=s.replace(" forest = np.clip(side + (patch > 0.35) * 0.9, 0, 1) * (dist > wloc / 2 + 6)", " edge_n = 0.25 * LF.fbm(X, Y, 40, seed=seed + 13)\n forest = np.clip(side + edge_n + (patch > 0.3) * 0.9, 0, 1) * (dist > wloc / 2 + 6)") open(p,'w').write(s) EOF rm -f ../cache/cirque_* ../cache/range_valley_* ../cache/river_valley_* ../cache/forest_slope_*; cd .. && python3 - <<'EOF' p='plates.py'; s=open(p).read() s=s.replace('dict(size=700, cell=1.0, seed=11, clearing=(0.5, 0.52, 45), slope=0.35, lone_trees=10)','dict(size=700, cell=1.0, seed=11, clearing=(0.5, 0.52, 45), slope=0.35, lone_trees=10, relief=0.16, gaps=0.1)') s=s.replace('''lambda sc: Iso((500, 760, sc.T.height(500, 760)), 1.0, 30, 0), "morning",''','''lambda sc: Iso((500, 720, sc.T.height(500, 720)), 1.0, 30, 0), "afternoon",''') s=s.replace('"headwall, cliff bands and scree apron, iso 1.0 m/px, morning"','"headwall, cliff bands and scree apron, iso 1.0 m/px"') s=s.replace('(SJ.cirque, dict(seed=3, snow=0.6), lambda sc: Persp.at((500, -350, 900), yaw=0, pitch=30, vfov=40)','(SJ.cirque, dict(seed=3, snow=0.6, size=1800, cell=3.0), lambda sc: Persp.at((900, 300, 700), yaw=0, pitch=30, vfov=40)') open(p,'w').write(s) p='sheets.py'; s=open(p).read() s=s.replace('dict(size=700, cell=1.0, seed=11, clearing=(0.5, 0.52, 45), slope=0.35, lone_trees=10)','dict(size=700, cell=1.0, seed=11, clearing=(0.5, 0.52, 45), slope=0.35, lone_trees=10, relief=0.16, gaps=0.1)') open(p,'w').write(s) EOF grep -n "cx, cy = size" lib/subjects.py # output: 96: cx, cy = size * 0.5, size * 0.56</pre></details><details class="step"><summary><code>Bash: Rerender plates</code></summary><pre>cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF' p='pal.py'; s=open(p).read() s=s.replace(''' b = np.array(body, float) * (0.6 + 0.4 * np.mean(light.sky_hor) / 200) t, h = light.sky_top, light.sky_hor''',''' t, h = light.sky_top, light.sky_hor # the body is the sky seen dimly through the Fresnel minimum plus the water's own colour: measured # tarn (Sawtooth) L*46 blue, river seen steeply L*23 (Cosumnes) -> body between the two b = np.array(body, float) * 0.7 + t * 0.28''') open(p,'w').write(s) EOF cd .. && nice -n 10 python3 plates.py > scratch/plates.log 2>&1; tail -12 scratch/plates.log # output: Command running in background with ID: b9abfml23. Output is being written to: (tmp) You will be notified when it completes. To check interim output, use Read on that file path. Session cwd remains ~/work/voxsim; directory changes made by the backgrounded command do not apply to subsequent commands.</pre></details><details class="step"><summary><code>Bash: Wait for plates and contact them</code></summary><pre>until ! pgrep -f "plates.py" >/dev/null; do sleep 5; done; tail -12 ~/work/pixelart-studies/aerial/scratch/plates.log; cd ~/work/pixelart-studies/aerial/plates && python3 -c " from PIL import Image names=['forest_slope_iso','river_valley_iso','cirque_iso','scree_cliffs_iso','range_far','cirque_far'] ims=[Image.open(n+'.png') for n in names] w=1300; hs=[int(i.size[1]*w/i.size[0]) for i in ims] o=Image.new('RGB',(w,sum(hs))) y=0 for i,h in zip(ims,hs): o.paste(i.resize((w,h)),(0,y)); y+=h o.save('../scratch/plates_all.png')" # output: ('forest_slope_iso', 11) ('river_valley_iso', 31) ('cirque_iso', 35) ('scree_cliffs_iso', 18) ('coast_iso', 37) ('village_iso', 28) ('village_dusk_iso', 29) ('range_far', 64) ('range_far_evening', 64) ('cirque_far', 64)</pre></details><div class="step"><code>Read: aerial/scratch/plates_all.png</code></div></div>  *98. aerial/scratch/plates_all.png* <div class="steps"><details class="step"><summary><code>Bash: Forest plate with relief tone</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 - <<'EOF' p='lib/tech_canopy.py'; s=open(p).read() s=s.replace("tone = np.clip(tone + np.where(tn > 0.75, 1, 0) - np.where(tn < 0.45, 1, 0) - np.where(tn < 0.2, 1, 0), -2, 1)", "dd = tn - sun[2]\n tone = np.clip(tone + np.where(dd > 0.12, 1, 0) - np.where(dd < -0.08, 1, 0) - np.where(dd < -0.25, 1, 0), -2, 1)") open(p,'w').write(s) for p in ('plates.py','sheets.py'): s=open(p).read(); s=s.replace("relief=0.16, gaps=0.1","relief=0.3, gaps=0.3"); open(p,'w').write(s) EOF nice -n 10 python3 plates.py forest_slope_iso && python3 -c " from PIL import Image; Image.open('plates/forest_slope_iso.png').resize((975,296)).save('scratch/fp.png')" # output: ('forest_slope_iso', 11)</pre></details><div class="step"><code>Read: aerial/scratch/fp.png</code></div></div>  *99. aerial/scratch/fp.png* <div class="steps"><details class="step"><summary><code>Bash: Render sheets and 640x360 plates</code></summary><pre>cd ~/work/pixelart-studies/aerial && (nice -n 10 python3 sheets.py scale light seed far > scratch/sheets.log 2>&1; nice -n 10 python3 plates.py cirque_iso village_iso coast_iso range_far --big >> scratch/sheets.log 2>&1) # output: Command running in background with ID: bth6j14zp. Output is being written to: (tmp) You will be notified when it completes. To check interim output, use Read on that file path. Session cwd remains ~/work/voxsim; directory changes made by the backgrounded command do not apply to subsequent commands.</pre></details><details class="step"><summary><code>Bash: Summarize crown numbers</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import json;d=json.load(open('measure/photo_stats.json')) for k,v in d.items(): if v['kind']=='crown': print(k, 'sp/r',round(v['crown_spacing_px']/v['crown_r_med_px'],2),'elong',round(v['elong_y_over_x'],2),'lit',round(v['lit_frac'],2),'Llit',round(v['L_lit_p85']),'Lgap',round(v['L_gap_p10']),'off',[round(x,2) for x in v['dark_offset_in_radii']]) "; ls studies plates sheets # output: conifer_near_dawn sp/r 2.44 elong 1.38 lit 0.35 Llit 19 Lgap 1 off [0.17, 0.02] conifer_mid_dawn sp/r 2.46 elong 0.43 lit 0.41 Llit 35 Lgap 5 off [0.09, 0.18] conifer_dense_overcast_near sp/r 2.4 elong 1.5 lit 0.51 Llit 53 Lgap 30 off [-0.02, -0.06] conifer_dense_overcast_far sp/r 2.33 elong 1.25 lit 0.56 Llit 60 Lgap 46 off [-0.05, -0.02] broadleaf_sun_near sp/r 2.31 elong 0.6 lit 0.55 Llit 70 Lgap 24 off [-0.02, -0.08] broadleaf_sun_mid sp/r 2.23 elong 0.8 lit 0.55 Llit 60 Lgap 7 off [-0.01, -0.17] broadleaf_sun_far sp/r 2.44 elong 0.43 lit 0.52 Llit 64 Lgap 30 off [0.0, 0.28] sparse_conifer_on_meadow sp/r 2.89 elong 0.73 lit 0.52 Llit 66 Lgap 13 off [-0.25, -0.1] far_slope_dotted_trees sp/r 2.73 elong 0.71 lit 0.5 Llit 75 Lgap 43 off [-0.16, -0.12] plates: cirque_far.png cirque_far_native.png cirque_iso.png cirque_iso_native.png coast_iso.png coast_iso_native.png forest_slope_iso.png forest_slope_iso_native.png range_far.png range_far_evening.png range_far_evening_native.png range_far_native.png river_valley_iso.png river_valley_iso_native.png scree_cliffs_iso.png scree_cliffs_iso_native.png village_dusk_iso.png village_dusk_iso_native.png village_iso.png village_iso_native.png sheets: studies: canopy.png cliff_snow.png coast.png huts_fire.png river.png scree.png</pre></details><details class="step"><summary><code>Bash: Measure my canopy with same statistics</code></summary><pre>cd ~/work/pixelart-studies/aerial && python3 -c " import sys; sys.path.insert(0,'.') from measure_photos import crown_stats from PIL import Image for f in ['plates/forest_slope_iso_native.png','plates/village_iso_native.png']: im=Image.open(f).convert('RGB').resize((960,540),Image.NEAREST) st=crown_stats(im,(0,300,960,540)) print(f, 'sp/r',round(st['crown_spacing_px']/st['crown_r_med_px'],2),'elong',round(st['elong_y_over_x'],2),'lit',round(st['lit_frac'],2),'Llit',round(st['L_lit_p85']),'Lgap',round(st['L_gap_p10'])) " # output: ~/work/pixelart-studies/aerial/measure_photos.py:66: RuntimeWarning: Mean of empty slice. offs.append(((xx + x0 - x).mean() / rr, (yy + y0 - y).mean() / rr)) ~/miniconda3/lib/python3.12/site-packages/numpy/core/_methods.py:129: RuntimeWarning: invalid value encountered in scalar divide ret = ret.dtype.type(ret / rcount) plates/forest_slope_iso_native.png sp/r 2.21 elong 1.75 lit 0.56 Llit 37 Lgap 5 plates/village_iso_native.png sp/r 2.49 elong 1.44 lit 0.54 Llit 37 Lgap 5</pre></details><details class="step"><summary><code>Bash: Check sheets log</code></summary><pre>tail -20 ~/work/pixelart-studies/aerial/scratch/sheets.log; ls ~/work/pixelart-studies/aerial/sheets # output: During handling of the above exception, another exception occurred: Traceback (most recent call last): File "~/miniconda3/lib/python3.12/multiprocessing/process.py", line 314, in _bootstrap self.run() File "~/miniconda3/lib/python3.12/multiprocessing/process.py", line 108, in run self._target(*self._args, **self._kwargs) File "~/miniconda3/lib/python3.12/multiprocessing/pool.py", line 136, in worker put((job, i, (False, wrapped))) File "~/miniconda3/lib/python3.12/multiprocessing/queues.py", line 399, in put self._writer.send_bytes(obj) File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 200, in send_bytes self._send_bytes(m[offset:offset + size]) File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 427, in _send_bytes self._send(header + buf) File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 384, in _send n = write(self._handle, buf) ^^^^^^^^^^^^^^^^^^^^^^^^ BrokenPipeError: [Errno 32] Broken pipe</pre></details><details class="step"><summary><code>Bash: Find root error</code></summary><pre>grep -n -E "Error|error" ~/work/pixelart-studies/aerial/scratch/sheets.log | grep -v BrokenPipe | head; grep -n "Traceback" -A 12 ~/work/pixelart-studies/aerial/scratch/sheets.log | head -40; df -h ~ | tail -1 # output: 2:Traceback (most recent call last): 3- File "~/miniconda3/lib/python3.12/multiprocessing/pool.py", line 131, in worker 4- put((job, i, result)) 5- File "~/miniconda3/lib/python3.12/multiprocessing/queues.py", line 399, in put 6- self._writer.send_bytes(obj) 7- File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 200, in send_bytes 8- self._send_bytes(m[offset:offset + size]) 9- File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 420, in _send_bytes 10- self._send(header) 11- File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 384, in _send 12- n = write(self._handle, buf) 13- ^^^^^^^^^^^^^^^^^^^^^^^^ 14-BrokenPipeError: [Errno 32] Broken pipe -- 18:Traceback (most recent call last): 19- File "~/miniconda3/lib/python3.12/multiprocessing/process.py", line 314, in _bootstrap 20- self.run() 21- File "~/miniconda3/lib/python3.12/multiprocessing/process.py", line 108, in run 22- self._target(*self._args, **self._kwargs) 23- File "~/miniconda3/lib/python3.12/multiprocessing/pool.py", line 136, in worker 24- put((job, i, (False, wrapped))) 25- File "~/miniconda3/lib/python3.12/multiprocessing/queues.py", line 399, in put 26- self._writer.send_bytes(obj) 27- File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 200, in send_bytes 28- self._send_bytes(m[offset:offset + size]) 29- File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 427, in _send_bytes 30- self._send(header + buf) /dev/disk3s5 926Gi 804Gi 80Gi 91% 10M 840M 1% /System/Volumes/Data</pre></details><details class="step"><summary><code>Bash: Rerun sheets detached with nohup</code></summary><pre>cd ~/work/pixelart-studies/aerial && nohup sh -c 'for k in scale light seed far; do nice -n 10 python3 sheets.py $k; done; nice -n 10 python3 plates.py cirque_iso village_iso coast_iso range_far --big' > scratch/sheets.log 2>&1 & echo started # output: started</pre></details></div> Now writing NOTES.md while sheets render. <div class="steps"><details class="step"><summary><code>Write: aerial/NOTES.md</code></summary><pre># Aerial: land seen from above and far away, in Ferrari's language Everything lives in `~/work/pixelart-studies/aerial/`. | what | where | |---|---| | oblique photos (~480, credits and licences) | `refs/<query>/`, `refs/sources.tsv` (all folders merged) | | Ferrari's Living Worlds scenes as indexed data | `refs/ferrari_lw/*.json` (+ `.png`), fetched from Canvas Cycle | | photo measurements | `measure_photos.py` -> `measure/photo_stats.json`, `measure/crowns_*.png` (the detected crowns drawn on the photo, for checking by eye); `measure_haze.py` -> `measure/haze.json` | | technique studies (photo, mine, Ferrari at 8x) | `studies/canopy.png`, `river.png`, `scree.png`, `cliff_snow.png`, `huts_fire.png`, `coast.png` (made by `study_canopy.py`, `study_river.py`, `study_mountain.py`, `study_objects.py`) | | scene plates beside an oblique photo of similar framing | `plates/*.png` (+ `*_native.png`, the raw 320x180 frame; `*_640*` the 640x360 versions); `plates.py` | | sweeps | `sheets/sheet_scale.png`, `sheet_light.png`, `sheet_seed.png`, `sheet_far.png`; `sheets.py` | | the code | `lib/` (below) |
Bash: Wait for scale and light sheets
until [ -f ~/work/pixelart-studies/aerial/sheets/sheet_light.png ] || grep -q Traceback ~/work/pixelart-studies/aerial/scratch/sheets.log; do sleep 5; done; grep -v Warning ~/work/pixelart-studies/aerial/scratch/sheets.log | tail -5
# output:
File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 384, in _send
n = write(self._handle, buf)
^^^^^^^^^^^^^^^^^^^^^^^^
BrokenPipeError: [Errno 32] Broken pipe
warnings.warn('resource_tracker: There appear to be %d 'Bash: Inspect failure start
cd ~/work/pixelart-studies/aerial; head -30 scratch/sheets.log; ls sheets; pgrep -fl sheets.py | head
# output:
sheets/sheet_scale.png (1624, 1054)
Process SpawnPoolWorker-4:
Traceback (most recent call last):
File "~/miniconda3/lib/python3.12/multiprocessing/pool.py", line 131, in worker
put((job, i, result))
File "~/miniconda3/lib/python3.12/multiprocessing/queues.py", line 399, in put
self._writer.send_bytes(obj)
File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 200, in send_bytes
self._send_bytes(m[offset:offset + size])
File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 420, in _send_bytes
self._send(header)
File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 384, in _send
n = write(self._handle, buf)
^^^^^^^^^^^^^^^^^^^^^^^^
BrokenPipeError: [Errno 32] Broken pipe
During handling of the above exception, another exception occurred:
Traceback (most recent call last):
File "~/miniconda3/lib/python3.12/multiprocessing/process.py", line 314, in _bootstrap
self.run()
File "~/miniconda3/lib/python3.12/multiprocessing/process.py", line 108, in run
self._target(*self._args, **self._kwargs)
File "~/miniconda3/lib/python3.12/multiprocessing/pool.py", line 136, in worker
put((job, i, (False, wrapped)))
File "~/miniconda3/lib/python3.12/multiprocessing/queues.py", line 399, in put
self._writer.send_bytes(obj)
File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 200, in send_bytes
self._send_bytes(m[offset:offset + size])
File "~/miniconda3/lib/python3.12/multiprocessing/connection.py", line 427, in _send_bytes
sheet_scale.png
40429 python3 sheets.py camera_light
40431 python3 sheets.py silver_seasonRead: aerial/sheets/sheet_scale.png
100. aerial/sheets/sheet_scale.png
Bash: Wait for all sheets and big plates
until ! pgrep -f "aerial.*sheets.py|sheets.py (light|seed|far)" >/dev/null && ! pgrep -f "plates.py" >/dev/null && [ -f ~/work/pixelart-studies/aerial/sheets/sheet_far.png ]; do sleep 10; done; ls ~/work/pixelart-studies/aerial/sheets ~/work/pixelart-studies/aerial/plates | grep -E "sheet|640" # output: Command did not complete within its 600s timeout and was moved to the background (ID: bkzehcdhj). Output is being written to: (tmp) You will be notified when it completes. To check interim output, use Read on that file path.
Bash: Check progress
ls ~/work/pixelart-studies/aerial/sheets; tail -3 ~/work/pixelart-studies/aerial/scratch/sheets.log | cut -c1-200
# output:
sheet_scale.png
BrokenPipeError: [Errno 32] Broken pipe
~/miniconda3/lib/python3.12/multiprocessing/resource_tracker.py:254: UserWarning: resource_tracker: There appear to be 6 leaked semaphore objects to clean up at shutdown
warnings.warn('resource_tracker: There appear to be %d 'Bash: See running processes
ps aux | grep -E "sheets.py|plates.py" | grep -v grep | head; grep -n "sheets/sheet" ~/work/pixelart-studies/aerial/scratch/sheets.log # output: 1:sheets/sheet_scale.png (1624, 1054)
Bash: Relaunch sheets in a new session
cd ~/work/pixelart-studies/aerial && cat > scratch/runall.sh <<'EOF'
cd ~/work/pixelart-studies/aerial
for k in light seed far; do nice -n 10 python3 sheets.py $k; done
nice -n 10 python3 plates.py cirque_iso village_iso coast_iso range_far --big
echo ALLDONE
EOF
python3 -c "
import subprocess,os
subprocess.Popen(['sh','scratch/runall.sh'],stdout=open('scratch/sheets.log','w'),stderr=subprocess.STDOUT,start_new_session=True)"; echo ok
# output:
okBash: Wait for runall to finish
until grep -q -E "ALLDONE|Traceback \(most recent call last\):\n File .*sheets.py" ~/work/pixelart-studies/aerial/scratch/sheets.log || ! pgrep -f runall.sh >/dev/null; do sleep 10; done; grep -E "sheets/|ALLDONE|\('" ~/work/pixelart-studies/aerial/scratch/sheets.log
# output:
Command running in background with ID: bwvulypkq. Output is being written to: (tmp) You will be notified when it completes. To check interim output, use Read on that file path.Bash: Cirque floor slabs and krummholz
cd ~/work/pixelart-studies/aerial/lib && python3 - <<'EOF'
p='subjects.py'; s=open(p).read()
old=''' meadow = np.clip(1 - slope / 28, 0, 1) * 0.7
snow_w = snow * 1.2'''
new=''' # the cirque floor (photos: Sawtooth, Watson River, Opabin): pale glaciated rock slabs with pockets
# of turf and krummholz, not a lawn
slabs = (LF.fbm(X, Y, 35, seed=seed + 40) > 0.05) & (r < R0 + 20)
meadow = np.clip(1 - slope / 28, 0, 1) * 0.7 * np.where(slabs, 0.3, 1.0)
snow_w = snow * 1.2'''
assert old in s
s=s.replace(old,new)
s=s.replace(''' rock=cliff * 1.1 + 0.6 * crest + rockpatch * (slope > 20), snow=snow_m.astype(float) * 1.5)''',''' rock=cliff * 1.1 + 0.6 * crest + rockpatch * (slope > 20) + slabs * 0.5, snow=snow_m.astype(float) * 1.5)''')
s=s.replace(''' forest = ((slope < 22) & (r > 300) & (open_ < 0.6) & (rough > -0.05) & (Y < cy)).astype(float)
cover["forest"] = forest
tr = TC.scatter_trees(T, forest * 0.85, 6.0, rng, hmean=16) if trees else None''',''' forest = ((slope < 22) & (r > 300) & (open_ < 0.6) & (rough > -0.05) & (Y < cy)).astype(float)
cover["forest"] = forest
krumm = ((slope < 25) & (r < R0 + 40) & ~tarn & (LF.fbm(X, Y, 25, seed=seed + 41) > 0.15)).astype(float) * 0.35
tr = TC.scatter_trees(T, np.maximum(forest * 0.85, krumm), 6.0, rng, hmean=12) if trees else None''')
open(p,'w').write(s)
EOF
echo ok
# output:
okBash: Wait for runall result
until [ -f (tmp) ] && grep -q . (tmp) do sleep 10; done; cat (tmp)
# output:
sheets/sheet_light.png (1624, 1258)
sheets/sheet_seed.png (1300, 1258)
sheets/sheet_far.png (976, 442)
('cirque_iso', 37)
('village_iso', 28)
('coast_iso', 37)
('range_far', 64)
ALLDONE
[exited with code 0]Read: aerial/sheets/sheet_light.png
101. aerial/sheets/sheet_light.png
Read: aerial/sheets/sheet_seed.png
102. aerial/sheets/sheet_seed.png
Read: aerial/sheets/sheet_far.png
103. aerial/sheets/sheet_far.png
Bash: Lift low-sun ambient, rerender cirque plates and light sheet
cd ~/work/pixelart-studies/aerial && python3 - <<'EOF'
p='lib/pal.py'; s=open(p).read()
s=s.replace('"morning": Light("morning", 14, 105, sun=(1.25, 1.0, 0.72), sky=(0.20, 0.26, 0.40)','"morning": Light("morning", 14, 105, sun=(1.25, 1.0, 0.72), sky=(0.26, 0.30, 0.46)')
s=s.replace('"evening": Light("evening", 7, 290, sun=(1.35, 0.78, 0.45), sky=(0.22, 0.20, 0.40)','"evening": Light("evening", 7, 290, sun=(1.35, 0.78, 0.45), sky=(0.30, 0.25, 0.50)')
open(p,'w').write(s)
EOF
rm -f cache/cirque_*.pkl
cat > scratch/runall2.sh <<'EOF'
cd ~/work/pixelart-studies/aerial
nice -n 10 python3 plates.py cirque_iso scree_cliffs_iso cirque_far village_dusk_iso range_far_evening
nice -n 10 python3 plates.py cirque_iso --big
nice -n 10 python3 sheets.py light
nice -n 10 python3 study_mountain.py
echo ALLDONE
EOF
python3 -c "
import subprocess
subprocess.Popen(['sh','scratch/runall2.sh'],stdout=open('scratch/run2.log','w'),stderr=subprocess.STDOUT,start_new_session=True)"; echo ok
# output:
okMeanwhile, let me look at the 640 plates rendered earlier.
Read: aerial/plates/village_iso_640.pngRead: aerial/plates/coast_iso.png
104. aerial/plates/coast_iso.png
105. aerial/plates/village_iso_640.png
Bash: Wait for rerender batch
until grep -q ALLDONE ~/work/pixelart-studies/aerial/scratch/run2.log || ! pgrep -f runall2.sh >/dev/null; do sleep 10; done; grep -E "\('|sheets/|studies/|ALLDONE|Error" ~/work/pixelart-studies/aerial/scratch/run2.log | grep -v BrokenPipe
# output:
('cirque_iso', 34)
('scree_cliffs_iso', 25)
('cirque_far', 64)
('village_dusk_iso', 29)
('range_far_evening', 64)
('cirque_iso', 37)
sheets/sheet_light.png (1624, 1258)
studies/scree.png
studies/cliff_snow.png
ALLDONEBash: Contact rerendered plates
cd ~/work/pixelart-studies/aerial/plates && python3 -c "
from PIL import Image
names=['cirque_iso','scree_cliffs_iso','cirque_far','village_dusk_iso','range_far_evening']
ims=[Image.open(n+'.png') for n in names]
w=1300; hs=[int(i.size[1]*w/i.size[0]) for i in ims]
o=Image.new('RGB',(w,sum(hs)))
y=0
for i,h in zip(ims,hs): o.paste(i.resize((w,h)),(0,y)); y+=h
o.save('../scratch/plates2.png')"
# output:
(Bash completed with no output)Read: aerial/scratch/plates2.png
106. aerial/scratch/plates2.png
Bash: Update NOTES failures; check sizes
cd ~/work/pixelart-studies/aerial && du -sh cache scratch refs; python3 - <<'EOF'
p='NOTES.md'; s=open(p).read()
old_start=s.index('- **Cirque iso**'); old_end=s.index('- **Headwall/scree plate**')
s=s[:old_start]+'''- **Cirque iso**: the headwall geometry is convincing. The floor was first a flat saturated lawn;
now it is glaciated slabs with turf pockets and krummholz (after the Sawtooth/Opabin photos), which
is closer but still greener than the photo. Snow cover is thresholded noise, not accumulation
physics, and it goes salt-and-pepper at far scale (`cirque_far`).
'''+s[old_end:]
s=s.replace('''- **Headwall/scree plate**: the scree apron barely reaches the frame; the talus cones only read
in the dedicated study (`talus_cone` subject). In the cirque the apron is too shallow and loses to
meadow.''','''- **Headwall/scree plate**: blocks, krummholz and the grain of the apron read; the fans themselves
(the Isfjorden cones' clean conical silhouettes) only read in the dedicated `talus_cone` study.
- **Large crowns (640x360 at 0.18 m/px, crowns > 20 px)**: the tier notches every 2-3 rows read as
horizontal "venetian blind" banding across the whole forest (`plates/village_iso_640.png`). The spur
stroke needs irregular tier spacing and ragged spur lengths above ~15 px.
- **Low sun**: the photos really are that dark (Deer Mountain at dawn: canopy median L\\*8); a literal
palette made the evening forest five colours of near-black. I lifted the sky ambient for morning
and evening (a Ferrari move, not a measured one); forests at evening are still the weakest cells in
`sheet_light`.
- **Seeds**: coast and talus seeds vary only noise at the default framing (the cove and the cone are
fixed shapes), so their `sheet_seed` rows look nearly identical; cirque, village, river and cliff
vary properly.''')
open(p,'w').write(s)
EOF
grep -n "Low sun" NOTES.md | head -2
# output:
596M cache
19M scratch
244M refs
245:- **Low sun**: the photos really are that dark (Deer Mountain at dawn: canopy median L\*8); a literal
[This command modified 1 file you've previously read: ../pixelart-studies/aerial/NOTES.md. Call Read before editing.]Bash: Remove rebuildable cache and scratch
cd ~/work/pixelart-studies/aerial && rm -rf cache scratch lib/__pycache__ __pycache__ && ls && ls lib studies plates sheets measure | head -80 # output: NOTES.md lib measure measure_haze.py measure_photos.py plates plates.py refs sheets sheets.py studies study_canopy.py study_mountain.py study_objects.py study_river.py lib: camera.py canvas.py dither.py landform.py look.py noise.py painter.py pal.py study.py subjects.py tech_canopy.py tech_ground.py tech_objects.py tech_rock.py tech_water.py terrain.py measure: crowns_broadleaf_sun_far.png crowns_broadleaf_sun_mid.png crowns_broadleaf_sun_near.png crowns_conifer_dense_overcast_far.png crowns_conifer_dense_overcast_near.png crowns_conifer_mid_dawn.png crowns_conifer_near_dawn.png crowns_far_slope_dotted_trees.png crowns_sparse_conifer_on_meadow.png haze.json photo_stats.json photo_stats_atlas.png plates: cirque_far.png cirque_far_native.png cirque_iso.png cirque_iso_640.png cirque_iso_640_native.png cirque_iso_native.png coast_iso.png coast_iso_640.png coast_iso_640_native.png coast_iso_native.png forest_slope_iso.png forest_slope_iso_native.png range_far.png range_far_640.png range_far_640_native.png range_far_evening.png range_far_evening_native.png range_far_native.png river_valley_iso.png river_valley_iso_native.png scree_cliffs_iso.png scree_cliffs_iso_native.png village_dusk_iso.png village_dusk_iso_native.png village_iso.png village_iso_640.png village_iso_640_native.png village_iso_native.png sheets: sheet_far.png sheet_light.png sheet_scale.png sheet_seed.png studies: canopy.png cliff_snow.png coast.png huts_fire.png river.png scree.png
Bash: Note cache deletion
cd ~/work/pixelart-studies/aerial && sed -i '' 's|Scenes are built once and cached in `cache/` (delete a file there after changing its builder;|Scenes are built once and cached in `cache/` (deleted at hand-off to save disk: ~600 MB, rebuilt on first run; delete a file there after changing its builder;|' NOTES.md && grep -n "cache/" NOTES.md | head -2 # output: 20:Scenes are built once and cached in `cache/` (deleted at hand-off to save disk: ~600 MB, rebuilt on first run; delete a file there after changing its builder;
SubagentHandback: I've sent my report to the parent session. The deliverables are in ~/work/pixelart-studies/aerial/, and NOTES.md covers the measurements, each technique and a list of what fails.