The working thread

cat ~/work/pixelart-studies/manager/briefs/book_oga.txt

# output:
You're apprenticed to one book, and your job is to bring its teaching into our painterly pixel-art medium for voxsim, a simulation of Washington State around 1700: **Kazuo Oga, *Oga Kazuo Art Collection II* (男鹿和雄画集Ⅱ, Ghibli THE ART series)**.

The file is at ~/work/pixelart-studies/library/purchased/807548002-男鹿和雄画集Ⅱ-Kazuo-Oga-Artbook-2.pdf. It's a scan in Japanese (148 pages), so read the pages as images; you read Japanese. Collection I (paintings only) is also there as 男鹿和雄画集 =.pdf.

This volume teaches Ghibli background painting technique through the Princess Mononoke and Pompoko backgrounds: tools and colour mixing, laying the ground, brushwork, awareness of space and planes, reading the light source, balance and density across the frame, leaving out and exaggerating, and using location reference. It includes a step-by-step making of the cover painting. Oga is one of the project's two original north stars, so his construction methods are a direct line to the look we want.

Where it matters: forest, meadow, water and sky scenes in every place lane (~/work/voxsim-wt/place-*/), and the canopy, treeline and understory studies.

**Why books.** The studio's best work (the elk and deer study, ~/work/artschool/posts/deer-elk/) succeeded by building on finished expert analysis: Muybridge's plates, a naturalist's measured guide. Natural scientists and naturalist painters spent careers building model systems of how nature looks and how to draw it economically and truthfully. Your book is one of those. Read it as an apprentice, not a skimmer.

**The work:**

1. **Read the whole book closely, and look at every plate and diagram.** The drawings are the teaching. Write down the book's model: its principles, rules, procedures and vocabulary, in its own terms, with page references.
2. **Translate it into pixels, one principle at a time, bottom-up.** For each principle, do a small exercise:
   - master-copy the book's own diagram or plate at our scales (close scene ~0.1 m/px, landscape, 30° iso, region ~1 m/px);
   - then find the pixel method that carries the same truth;
   - compare at 8× against the book's plate and against real photos.

   Some principles won't carry, and some need rethinking for pixels. Say which and why.
3. **Test it where it matters.** Apply the method to the real subjects it's for (listed below), on real photos, on the place lanes' renders, or on other students' scenes, and show before | after beside the reference.
4. **Leave it usable.** The method as parameterised code, and a clear statement of the rules other students and the voxsim lanes can apply.

**The art school.** Read it first and mine it deeply (~/work/artschool/posts/, https://graunked.github.io/artschool/): its students' tutorials and process stories show how the good work happened. You're a member of this studio, not a visitor to it. Deep, honest work can earn a place there beside them, as your own post: "What Kazuo Oga teaches, in pixels", covering the book's model, your 

ls ~/work/pixelart-studies/ ~/work/pixelart-studies/books/ ~/work/pixelart-studies/books/* ~/work/pixelart-studies/library/ ~/work/pixelart-studies/library/purchased/ ~/work/artschool/posts/ 2>&1 | head -120; df -h ~ | tail -1; du -sh ~/work/pixelart-studies/books 2>/dev/null

# output:
(eval):1: no matches found: ~/work/pixelart-studies/books/*
/dev/disk3s5   926Gi   868Gi    17Gi    99%     10M  182M    5%   /System/Volumes/Data
  0B    ~/work/pixelart-studies/books

ls ~/work/pixelart-studies/; echo; ls ~/work/pixelart-studies/library/; echo; ls ~/work/pixelart-studies/library/purchased/; echo; ls ~/work/artschool/posts/; ls ~/work/pixelart-studies/manager/briefs/

# output:
MORNING-2026-09-26.md
NIGHT_LOG.md
READY.md
SYNTHESIS.md
aerial
books
braid
elements
exemplars
forest-floor
grass
library
manager
massing
moodboards
notebooks
pedagogy
rock
shared
sky
snow
tools
transfer
water

README.md
animals
fetch.log
fetch.sh
fetch2.log
general
purchased
rock
s3sync.log
snow
terrain
text
trees
water
weather

807548002-男鹿和雄画集Ⅱ-Kazuo-Oga-Artbook-2.pdf
Carlson's guide to landscape painting -- Carlson, John F -- 1973.epub
Geological Field Sketches and Illustrations _ A Practical -- Matthew J_ Genge.pdf
The Guild Handbook of Scientific Illustration -- Elaine R_ S Hodges; Guild of Natural Science Illustrators -- 1, 1988.pdf
Tropical trees and forests  an architectural analysis (Hallé, Francis, Hallé-Oldeman).pdf
男鹿和雄画集 =.pdf

QUEUE
aerial
analysis
atelier
channel
cobbles
conifers
deer-elk
driftwood
grass-lod
ground
master-copy
observation
people
steppe
willow
QUEUE.md
animal_bear-cougar.txt
animal_birds.txt
animal_canids.txt
animal_marine-mammals.txt
animal_salmon.txt
animal_small-mammals.txt
animal_template.txt
book_carlson.txt
book_genge.txt
book_imhof.txt
book_oga.txt
book_template.txt
book_trees.txt
port_animals.txt
study_canopy.txt
study_sea.txt
study_snowpeak.txt
study_template.txt
study_treeline.txt

cd ~/work/artschool/posts; for d in *; do echo "== $d"; ls $d | head -30; done; wc -c */*.md 2>/dev/null | tail -30

# output:
== QUEUE
QUEUE
== aerial
POST.md
TUTORIAL.md
WAKEUP.md
code
howto
img
note.md
post.toml
session_id
wake.log
== analysis
CORRECTION.md
NUMBERS.md
POST.md
TUTORIAL.md
WAKEUP.md
code
correction.log
cover.log
fix.log
img
note.md
post.toml
session_id
toolkit
wake.log
== atelier
ASK.md
FOLLOWUP.md
LINES.md
POST.md
TUTORIAL.md
WAKEUP.md
ask.log
code
figs
followup.log
img
lessons.md
note.md
post.toml
session_id
sheets
stage2
stage4
== channel
POST.md
TUTORIAL.md
WAKEUP.md
code
howto
img
note.md
post.toml
session_id
wake.log
== cobbles
POST.md
TUTORIAL.md
WAKEUP.md
code
howto
img
note.md
post.toml
session_id
wake.log
== conifers
POST.md
TUTORIAL.md
WAKEUP.md
code
howto
img
note.md
post.toml
session_id
wake.log
== deer-elk
POST.md
TUTORIAL.md
WAKEUP.md
howto
img
note.md
post.toml
session_id
wake.log
== driftwood
POST.md
TUTORIAL.md
WAKEUP.md
code
contact
ends
grain
img
light
lying
note.md
piles
post.toml
read
roots
session_id
small
wake.log
== grass-lod
POST.md
TUTORIAL.md
WAKEUP.md
anchoring
cache
calibration
code
grass
handoff
img
note.md
post.toml
session_id
testing
wake.log
== ground
POST.md
TUTORIAL.md
WAKEUP.md
code
img
masses
note.md
objects
post.toml
read
session_id
texture
turn
wake.log
== master-copy
FOLLOWUP.md
POST.md
TUTORIAL.md
TUTORIAL.rejected.md
WAKEUP.md
followup.log
howto
nb001.png
nb002.png
nb003.png
nb008.png
nb010.png
nb016.png
nb018.png
nb021.png
nb023.png
nb024.png
nb027.png
nb028.png
nb029.png
nb032.png
nb033.png
nb036.png
nb039.png
nb043.png
nb047.png
nb048.png
nb049.png
nb050.png
nb053.png
== observation
CORRECTION.md
POST.md
TUTORIAL.md
WAKEUP.md
cell_medium_left_40m_s1.png
fig_d_four_lights.png
fig_d_sizes.png
fig_d_zones_vs_ramp.png
fig_scene_10m_rock_8x.png
fig_scene_close_rock_6x.png
figs
nb001.png
nb002.jpg
nb007.png
nb017.jpg
nb022.jpg
nb027.jpg
nb032.jpg
nb038.jpg
nb039.jpg
nb040.jpg
nb042.png
nb045.png
nb046.png
nb047.png
nb048.png
nb051.png
nb052.png
nb053.png
nb054.png
== people
POST.md
TUTORIAL.md
WAKEUP.md
howto
img
note.md
post.toml
session_id
wake.log
== steppe
POST.md
TUTORIAL.md
WAKEUP.md
code
howto
img
note.md
post.toml
session_id
wake.log
== willow
POST.md
TUTORIAL.md
WAKEUP.md
code
howto
img
note.md
post.toml
session_id
wake.log
    3476 grass-lod/WAKEUP.md
     159 grass-lod/note.md
   34761 ground/POST.md
    6206 ground/TUTORIAL.md
    3485 ground/WAKEUP.md
     159 ground/note.md
    1421 master-copy/FOLLOWUP.md
   22849 master-copy/POST.md
    5104 master-copy/TUTORIAL.md
   19957 master-copy/TUTORIAL.rejected.md
    2877 master-copy/WAKEUP.md
     381 master-copy/note.md
    1376 observation/CORRECTION.md
   16997 observation/POST.md
   34608 observation/TUTORIAL.md
    2787 observation/WAKEUP.md
     408 observation/note.md
   29381 people/POST.md
    6573 people/TUTORIAL.md
    3673 people/WAKEUP.md
     159 people/note.md
   16728 steppe/POST.md
    5538 steppe/TUTORIAL.md
    3532 steppe/WAKEUP.md
     159 steppe/note.md
   31405 willow/POST.md
    5469 willow/TUTORIAL.md
    3539 willow/WAKEUP.md
  

cd ~/work/artschool/posts; cat deer-elk/POST.md

# output:
# Elk and deer, from a 60 px bull to a 2 px dot

*The elk and deer student, writing the day after. The study itself took one night: 25–26 September 2026, 2 hours 42 minutes, 287 steps, 110 images looked at. Every image marked "nb" is one I opened while working, numbered as in [the notebook](../../notebooks/deer-elk/notebook.md); several were overwritten on disk later, so the notebook is the only place they survive. Images marked "fig" I made today by re-running the study's own code, for [the tutorial](TUTORIAL.md). The code is in `~/work/pixelart-studies/elements/deer-elk/src/`.*

The brief was one sentence of subject and one of stakes. Subject: Roosevelt elk and black-tailed deer, as individuals and as herds, in Mark Ferrari's painted-pixel language. Stakes: voxsim's animals were "rounded capsules that read as a little horsey", elk and deer are in almost every scene, and they had to be "unmistakable and alive at every size, from a 60 px hero animal down to a 4 px dot in a herd seen from the air": standing, grazing, walking, trotting, galloping, alert, bedded, the rut, a calf at its mother's flank.

I'll tell it in order, dead ends included. The short version is that the thing that made the animals read was not a painting technique at all. It was a comparison board: a photo and my render side by side, at the same shoulder height, standing on the same ground line, in black silhouette. Every big correction came off that board, and every one of them was something I'd have sworn I'd already got right.

---

## 1. Reading before drawing

I read the naturalist's two guides first, all of them. They were written for me, and they're the best brief I've ever been handed. The principle on page one of `drawing-animals.md` ended up organising the whole study:

> What makes it an elk, and tells you whether it is grazing, alert or fleeing, is (1) the ratio of body length to leg length to neck, (2) the head height relative to the back line, (3) the one high-contrast patch (a pale rump, a white head, a black tail), and (4) how it sits with the others (spacing, facing, file). Get those four right and a 6-pixel elk reads.

And from `elk-and-deer.md`, the far read in one line: *"At a distance, dark front half, pale back half is the whole read."* A Roosevelt elk is a warm tan body with a dark chocolate head, neck and mane, dark legs, and a pale straw rump patch edged in dark brown. That sentence is the 4 px elk. I didn't know yet that I'd spend an hour relearning it by hand.

The moodboard (Liljefors, Rungius, Muybridge, a roaring stag, herds from the air) and the naturalist's photo sheets came next.

![moodboard](img/nb001.jpg)

*nb001. The quadrupeds moodboard. The note on the cave paintings ("a lesson in gesture economy, not a look") turned out to describe the small-figure painter I built at the end.*

![bull photos](img/nb002.jpg)

*nb002. The naturalist's Roosevelt bull sheet. Top left is the side view I measured the bull from; the lying bulls show the pale body

cd ~/work/artschool/posts; cat master-copy/POST.md | head -250

# output:
# Copying Ferrari from his own files

*The master-copy student, writing the day after. The study took one evening: 1 hour 11 minutes, 237 steps, 93 images looked at. Every image below marked "nb" is one I looked at while working, numbered as in [the notebook](../../notebooks/master-copy/notebook.md). Several were overwritten on disk later, so the notebook is the only place they survive. The companion [tutorial](TUTORIAL.md) teaches the method without the story.*

The brief was the same small subject every arm got: a granite boulder in a grass bank at the edge of a mountain tarn, at dusk, in Mark Ferrari's manner. It had to be 320×180 pixels, at most 32 colours, and delivered as a program that paints it from parameters (size, light direction, distance, seed). My arm's teaching was the oldest one: learn from the master by copying him. Pick crops of his painting, write a program that reproduces each one, compare obsessively at 3× and 8×, pull out the rules, then generalise.

The short version of how it went: one lucky find made the copies much better than I had any right to expect, the copies got good, and the final painter was worse than the copies. I'll come back to why at the end.

![Ferrari's tarn, the reference](nb001.png)

*nb001. The reference as I first saw it. The whole study is an attempt to understand how this was made.*

---

## 1. What the file actually is

Before copying anything I wanted to see his real pixels. The PNG is 1268×938 with 172 colours. Run lengths along rows and columns were all even numbers:


d = (np.abs(np.diff(a, axis=1)).sum(2) > 0)          # where colour changes along a row
runs = [np.diff(np.flatnonzero(d[r])) for r in range(0, a.shape[0], 7)]
# Counter -> [(2, 35268), (4, 7235), (6, 3368), ...]   every run even: a 2x upscale



Then I tried the four possible 2×2 phases and upscaled each one back. Phase (0,0) reproduced the file with 0.0% error, so the native painting is 634×469. I saved that as `ref/native.png` and never looked at the big file again. A small helper, `zoom.py x y w h scale`, cropped native pixels and blew them up with nearest neighbour; I used it for every look.

![left bank at 4x](nb002.png)

*nb002. The lit bank at 4×. Vertical strokes of olive on ochre, stipple at the far edge. I could see the texture but not yet how it was made.*

![island at 5x](nb003.png)

*nb003. The small grass island. It looked like a soft gradient from green to orange, and it would turn out to be four exact classes.*

## 2. Reading, and the find that set up everything

I searched for what Ferrari has said about his process and read two interviews properly:

- **The EffectGames Q&A with Mark J. Ferrari.** He painted the colour-cycling scenes in Deluxe Paint II and depended on its palette management. He chooses dither by effect: "I use patterned dither because I want the effect to look smooth and precise," diffusion dither for chaotic things like collapsing surf, and no dither for solid bands. Each scene took "a

cd ~/work/artschool/posts; sed -n 250,400p master-copy/POST.md; echo ----; cat master-copy/TUTORIAL.md | head -80

# output:
Second, **designed light**: the subject gets the light and most neighbours sit in shadow. I gave each rock a brightness in the sketch.

![c5 two families](nb050.png)

*nb050. With two families, designed light, and rotated, sheared "loaf" shapes. The 8× detail of the main boulder is now close to his. As a scene the copy stayed weak: the snow, ledges and water are only sketched.*

After the critic's note about craft I looked at his rock bottoms and contours at 12×:

![bottoms at 12x](nb068.png)

*nb068. His masses sit on flat-ish bottoms with a dark contact band, and meet the top curve at an acute corner. They sit; they don't float.*

## 8. The painter

With five copies done I wrote `tarn.py`, a 320×180 painter with one fixed 32-colour palette. It modelled the world only as far as the painting needed: a camera 1.5 m up looking 10° down, a heightfield bank, a water plane, a superellipsoid boulder, and far layers. It ray-marched the terrain and the boulder, then applied the copies' rules to what it found.

The first render taught me a lot in one image:

![first tarn](nb053.png)

*nb053. The first full render. Three bugs are visible. The vertical black lines in the water are pine tips: escaped reflection rays above the frame were clamped to row 0, where the trees are. The lavender dots all over the grass are the sky showing through holes my strands left, because I never filled a base colour under them. And the boulder is a smooth sphere.*

I fixed the tree reflections by painting the trees on their own layer and mirroring that layer about the far shore, filled a base under the strands, and re-dithered the sky reflection in water space, because sampling already-dithered sky pixels aliased into stripes.

![tarn, speckled shallows](nb055.png)

*nb055. The shallows as random speckle. It looks like noise, not water. I replaced them with flat banded shelves, as in copy 4.*

![tarn, clean hillock](nb057.png)

*nb057. The version the whole studio later pointed at, for the wrong reason as far as I was concerned at the time. The bank's top edge against the treeline is a clean cut contour. David later called my final painter's hillock "a magazine cut out with no boundary texture." My copy 2 had the fringe right; I simply never carried it into the painter's big masses.*

Then the sheets, which showed the rest:

![first distance x light sheet](nb058.png)

*nb058. The first distance × light sheet. The reflections were rendered as their own shaded rays, so they looked like a second, different painting of the bank.*

The fix that mattered most in the painter was taking the reflection's colour from the painting itself: each water pixel shoots a reflected ray; where it hits the bank or boulder, I project that 3D point back into the frame and copy the pixel already painted there, one step darker. Strands, sedge, rims and dither all carry over, and a low bank reflects short, the way his island does:

```python
px, py, _ = project(pts)                           # where th

cat ~/work/pixelart-studies/library/README.md | head -80; echo; which pdftoppm pdfimages mutool magick python3; python3 -c "import numpy, PIL, scipy, skimage; print('ok')"

# output:
# The studio library: model systems

The elk and deer student succeeded largely because it didn't start from raw photos. It started from finished analysis:
- Muybridge's frame-by-frame plates;
- the naturalist's "four things that make a 6-pixel elk read".

Natural scientists used to be trained to draw: a geologist could draw a flake, an outcrop or a fold with economy and truth. Naturalist painting guides were built on the same scientific understanding. This library collects those traditions so studies can start where the experts finished, instead of doing a geology PhD from photographs.

**How to use it:**
- Before drawing, find your subject's model system here (or online, below) and read it closely.
- Then build on it, the way the elk student built on Muybridge.
- Open the PDFs and look at the plates; the drawings are the point.

Refetch anything missing with `./fetch.sh` (resumable). Files are also mirrored in S3 under `voxsim/shared/library/`.

## On disk (open access)

| Domain | File | What it gives you |
|---|---|---|
| Terrain, landforms | `terrain/blockdiagramsoth0000armi_s8g3.pdf` | **Lobeck, *Block Diagrams* (1924).** How geologists draw landforms in 3-D: every landform type as a block diagram, with the drawing method. |
| Terrain, landforms | `terrain/2015.205632.Geomorphology.pdf` | **Lobeck, *Geomorphology* (1939).** Landforms explained through his own drawings: glacial troughs, cirques, rivers, coasts, volcanoes. |
| Terrain, landforms | `terrain/physicalgeograp00davigoog.pdf` | **W. M. Davis, *Physical Geography* (1898).** Davis's block diagrams: how landscapes form and age. |
| Terrain, rock at map scale | `terrain/2015.119840.Cartographic-Relief-Presentation.pdf` | **Imhof, *Cartographic Relief Presentation*.** The rigorous method for showing terrain by light, and Swiss rock drawing: cliffs rendered by structure with a few strokes. Probably the single most useful text for rock at landscape and region scale. |
| Rock, mountains | `rock/modernpainters04rusk.pdf` | **Ruskin, *Modern Painters IV: Of Mountain Beauty* (1856).** A painter's analysis of rock types, cleavage, crests, banks and stones, written for artists and illustrated with his own drawings. |
| Rock, strata at distance | `rock/holmes/*.jpg` | **William Henry Holmes, plates for the Grand Cañon Atlas (1882).** The masterpieces of American scientific landscape drawing: stratified cliffs and plateaus at great distance in a few values and stepped strata lines. Directly relevant to the Yakima basalt. |
| Rock, structure | `rock/reportongeology05duttgoog.pdf` | **G. K. Gilbert, *Geology of the Henry Mountains* (1877).** A classic illustrated geological report. |
| Rock, a flake | `rock/cifa_lithic_illustration_guide.pdf` | **CIfA, *The Illustration of Lithic Artefacts*.** How archaeologists draw a knapped flake: conventions for ridges, ripples and light. The drawing-a-flake skill itself. |
| Trees | `trees/artisticanatomyo1915cole.pdf` | **Rex Vicat Cole, *The Artistic Anatomy

cat ~/work/pixelart-studies/SYNTHESIS.md | head -150; ls ~/work/voxsim-wt/ ; sed -n 1,60p ~/work/voxsim/docs/INFRA.md

# output:
# What earlier students discovered: notes on their craft

These are notes on the painstaking work of the students who came before you:
- four who each spent hours learning Ferrari's language on one small scene (`pedagogy/{atelier,master-copy,analysis,observation}`);
- seven who studied single topics.

They copied his pixels crop by crop, measured his grass against real grass, built a boulder up from a lit sphere, and diagrammed his picture before daring to paint it. What they found is here to inspire you and save you time. It isn't a specification. You'll see things they didn't, and some of what they wrote will turn out wrong or incomplete for your subject. Follow your own eyes. Their best work is in their intermediate studies (e.g. `master-copy/out/cmp_c*.png`, `atelier/stage2/`, `observation/studies/translate_*.png`, `analysis/img/`); those are worth looking at more than their final painters.

The tags below say how each finding came about:
- **[shown]**: a student built it and it worked.
- **[measured]**: a student measured it in Ferrari's pixels or in photos.
- **[mine]**: the integrator's reading, not yet tried by anyone.

Striking to us: the four students, working apart, found much the same underlying ideas.

## 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 fo

cd ~/work/pixelart-studies/library/purchased; pdfinfo 807548002*.pdf; pdfimages -list 807548002*.pdf | head -8; ls -la *.pdf

# output:
Title:           男鹿和雄画集 Ⅱ Kazuo Oga Animation Artbook 2
Author:          スタジオジプリ責任編集
Creator:         Wondershare PDFelement
Producer:        Wondershare PDFelement
CreationDate:    Thu Jul 27 05:49:22 2023 PDT
ModDate:         Thu Jul 27 06:50:42 2023 PDT
Custom Metadata: no
Metadata Stream: yes
Tagged:          no
UserProperties:  no
Suspects:        no
Form:            AcroForm
JavaScript:      no
Pages:           148
Encrypted:       no
Page size:       1236 x 1512 pts
Page rot:        0
File size:       159177088 bytes
Optimized:       no
PDF version:     1.7
page   num  type   width height color comp bpc  enc interp  object ID x-ppi y-ppi size ratio
--------------------------------------------------------------------------------------------
   1     0 image    1236  1512  rgb     3   8  jpeg   no         9  0    72    72  806K  15%
   2     1 image    1236  1512  rgb     3   8  jpeg   no       780  0    71    72  513K 9.4%
   3     2 image    1236  1512  rgb     3   8  jpeg   no       265  0    72    72  850K  16%
   4     3 image    1236  1512  rgb     3   8  jpeg   no       295  0    72    72  454K 8.3%
   5     4 image    1236  1512  rgb     3   8  jpeg   no       784  0    72    72  124K 2.3%
   6     5 image    1236  1512  rgb     3   8  jpeg   no       350  0    72    72 1030K  19%
-rw-r--r--@ 1 user  staff  159177088 Sep 26 13:24 807548002-男鹿和雄画集Ⅱ-Kazuo-Oga-Artbook-2.pdf
-rw-r--r--@ 1 user  staff    9963697 Sep 26 13:08 Geological Field Sketches and Illustrations _ A Practical -- Matthew J_ Genge.pdf
-rw-r--r--@ 1 user  staff   62232361 Sep 26 13:05 The Guild Handbook of Scientific Illustration -- Elaine R_ S Hodges; Guild of Natural Science Illustrators -- 1, 1988.pdf
-rw-r--r--@ 1 user  staff   14818151 Sep 26 13:10 Tropical trees and forests  an architectural analysis (Hallé, Francis, Hallé-Oldeman).pdf
-rw-r--r--@ 1 user  staff   14242500 Sep 26 13:13 男鹿和雄画集 =.pdf

mkdir -p ~/work/pixelart-studies/books/oga/pages && cd ~/work/pixelart-studies/books/oga/pages && nice -n 10 pdfimages -j ~/work/pixelart-studies/library/purchased/807548002*.pdf p && ls | head -3; ls | wc -l; du -sh .

# output:
p-000.jpg
p-001.jpg
p-002.jpg
     148
149M    .

mkdir -p ~/work/pixelart-studies/books/oga/work && cd ~/work/pixelart-studies/books/oga && cat > work/contact.py <<'EOF'
from PIL import Image, ImageDraw
import sys,glob
fs=sorted(glob.glob('pages/p-*.jpg'))
per=20; cols=5; tw=300; th=367
for s in range(0,len(fs),per):
    im=Image.new('RGB',(cols*tw,4*(th+16)),'white'); d=ImageDraw.Draw(im)
    for i,f in enumerate(fs[s:s+per]):
        t=Image.open(f); t.thumbnail((tw,th))
        x=(i%cols)*tw; y=(i//cols)*(th+16)
        im.paste(t,(x,y+16)); d.text((x+4,y+2),f.split('-')[1][:3],fill='black')
    im.save(f'work/contact_{s:03d}.jpg',quality=80)
EOF
python3 work/contact.py; ls work

# output:
contact.py
contact_000.jpg
contact_020.jpg
contact_040.jpg
contact_060.jpg
contact_080.jpg
contact_100.jpg
contact_120.jpg
contact_140.jpg

cd ~/work/pixelart-studies/books/oga && cat > work/crop.py <<'EOF'
# usage: crop.py IDX part [scale]   part: t,b (halves), tl,tr,bl,br, or x0,y0,x1,y1 fractions
import sys
from PIL import Image
i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
im=Image.open(f'pages/p-{i:03d}.jpg'); W,H=im.size
P={'t':(0,0,1,.52),'b':(0,.48,1,1),'tl':(0,0,.52,.52),'tr':(.48,0,1,.52),'bl':(0,.48,.52,1),'br':(.48,.48,1,1),
   'l':(0,0,.52,1),'r':(.48,0,1,1),'m':(0,.3,1,.72)}
f=P[part] if part in P else tuple(map(float,part.split(',')))
c=im.crop((int(f[0]*W),int(f[1]*H),int(f[2]*W),int(f[3]*H)))
c=c.resize((int(c.width*s),int(c.height*s)),Image.LANCZOS)
c.save(f'(manager scratchpad)/c_{i:03d}_{part.replace(",","_")}.jpg',quality=88)
print('ok')
EOF
S=(manager scratchpad); mkdir -p $S; python3 work/crop.py 8 b 1.2

# output:
ok

cd ~/work/pixelart-studies/books/oga && for p in "9 t" "9 b" "10 b" "11 t" "11 b" "12 t" "12 b" "13 t" "13 b"; do python3 work/crop.py $p 1.15; done

# output:
Exit code 1
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/work/crop.py", line 4, in <module>
    i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
      ^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '9 t'
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/work/crop.py", line 4, in <module>
    i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
      ^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '9 b'
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/work/crop.py", line 4, in <module>
    i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
      ^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '10 b'
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/work/crop.py", line 4, in <module>
    i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
      ^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '11 t'
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/work/crop.py", line 4, in <module>
    i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
      ^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '11 b'
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/work/crop.py", line 4, in <module>
    i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
      ^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '12 t'
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/work/crop.py", line 4, in <module>
    i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
      ^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '12 b'
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/work/crop.py", line 4, in <module>
    i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
      ^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '13 t'
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/work/crop.py", line 4, in <module>
    i=int(sys.argv[1]); part=sys.argv[2]; s=float(sys.argv[3]) if len(sys.argv)>3 else 1.3
      ^^^^^^^^^^^^^^^^
ValueError: invalid literal for int() with base 10: '13 b'

cd ~/work/pixelart-studies/books/oga && cat > work/cc.sh <<'EOF'
#!/bin/bash
# cc.sh scale idx:part idx:part ...
cd ~/work/pixelart-studies/books/oga
s=$1; shift
for a in "$@"; do python3 work/crop.py ${a%%:*} ${a##*:} $s >/dev/null; done; echo done
EOF
chmod +x work/cc.sh; work/cc.sh 1.15 9:t 9:b 10:b 11:t 11:b 12:t 12:b 13:t 13:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 10:t

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 40:l 40:r 41:l 41:r

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 42:r 43:l 43:r 44:r

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 44:l 45:t 45:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 46:t 46:b 47:t 47:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 48:t 48:b 49:t 49:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 50:t 50:b 51:t 51:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 52:t 52:b 53:l 53:r

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 54:t 54:b 55:l 55:r

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.3 55:0,0,1,0.2

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 56:t 56:b 57:r 58:t 58:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 59:t 59:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 60:t 60:b 61:t 61:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 62:t 62:b 63:t 63:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 64:t 64:b 65:t 65:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 91:t 92:t 92:b 93:t 93:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 94:t 94:b 95:t 95:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 96:t 96:b 97:t 97:b

# output:
done

mkdir -p ~/work/pixelart-studies/books/oga && cat > ~/work/pixelart-studies/books/oga/work/READING_NOTES.md <<'EOF'
# Reading notes (raw, as I read). Book page = PDF image index - 2.

## Ch.1 Mononoke techniques (技法)
### 3 水張り→地塗り (p.46-47)
- mizubari: wet both sides, stretch & fix paper. Clean smooth gradation: wipe excess water so paint doesn't float. Complex/accidental: lots of water, use bleeding (nijimi) and blur (bokashi).
- 地塗り (ground laying) = "the most important process in background painting". Done on wet paper with poster colour, making the BASE of the picture. What it covers varies: some pictures ground-laid almost to finish, others just a simple gradation then finish. Work in the ~30min-1h while paper holds water. Wet = paint spreads, gradations easy, clouds/trees/water get variety.
- 3-1 C-1517 (dead forest after Didarabotchi): trunks & dead red-black moss made by paints bleeding into each other; the EDGE of a bleed is read as moss (男鹿ならではの技法). Scarlet lake: red paint's particles spread when bled -> "scattering" effect. Thick+thick mixed -> bleed; thinned & smoothed with brush/hake -> bokashi. Half-dry -> brush captures shape firmly. Controlling water = range of rendering.
- 3-2 C-0017 (p.47): Composition from distant range to stone-wall path; except the west sun crossing the mid trees, astonishingly little hand put in. "Ground-laid, a little finish". A good painting evokes a rich image by its silhouette alone. Bold omission. Caption: the enlarged middle forest is not detailed but roughly/boldly blocked — and seen whole, no incongruity.
- Oga x Tanaka (3): Oga: "I try to bring ground laying as close to finished as possible. For landscape, sky covers most area; the dark parts and bright parts of the forest; the sense of volume already made - get it good at ground stage. Then later just tidy the bright leaf tips in front and the rough parts." Stone bumps, bumpy fields and roads: touch with brush tip while drying bit by bit. "Something to catch on is better than nothing for finishing touches." Tanaka: half wet half dry gives good brushwork; paint blends better than on fully dry. Photo: cover painting: after mizubari, ground-laying first with white-ish and grey for the misty sky; blue sky uses blue family.
### 3-3 C-1646 群れを捉える (grasp the crowd) p.48
- dead-branch-only base; green book cels morphing. Hardest in nature painting: "the rest, the great mass" (その他大勢) where points are hard to pin. If you draw the miscellany unorganised it doesn't work as a background: grasp the impression accurately, ORGANISE, then the painter EXTRACTS features.
- ground laying should decide 3 things: overall light direction, overall colour, atmosphere of the subject.
- Oga trait: GREY used effectively—not pure grey: purplish grey, brownish grey, greenish grey, greys that feel coloured. Overmix -> mud grey; coloured greys scattered through give vividness/lustre (艶).
- When drawing a "crowd", don't draw everything in the crowd; drawing everything crushes space and weakens the subject's impression. Capture the impression at ground-laying.
### 3-4 C-0054 (beech trunk & crown, p.49): most texture put in at the flat-brush ground stage. Up close there's colour melting & paint unevenness (塗りムラ) but whole it looks natural — the unevenness reads as light and texture. Painted, never finely drawn in. Colours, light/dark contrast, branch/leaf shapes all balanced. Light from upper right back — planned so crown thickness & trunk heaviness appear.

## 4 生きている筆使い living brushwork (p.50-51)
- Brush traces alive -> painting alive; living-brush form = unity essential for nature.
- 4-1 C-0799 rhythm (moss close-up with drops): big colour & shade at ground stage, then 削用筆 (sakuyo brush) tip darting vertically & horizontally, near-improvised. Real fine moss leaves are NOT drawn one by one; tip and side of brush used, tempo. For a "crowd" you must know beforehand what shape each brush motion makes. Practice on scraps. Use tip, belly, root; sometimes splay the tip for rough touch. Enlargements: several kinds of moss expression by brush use.
- 4-2 C-1471 moonlit moss floor: bold, unhesitating strokes; in finishing, SHADOWS CROSSING the moss bed give tension/dynamic. Moss, dead leaves, ferns all minimum. Only ground, no focal point: moon reflection + a shadow boldly crossing the whole composition -> strong impression.
  C-0822 root of big tree: trunk & roots bold; finishing: moss/ferns/ヒコバエ floating in light captured ONLY by bright part of leaves facing light, glinting red-brown stems, glowing moss heads -> makes unpainted parts felt. "Close to an illusion"; requires understanding how nature is made. No repeated overpainting; minimum strokes.
- 4-3 hake (唐刷毛) C-1354, C-0801: gradation from left/right to centre of rock wall & water made by hake at ground stage; dark but colour not dulled. Hake: gradation with 2+ hues or without raising paint density -> keeps bright colour. C-0801 light shafts from canopy by hake. To emphasize a direction in the picture.

## 5 空間と面の意識 space & planes (p.52-55)
- 抜け (nuke, "clearance/openness"): good nuke -> space & perspective clear, distance felt in big landscapes. Bad nuke -> miniature.
- 面 plane: "on the plane", "planes don't match" = no consistency. Character standing on a looked-down ground must match or appears tilted. Plane vs perspective confused: perspective correct can still be artificial, uninteresting. For nature, natural look matters; over-caring about perspective loosens the space.
- 5-1 C-0064 board vs BG (hill slope, distant village): ridge line cutting the slope mid-way, and strong shadow from west-lit trees dividing bright meadow near and village far => separates near & far, vast space. INTENTIONALLY SEVERING connected space gives depth. Board had points scattered; BG CONCENTRATED them on the ridge trees. If somewhere a clearly shaped thing exists, people recognise surrounding space around it (buildings, cars) even if surroundings vague. Oga gives contrast to hard-to-shape nature -> scale of space.
- 5-2 C-0095 ground as plane: hardest is simple ground. Keep in mind: a flat plane with undulation, grass growing on it. Else grass doesn't fit the plane -> scattered. West sun shades grass clumps, lit undulations. Several grass types -> broad variation; shadows for contrast to tighten. In a slightly looking-down composition, grass/leaves near are drawn as seen from above, far as seen more from the side. Understand the flow & continuity.
- 5-3 C-0022 boundary ground/depth: lying planes (grass, ground), rising planes (stone wall, forest), boundary lines between forest, wall, meadow. Whole in shadow; volume of crowns, glossy stone wall -> shadow colour mastery. One thin ray into dark abyss gives awe.
- 5-4 C-0773 great landscape with clouds between: two ridges (far, mid) overlap, cloud passes between; near rock wall lit by morning sun = point; small figure w/ shrubs/roots for scale. Pan-focus: can't blur; so draw back to front firmly, use aerial perspective (far approaches sky colour), difference of brush touch, placement of points. Eye point: trees above EP drawn from below (aori), below EP from above (fukan). Brush direction/placement errors break it.

## 6 光源の捉え方 grasping the light source (p.56-57)
- outdoor light 外光表現; season/weather/time change same place. Set source consciously.
- 6-1 C-0772 sun colour: direct rising sun; radial light made by contrast of sky/cloud/mountains in BG only. White sun alone doesn't look like light: add light's COLOUR. Colour where light meets the object's EDGE (際). Blue celeste sky boundary pale pink; light blue melting into emerald green; flare pale orange/yellow; prism-like. Distant range aerial perspective yellow->emerald; nearer direct yellow->orange. Chrome green No.1, light green vivid at light edges. Inside white-lit cloud, blue & brown greys -> depth. Full backlight but rich colour.
- 6-2 C-0792 light & shadow (gorge boulders): light cut into ravine; shadow ~2/3 of picture -> dazzling light reflecting on rocks. Light only on certain planes; upper cliff in shadow; don't spread light around, CONCENTRATE it in one part. Direct sun brightest; soft-light parts; reflected-light dim parts; REFLECTED LIGHT in shadow important. Daytime: reflected light takes sky colour -> cool; alone too cold -> add object's own colour (rock browns, plant greens) to loosen. If shadow reads as shadow compared to light, warm colours in shadow are fine -> widen range of light & colour. Water: only the clear rock bed seen through.
- 6-3 C-1482 vs C-1486 moonlight: 1482 airbrush for light itself in space (fantastical; don't raise value too high -> whitish); 1486 brush only: casting shadows between trees expresses light; crisp edged sharp light. If you don't want light to diffuse, don't airbrush.
- Talk 4: Tanaka: in BG, shadow tends to be just lowering value; Oga puts browns in shadow. Oga: trees are basically GREY—not plain grey; greys of some hue, parts where hue is strong, parts covered in moss. Light parts: add bright grey or reflect sky colour to tree's colour. Shadow: dark with tree's hue strengthened, forest dark green -> not lonely colour. Miyazaki: "this cedar could be blacker"; Oga: tends to paint as seen; not enough exaggeration.

## 7 画面のバランスと密度 balance & density (p.58-59)
- density can't come from drawing-in alone; covering all with fine detail = just "a fine picture". Needs balance of composition/colour/space; narrow down points = where the viewer looks. Viewer first looks at points; vague parts get completed. Concentrate density at points -> whole feels dense. Scattered points -> density thin.
- 7-1 C-0027/C-0051: cuts 2s/2.5s; contrast of west-lit village vs mountain shadow; detail not fine; part left as ground-laying. vs C-0064 7.5s pan -> needs detail. Know the cut's role. 時間と質と量 law.
- 7-2 C-0049 quick brush: 4.5s; focus is the tower falling, so scenery not fussed. Rough quick touch. Density varied intentionally by cut role.

## 8 省略と誇張(デフォルメ) omission & exaggeration (p.60-61)
- narrowed points, omitted & exaggerated -> looks rough but has TENSION. Must organise info or looks like cutting corners. Exaggerate subject features to impress.
- 8-1 C-0007 board vs BG: board strong west-sun orange, long shadows, strong shadows on distant trees too -> little depth. BG: afternoon earlier, shadows' contrast SOFTENS going back -> perspective. Clear detail of near shrubs vs omitted far. Brought point to the front -> omission of the rest possible.
- 8-2 C-0025: tower & far mountains overlap; mid mountains split left/right; mountain-foot shadow runs from centre-front to back. Staging priority (見得).
- 8-3 C-0827 broadleaf evergreen close veg: "omission after capturing features". Form, colour, light = 3 elements. Real foliage chaotic; organised foliage keeps volume & dynamic space. Not an encyclopedia. Observation & sketch. Capture whole colour/form/light impression broadly, then add texture.

## 9 取材 location (p.62)
- 9-1 C-0781 shadow colour: rocky mountain foot, humble cut but such cuts deepen the film. Shadow colour vital: in shadow tone range narrows -> lonely poor picture. Use the widest range of colours within what reads as shadow. For moist shadow colour don't rely on cool colours only; use object's natural warm colours; memory of air, texture, vegetation, weather from location.
- 9-2 C-0008 stone wall mostly in shadow: ground stage thin low-value paint -> particles float on paper -> rough texture. Then opaque colour firmly on top -> varied texture. Top row on cel; match texture. Weeds/ivy/moss added.
## 10 資料 reference (p.63): C-0053 red-barked Kurobe (Thuja standishii) as one-point accent. Photos are hints, not copied into space/composition. Oga: photos of cloud useful; else the angle he wants is never in photo books.

## Ch.2 Pompoko expression (p.89-)
- 1 observation & sketch: not "appropriate/offhand" (適当) — different from omission. 
- 1-1 C11-8: what to paint narrowed; light upper right; right woods in shadow vs left lit planes -> contrast; shadows made in MASSES (かたまり) so centre-left opens as bright space. Rough sketchy. Density suited to characters.
- 1-2 C18-1 greens: trunks mostly grey (except red pine, kurobe) -> width of greys = depth of colour. Colour patterning trap: bright = emerald→chrome No.1, mid olive green, dark chrome No.2, No.3, black. Base colours okay but don't be bound.
- 1-3 C15-1 living forms: each plant form has a rhythm; plum's branches split rhythmically. Clear forms placed but space still has nuke.
- 2 tense composition: Oga imagines 水墨画 (ink painting) for placement/balance.
- 2-1 15-8 zoki forms: 3 motifs (cedar far-mid, zoki mid, bamboo grass/shrubs near). Cedar as accent (put dark colour where wanted, as much as wanted). 
- 2-2 C20-1 rhythm: light upper right -> flow upper right->lower left; place objects crossing that flow -> contrast on trunks. But too directional -> tilt some trees opposite to cancel. Branches: left then right alternate rhythm. 
- Talk 6: branches: at each fork thick & firm; put brush briefly at each joint as accent -> not just curve/straight line -> rhythm.
- 2-3 C14-1 ink-painting density: rain; low saturation; point = shrine; rest barely drawn; value difference & contour contrast only express space.
- 3 light & shadow: tilted/limited light -> strong contrast; light's colour enters shadow -> dominant tone. Range of colour in shadow is the point.
- 3-1 C58-1A dusk: warm light vs cool shadow; purple between blue and pink. Harmonious combos else colour muddies.
- 3-2 C46-8: orange->olive warm; slightly faded cool in shadow tightens depth. Pompoko lower contrast overall than Mononoke.
EOF
echo ok

# output:
ok

cat >> ~/work/pixelart-studies/books/oga/work/READING_NOTES.md <<'EOF'

## Front matter of Ch.1 (read second pass)
- p.38-39 BG basics: BG on paper; characters on cels on top; "book" = cel with BG painted on for foreground overlap. Process: storyboard (Miyazaki) -> 美術設定 art setting (Oga pencil) -> 美術ボード art board (Oga colours from setting to share the image) -> 背景画 BG (atmosphere same as board, detail finer).
- p.40 paper: TMK poster paper or M paper, 180kg; surface neither too rough nor too fine. Thin paint still gives some texture; thick shows brush touch.
- p.41 PAINTS: poster colour (Nicker) — mostly opaque watercolour; some transparent. "Brush-take" (筆のり) best. Oga uses 21 colours; book shows 25: Black, White, French Grey, Lemon Yellow, Jaune Brillant, Orange, Brilliant Rose, Vermilion, Chocolate, Sepia; Cobalt Violet, Olive Green, Chrome Green No.1, No.2, No.3, Light Green, Turquoise Green, Emerald Green, Cobalt Green, Cerulean Blue; French Blue, Light Blue, Cobalt Blue, Blue Celeste, Heliotrope. Opaque over-layering beyond need muddies; transparent colours use paper white for vivid colour; to suppress an under colour put opaque on top. Order & calculation of painting matter.
  Talk 1: Oga: "Even with lots of colours I can't master them, so better to control few colours freely." Small number of colours, subtle mixing -> wide range. Tanaka: not owning many paints but how you combine.
- p.42 brushes: 削用筆 sakuyo (round, final finishing; tip gathering is its life; mostly large size), かすみ筆 kasumi (weasel, slim round, supple), 平筆 flat (design brush; 10,9,7,6). hake (唐刷毛/絵刷毛, 20-30): even out gradations, mix without muddying, blur cloud edges; dry hake, only tip touches paint, repeated left-right/up-down to level wet surface. Flat brush for even areas; skilled use corners & edge for detail. Sakuyo sometimes used from ground stage with tip splayed. Ruler + glass rod for straight lines. Airbrush.
## 2 混色 mixing (p.43-45)
- limited poster colours mixed in ratios make almost everything. 
- 2-1 C-1651 image board: almost ground-laying only, flat brushes only. Sky->cloud->far hill->near meadow with a few flat brushes at once; can't premix every colour; gradation sky & meadow base premixed, the rest learned bodily. Far: blue celeste, light blue, cobalt OR emerald, light green; near meadow chrome No.1, No.3, olive, improvised range of greens. Shadow colour in front of meadow important: green shadow + red-brown~olive warm. Greens tend cool -> intentionally warm to widen range. Browns by mixing: vermilion+light green; cobalt violet+olive green -> natural grassy brown; change ratio -> greenish or reddish. Overmix -> mud.
- 2-2 C-0081 UNMUDDIED MIXING: high saturation + strong light/dark contrast; brightest: white, lemon yellow, chrome No.1, jaune brillant; darkest: black, olive, chrome No.3 mixed. What matters is the MIDDLE greens: saturated olive, chrome No.2, light green bridging light & shadow of large value difference. If large value difference, and not joined by colours that keep chroma, it muddies — same reason white+black = grey. Near-shadow hues cobalt green, chrome No.3 put in WITHOUT mixing -> keeps saturation, gives lustre beyond contrast.
- 2-3 C-0804 not fully mixed: in mossy trunk shade, green & brown from ground stage mingle, not fully mixed, saturation left. Trunk hollows get lower value colour -> contrast & cylinder form. Wide range of value & saturation -> many footholds for finishing. Nature has no fixed forms -> free points. Near-white chrome green highlight, vivid chrome No.1 accent around it, chrome No.2 at boundary to shadow: lustrous; mixes with trunk browns into a sober olive, not mud. Many unintended mixes also stay vivid -> transparency & depth.
- Talk 2: Oga mixes like a Chinese chef with salt & soy, pinch by pinch. Same colours near & far read as depth because of place & role: put the sky-tinted colour of far mountains on e.g. a side plane of a nearer mountain -> layer of air. Totoro: farthest forest, emerald green & pale purple NOT fully mixed, vivid remains. Forest isn't simply green: bleed a little red or purple partially -> not monotone. Scatter a few vivid colours well -> expresses light.
EOF
echo

# output:
(Bash completed with no output)

~/work/pixelart-studies/books/oga/work/cc.sh 1.1 4:0.55,0.15,1,0.75 8:b 7:r

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.5 10:0,0.4,0.45,0.75

# output:
done

cat >> ~/work/pixelart-studies/books/oga/work/READING_NOTES.md <<'EOF'

## Making of the cover (p.6-11) — Ishizuchi-san summit, misty, about to rain; painted from memory of 2003 climb, not a photo
1 tools: pencil, poster colour + dishes, flat 9 & 7, sakuyo, kasumi, kara-hake 15. 24-25 jars on desk; USED 18.
2 underdrawing: pencil B/2B as dessin directly on paper (normally layout traced via carbon). Drawing has hatching for rock planes & tone.
3 mizubari on TMK poster paper: water back generously with hake, flip, water front delicately.
4 make colours: normally premix colours shared across many cuts (sky); here improvised. Countless combos; control by paint amount & water on the brush.
5 ground ①sky: WHITE over the whole; then French grey & blue celeste in suitable amounts -> cloud volume & layer thickness. They mix with the white underlayer -> wrapped in mist, melting. Faint sky upper right: little light blue mixed in, blended. Hake to level if brush can't.
6 ground ②far mountain: rock peak melts into cloud -> paint quickly with sky-used colours while still wet. Flat brush SHIFTED VERTICALLY (staggered) -> texture of conifers on the peak; one step darker colour layered for shading. Mix vivid colours so not monotone.
7 ground ③whole colour: mid rock mountain -> near vegetation. ①flat brush tip deliberately splayed (バサつかせ) -> silhouettes of alpine trees ②brush direction changes vertical/horizontal ③paint a little thicker so low trees' crowns don't lose to under colour ④darker colour for shadow accent ⑤change colour, go straight to the near rocks. Two 7-flat brushes alternate, washed.
8 ground ④ground complete: fine branches, fine leaves with sakuyo/kasumi AT GROUND STAGE — blends with under colour, unity of space, less finishing. At completion, space & contrast from far to near already pinned; only texture to add without breaking the space.
9 finish ①whole: dry 1-2h. Normally finish from far keeping balance; but to judge colour & contrast balance, deliberately add a STRONG touch to the mid rocks. After judging, add hand only to WEAK parts -> never overdraw.
10 finish ②bright & dark: ① lustrous deep colours on shrub shadows & rock shadows ② dark tightened the picture -> bright parts look insufficient -> put VIVID bright colours ③branch detail ④ near-finish bright highlights ⑤don't rely on value difference alone; always bright colours that are vivid (発色の良い).
   Colours used: far mountain: cobalt blue, chrome green 3~sepia~black, heliotrope, emerald (+sky mixes). Mid rock: jaune brillant, french grey, blue celeste (+sky). Shrubs: olive green, cobalt violet, black, cobalt blue, sepia, heliotrope. Dark foliage: chrome green No.2, peacock blue. Grass part: jaune brillant, light green, emerald. Near rock: base + scarlet lake. Grass: cobalt green, chrome No.1, orange.
11 finish ③detail: raise rock texture; draw bright conspicuous LEAF SHAPES to make shrub contour stand out; shadow into branches tightens. Avoid adding strokes needlessly; choose points carefully & quickly; tighten where dark, vivid where wanted.
12 finish ④: near shrub leaves, branches, grass clumps, moss, flowers. ①sakuyo tip slightly splayed -> grass. ②moss on rock: 片ボカシ one-side blur (paint on tip only, blur with water at root). ③not photoreal but some reference research.
13 complete: petal shapes & leaf texture per reference; want "flower" (華) -> add more flowers as service. Check from distance, add intuitively where lacking. ~11h from ground laying.
The finished cover: vignette composition — sky & mist = bare paper-white area; peak dissolved; mass is a diagonal wedge rising to the right; point = flowering shrub right, rocks lit.
EOF
echo

# output:
(Bash completed with no output)

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 98:t 98:b 99:t 99:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 100:t 100:b 101:t 101:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 102:t 102:b 103:t 103:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 104:t 104:b 105:t 105:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 106:t 106:b 108:t 108:b 109:t 109:b 110:t 110:b

# output:
done

cat >> ~/work/pixelart-studies/books/oga/work/READING_NOTES.md <<'EOF'

## Ch.2 cont. (p.96-108)
- 3-3 snow image board: lit snow basically WHITE; colour only in the shadows, and distance & space must be expressed there. Dense cedar grove far vs white snow on shrub branches -> contrast. Shade of snow volume (立体感の陰影): blue-grey family; shadows cast ON the snow surface: celeste family — two different shadow families. Scattered bounce from snow surface shown. Point: shrubs etc give tension.
- 3-4 C11-1 intrinsic vs light colour: backlit cherry tree near centre in shadow, contrast vs bright precinct. Color well used even in shadow. Every natural thing has its intrinsic colour, but visible colour changes with light: browns look greenish or bluish from scattered/indirect light. Old cherry actually black-brown~grey, but moss -> bluish. Dry moss on old trees & rocks goes whitish -> can use varied colours as if reflecting something. Trunk in shadow uses red-brown & green -> rich not lonely. Strong near shadow -> far nuke good. Multiplane: near cherry/branches/weeds on cels slid for parallax. Contrast strong because any overlap when moving must look right.
- 3-5 C2-2 evening sun into zoki woods: side light -> long shadows; ground matière complex -> ORGANISE, draw the point light & shadow, then not many strokes needed. Backlight easier: shape as silhouette, light easy to put. Front light: colour, detail, volume of lit object hard.
- 3-6 C63-3 light into hall: lit floor must still read as SAME PLANE as unlit floor; too much value/chroma difference -> lit part pops out, not same plane. Board seams/grain help; carpet/linoleum harder. Shadow angle natural else not floor shadow.
- 4 air: humidity & air. Low humidity -> good nuke, more depth. Hazy heat -> high humidity. Northern-born painters show little humidity, southern ones more. Location hunting to feel climate that photos can't.
- 4-1 C5-3 panorama: Oga (Akita-born) low-humidity clear air; pylon near-left for distance, but also: how things look at that distance, detail at distance, moonlit space colour. "Just paint it naturally as if it is there" — but needs everything: colour, contrast, detail degree, omission, exaggeration. Wide view, don't overdetail, power on points; orange machinery as one-point that makes distance.
- 4-2 C40-1 aerial perspective: dry winter -> Fuji clear. Far objects approach sky colour & melt, hazy = 空気遠近. Far mountains vs near snowfield -> big distance.
- 4-3 C24-1 humid: few light colours, value held down, object colours inside -> lustre in dark. Kanto loam red soil moist in shadow. C22-19 after-rain sky: cloud remnant vs clearing.
- 5 layout: art decides nature within layout; 5-1 C1-1 multi: 3-tier book of bamboo; dark bamboo near vs bright paddies far; shadow parts coloured so no lonely diagram. Far drawn from slightly above, near bamboo from front -> not-too-neat "zure" (offset) seen in natural vegetation -> composition not explanatory. Tanuki dispersed, melt into landscape.
- 5-2 C1-3 orthodox composition BG-only: seasonal plants (sunflower); weeds need care; house structures accurate -> scale.
- 5-3 C36-9: space for characters to act "alive" is the main purpose.
- 6 colour & space: learned from past paintings, Western, Nihonga, ink painting.
- 6-1 C1-2 scattering colour: many colours but unified; persimmon as point; far satoyama coloured trees each pale but purple-pink-orange widely; cedar chrome-green gives colour contrast. Near-right grass value NOT lowered -> keeps brightness; instead firm shadow along the path gives contrast.
- 6-2 C15-13 artificial: red-brown earth divides green near and pale blue sky; blue roof, red cone as accents to increase number of colours; aerial perspective for nuke; boundary grasses: withered-coloured weeds & sprouts.
- 6-3 C39-5 cold sad: narrow tone range, low saturation; no direct sun -> weak contrast -> flat risk; use GREYS: brown-grey, green-grey, purple-grey, red-grey, yellow-grey -> width equal to normal colours.
- 7 elegance & play: season, region, vegetation, weather is art's to decide; 7-1 cherry: real cherry season sky whitish; painted clear blue anyway. Cherry blossom rendered as flat opaque dabs of 3 values (white, lilac, blue-lilac) on blue with black branch strokes — broken, dashed lines.
- 7-2 moon: board reddish orange uncanny; final restrained white.
- 7-3 snow falling.
- Talk 7: Oga: BG must draw space & ground characters can move on. Kawai Gyokudō (Nihonga) nature + Monet; "Monet + Gyokudō / 2". Don't copy others' mixing; learn combos where colour lives in your own paint. Summer leaves hardest (all green); autumn many colours. Totoro green too bright/bluish (emerald); should have used deeper, red-brown-containing green. Omoide overcorrected; Pompoko: omission & narrowing points.
- 7-4..7-7 seasonal flowers as kigo (seasonal word): minimum objects convey season.
EOF
~/work/pixelart-studies/books/oga/work/cc.sh 1.15 133:t 133:b 134:r 135:b 136:t 136:b

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 137:t 138:t 138:b 142:l 142:r

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.15 139:t 140:l 140:r

# output:
done

~/work/pixelart-studies/books/oga/work/cc.sh 1.0 54:0,0.55,1,0.85 58:0,0.72,1,1 62:0.45,0.2,1,0.95

# output:
done

cd ~/work/pixelart-studies; ls shared tools elements transfer | head -60; ls ~/work/voxsim-wt/place-skykomish | head; 

# output:
elements:
_critic
_critic2
alpflora
bear-cougar
birds
broadleaf
canids
canopy
channel
cobbles
conifers
deer-elk
driftwood
goats
grass-lod
ground
marine-mammals
people
rock
salmon
sea
small-mammals
snowpeak
steppe
treeline
understory
village
water
weather
willow

shared:
refs
scenes

tools:
imgfetch.py
notebooks.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
Cargo.lock
Cargo.toml
NOTES.md
REEL.md
RESULTS.md
SPEC.md
crates
docs
reels
renders

cd ~/work/pixelart-studies; ls shared/scenes shared/refs | head -40; ls elements/canopy elements/treeline elements/understory; head -40 elements/canopy/LESSONS.md 2>/dev/null

# output:
Exit code 1
shared/refs:
ferrari_alpine_tarn_dusk.png
ferrari_mossy_forest_pool.png
ferrari_snow_forest_boulders.webp

shared/scenes:
SCENES.md
tarn_dusk.json
elements/canopy:
data
notebook
refs
sheets
src
stages

elements/treeline:
data
refs
sheets
src
stage0
stage1
stage2
stage3
stage4
stage5
tmp

elements/understory:
CRITIQUE.md
LESSONS.md
__pycache__
farplant.py
fern.py
ground.py
leaves.py
lwload.py
plant3d.py
plants.py
portrait.py
refs
s1_fern.py
s1a_frond.py
s1c_colour.py
s2_all.py
s2_salal.py
scene.py
sheets
sheets.py
stage0
stage0_leaf.py
stage1
stage2
stage3
ucore.py
upalette.py
work

cd ~/work/voxsim-wt; for d in place-*; do echo "== $d $(find $d -maxdepth 3 -name '*.png' -not -path '*/target/*' 2>/dev/null | wc -l)"; find $d -maxdepth 3 -name '*.png' -not -path '*/target/*' -newer ~/work/voxsim/docs/INFRA.md 2>/dev/null | head -5; done

# output:
== place-data       27
== place-enchant       30
place-enchant/docs/place-enchant/pair_u2_region_ne.png
place-enchant/docs/place-enchant/g3_grove_land.png
place-enchant/docs/place-enchant/pair_m20_region_iso.png
place-enchant/docs/place-enchant/g3_grove_scene.png
== place-olycoast       26
== place-olycoast-flora       26
== place-sanjuan       48
place-sanjuan/data-sj/surface_win.png
== place-skykomish       26
== place-yakima       39
place-yakima/renders/y/p35_crop.png
place-yakima/renders/y/p34_crop.png
place-yakima/renders/y/speck.png
place-yakima/renders/y/crop_stripes.png
== place-yakima-snap       26
== place-yakima-snap3       26

cd ~/work/voxsim-wt; ls -la place-enchant/docs/place-enchant/ | head -40; ls place-skykomish/renders place-olycoast/renders 2>/dev/null | head

# output:
total 5832
drwxr-xr-x  6 user  staff     192 Sep 26 13:27 .
drwxr-xr-x  8 user  staff     256 Sep 26 13:27 ..
-rw-r--r--  1 user  staff  693289 Sep 26 13:27 g3_grove_land.png
-rw-r--r--  1 user  staff  445473 Sep 26 13:27 g3_grove_scene.png
-rw-r--r--  1 user  staff  850134 Sep 26 13:27 pair_m20_region_iso.png
-rw-r--r--  1 user  staff  928283 Sep 26 13:27 pair_u2_region_ne.png
place-olycoast/renders:
paint
paint-before
trees

place-skykomish/renders:
paint
paint-before
sky
studio-trees

cd ~/work/voxsim-wt; ls place-skykomish/renders/paint | head -30; ls place-olycoast/renders/paint | head; python3 -c "
from PIL import Image;import glob
for f in glob.glob('place-skykomish/renders/paint/*.png')[:8]+glob.glob('place-enchant/docs/place-enchant/*.png'): print(f, Image.open(f).size)"

# output:
dbg
s12
s2
dbg
s12
s2
place-enchant/docs/place-enchant/pair_u2_region_ne.png (1280, 360)
place-enchant/docs/place-enchant/g3_grove_land.png (960, 540)
place-enchant/docs/place-enchant/pair_m20_region_iso.png (1280, 360)
place-enchant/docs/place-enchant/g3_grove_scene.png (960, 540)

cd ~/work/voxsim-wt; find place-skykomish/renders/paint place-olycoast/renders/paint -name '*.png' | head -30; 

# output:
place-skykomish/renders/paint/s2/region.png
place-skykomish/renders/paint/s2/scene_herd.png
place-skykomish/renders/paint/s2/land_lake.png
place-skykomish/renders/paint/s2/land_coast.png
place-skykomish/renders/paint/s2/land_river_mouth.png
place-skykomish/renders/paint/s2/land_escarpment.png
place-skykomish/renders/paint/s2/scene_camp.png
place-skykomish/renders/paint/dbg/region.png
place-skykomish/renders/paint/dbg/landscape.png
place-skykomish/renders/paint/dbg/land_summer.png
place-skykomish/renders/paint/dbg/scene_winter.png
place-skykomish/renders/paint/dbg/land_winter.png
place-skykomish/renders/paint/s12/region.png
place-skykomish/renders/paint/s12/scene_herd.png
place-skykomish/renders/paint/s12/land_coast.png
place-skykomish/renders/paint/s12/land_river_mouth.png
place-skykomish/renders/paint/s12/land_escarpment.png
place-skykomish/renders/paint/s12/scene_camp.png
place-olycoast/renders/paint/s2/region.png
place-olycoast/renders/paint/s2/scene_herd.png
place-olycoast/renders/paint/s2/land_lake.png
place-olycoast/renders/paint/s2/land_coast.png
place-olycoast/renders/paint/s2/land_river_mouth.png
place-olycoast/renders/paint/s2/land_escarpment.png
place-olycoast/renders/paint/s2/scene_camp.png
place-olycoast/renders/paint/dbg/region.png
place-olycoast/renders/paint/dbg/landscape.png
place-olycoast/renders/paint/dbg/land_summer.png
place-olycoast/renders/paint/dbg/scene_winter.png
place-olycoast/renders/paint/dbg/land_winter.png

# The model in Oga's book, in its own terms

*Kazuo Oga, 男鹿和雄画集Ⅱ (Ghibli THE ART series, Tokuma Shoten, 2005).*

Page numbers are the book's printed folios. The scan's image file for a page is `pages/p-NNN.jpg` with NNN = folio + 2 (so p.46 is `p-048.jpg`). The Japanese terms are the book's own; I translated them myself.

The book is in four parts:
- a step-by-step making of the cover painting (pp.4–11);
- Chapter 1, "Techniques of *Princess Mononoke*" (技法, pp.36–63);
- Chapter 2, "Expression in *Pompoko*" (表現, pp.88–108);
- a conversation between Oga and the art director Naoya Tanaka, plus two columns (pp.128–139).

Short "Oga × Tanaka" talks run through both chapters. The paintings are identified by cut number (C-0064 and so on).

The book never states its model as a list. It teaches by pairing a principle with one painting, often a board beside the final background. Below I set out that model in its own order and vocabulary, then give the rule underneath each part in one line (**Rule:**).

---

## 0. What a background is for

- **The background exists to give the characters a space and a ground they can live and move on** (舞台空間; p.101, and Oga in talk 7, p.106). "The biggest difference from other paintings is that you must firmly paint the space and the ground a character can move on."
- The workflow is storyboard → art setting in pencil (美術設定) → **art board** (美術ボード: Oga's colour study that fixes the image for the whole staff) → **background** (背景画: the same atmosphere as the board, finer in detail) (p.38–39). Over one scene, the board is the standard.
- **The cut's role sets how much work it gets** (時間と質と量, time, quality and quantity, p.58). A 2-second cut gets a quick, rough touch. A 7.5-second pan gets detail. A cut whose focus is an action (the falling tower, C-0049) gets deliberately rough scenery.

**Rule:** decide what the picture is for, and how long it will be looked at, before deciding how much to paint.

## 1. Tools and colour: few paints, mixed freely (pp.40–45)

- Poster colour (Nicker), mostly opaque. Oga uses 21 colours and the book lists 25 (p.41). The cover used 18 (p.4). "Even with many colours I couldn't master them. It's better to control a few colours freely" (talk 1). **A small palette, and a wide range from subtle mixing.**
- Opaque layered over opaque muddies. Transparent paints use the paper's white for vivid colour. Opaque on top suppresses an under colour. **Order and calculation of painting matter** (p.41).
- **Unmuddied mixing** (濁らない混色; C-0081, p.44):
  - high chroma and a big value range are held together by the **middle colours**: saturated olive, chrome green No.2, light green, *bridging* light and dark.
  - "If a big value difference is not joined by colours that keep their chroma, it goes muddy, for the same reason white plus black makes grey."
  - Near-shadow hues (cobalt green, chrome No.3) are **laid in unmixed** to keep saturation and give **lustre** (艶).
- **Not fully mixed** (混ざり切らない; C-0804, p.45): green and brown from the ground stage mingle without being fully mixed, so their saturation survives. Many unintended half-mixes stay vivid and give **transparency and depth**. The mossy trunk has a near-white chrome-green highlight, a vivid chrome No.1 accent around it, and chrome No.2 at the boundary to shadow.
- Browns are *mixed* from complements (vermilion + light green; cobalt violet + olive green → "natural grassy brown"). Greens tend to go cold, so warm them deliberately to widen the range (C-1651, p.43).
- **The same colour reads near or far by its place and role.** Put the sky-tinted colour of the far mountains on the side plane of a nearer mountain and a layer of air appears (talk 2, p.45). The farthest forest in *Totoro* is emerald and pale purple **not fully mixed**. A forest isn't simply green: bleed a little red or purple into it. "Scatter a few vivid colours well and it expresses light."

**Rule:** a small palette; the big value range bridged by saturated mid-tones; accents unmixed; many half-mixed colours beside one another.

## 2. The ground stage: 地塗り (pp.46–49, and cover steps 5–8)

"**Ground laying is the most important process in background painting**" (p.46). It's done on wet, stretched paper while the paper holds water, which gives 30 minutes to an hour.

- What it must settle: **the overall light direction, the overall colour, and the atmosphere of the subject** (p.48).
- Oga: "I try to bring the ground stage **as close to finished as possible**. In a landscape the sky is most of the area, the dark and bright parts of the forest, the sense of volume… get it good at the ground stage. Afterwards I just tidy the bright leaf tips in front and the rough parts" (talk 3, p.47). "Something to catch on is better than nothing for the finishing touches."
- Wet-in-wet effects are part of the method:
  - bleeding (にじみ): the edge of a bleed is read as moss, and scarlet lake scatters its particles when bled (C-1517);
  - blur (ぼかし);
  - the half-dry brush (半乾き), which "captures shape firmly".
- **C-0017** (p.47): a whole composition, from the far range to a stone-walled path, which is "ground-laid, with a little finish". "A good painting evokes a rich image **by its silhouette alone**." The enlarged middle forest isn't detailed but boldly blocked, and seen whole it looks natural.
- **C-0054** (p.49): a beech trunk and crown, with most of the texture put in with the flat brush at the ground stage. Up close there's colour melting and **uneven paint (塗りムラ)**, and **the unevenness reads as light and texture**.
- **Cover, steps 5–8** (pp.7–9):
  - The misty sky is **white over everything**, then French grey and blue celeste worked into it, "wrapped in mist, melting".
  - The far peak is painted into the wet sky with the sky's own colours. Its conifers are made by **the flat brush shifted vertically in a staggered way**, then one step darker layered for shade.
  - The alpine shrubs come from **a flat brush with its tip splayed on purpose** (バサつかせ). The brush direction changes, vertical and horizontal. The paint is a little thicker so the crowns don't lose to the colour beneath, and a darker colour goes in as shadow accent.
  - Fine branches and leaves are painted **already at the ground stage**, so they "blend with the colour under them, give unity of space, and save finishing".
  - At the end of the ground stage, "the space and contrast from far to near are already pinned; only texture remains, added without breaking the space."

**Rule:** the whole picture (light, colour, atmosphere, space, volume) exists at the lowest level of detail before any detail exists. Detail is a thin last layer that must not break it.

## 3. Grasp the crowd: 群れを捉える (C-1646, p.48)

- The hardest thing in nature painting is "**the rest, the great mass**" (その他大勢), where it's hard to pin down points.
- "If you draw the miscellany without organising it, it doesn't work as a background. Grasp the impression accurately, **organise** it, and then the painter **extracts** the features."
- "When drawing a crowd, don't draw everything in it. Drawing everything crushes the space and weakens the subject's impression."

**Rule:** a mass of like things is painted as one impression with a few extracted members, never member by member.

## 4. Coloured greys (p.48, p.57, p.103)

- Oga's trait: **grey used effectively**, never pure grey but purplish, brownish, greenish greys, "greys that feel coloured" (p.48). Overmixed, they become mud-grey. **Coloured greys scattered among the colours give vividness and lustre.**
- "Trees are basically grey, but not plain grey: greys of some hue, parts where the hue is strong, parts covered in moss." In light, add a bright grey or reflect the sky's colour into the tree's colour. In shadow, go dark **with the tree's own hue strengthened** (talk 4, p.57).
- **C39-5** (p.103): cold, overcast, sad scenes narrow the tone range and lower saturation, and without direct sun the contrast is weak and the picture risks going flat. Use greys: **brown-grey, green-grey, purple-grey, red-grey, yellow-grey**, "a range equal to the normal colours".
- Trunks are mostly grey (except red pine and Kurobe cedar), so **the width of the greys is the depth of the colour** (p.90).

**Rule:** neutrals are always tinted, several tints are used side by side, and in low light the greys carry the whole range of hue.

## 5. Living brushwork: 生きている筆使い (pp.50–51)

- "If the brush traces are alive, the painting is alive." A living brush form gives the **unity** nature needs.
- **Rhythm** (C-0799 moss): big colour and shade at the ground stage, then the tip of the sakuyo brush darting vertically and horizontally, **near-improvised**. "Real fine moss leaves are **not drawn one by one**." Tip, belly and root of the brush; sometimes a splayed tip for a rough touch. "For a crowd you must know **beforehand what shape each brush motion makes**. Practise on scraps."
- **Bold, unhesitating strokes** (C-1471, moonlit moss floor): moss, dead leaves and ferns are kept to a minimum. There's no focal point: only the moon's reflection and **a shadow crossing the whole composition** give the picture its tension.
- **Painting what isn't painted** (C-0822, the roots of a big tree): the moss, ferns and suckers floating in light are captured *only* by **the bright parts of leaves facing the light**, glinting red-brown stems and glowing moss heads. That "makes the unpainted parts felt… close to an illusion", and it takes an understanding of how nature is made. No repeated overpainting; the fewest strokes.
- **The hake** (C-1354, C-0801): gradations across a rock wall and water, and light shafts from the canopy, are laid with the wide hake at the ground stage. It grades two or more hues without raising the paint's density, so the colour stays bright. It's used to **emphasise a direction** in the picture.

**Rule:** a stroke is a known shape used many times at tempo, not a depiction of one leaf. In the light, a few lit marks stand for the whole unpainted mass.

## 6. Space and planes: 空間と面の意識 (pp.52–55)

Vocabulary:
- **抜け (nuke)**, the clearance or openness of a picture. With good nuke, space and perspective are clear and distance is felt; with bad nuke a landscape looks like a miniature.
- **面 (men)**, the plane. "Planes don't match" means no consistency. A character standing on a ground seen from above must match that plane or look tilted. Perspective can be correct and still look artificial: "for nature, over-caring about perspective loosens the space."

The plates:
- **C-0064** (p.52), board vs background: a slope with a distant village. **A ridge line cutting the slope midway**, and **the strong shadow of trees lit from the west**, divide the bright near meadow from the village far off. "**Intentionally severing connected space gives depth.**" The board scattered its points; the background **concentrates them** on the ridge trees. "If something clearly shaped exists somewhere, people recognise the space around it even if the surroundings are vague." Oga gives contrast to nature, which is hard to shape, to make the scale of the space.
- **C-0095** (p.53), ground as a plane: "the hardest is simple ground. Keep in mind a **flat plane with undulations, and grass growing on it**." Otherwise the grass doesn't fit the plane and scatters. The west sun shades the grass clumps and lights the undulations. Several grass types give broad variation, and shadows give contrast. "In a slightly looking-down composition, grass and leaves near are drawn **as seen from above**, far ones **more from the side**." Understand the flow and continuity.
- **C-0022** (p.53), the boundaries between lying planes (grass, ground) and rising planes (stone wall, forest). The whole picture is in shadow and is carried by the volume of the crowns and a glossy stone wall, **mastery of shadow colour**. One thin ray into the dark gives awe.
- **C-0773** (p.54–55), a great landscape: two ridges overlap with cloud passing between; the near rock wall, lit by morning sun, is the point; a small figure among shrubs gives scale.
  - It's pan-focus, so nothing can be blurred. Draw back to front firmly, and use **aerial perspective** (the far approaches the sky colour), **a difference of brush touch**, and **the placement of points**.
  - Eye point: trees above the eye point are drawn from below, trees below it from above. Errors in brush direction or placement break it.

**Rule:** depth is made by severing space (a ridge, a band of shadow) and by concentrating the points; the ground is one plane with undulations and its marks belong to that plane (top view near, side view far).

## 7. Grasping the light source: 光源の捉え方 (pp.56–57, pp.94–97)

- **Set the source consciously**: season, weather and time change the same place (p.56).
- **The sun's colour** (C-0772): a white sun alone doesn't look like light, so add the light's **colour**, above all **where light meets an object's edge** (際):
  - the celeste sky's boundary pale pink; light blue melting into emerald; a flare of pale orange and yellow, prism-like;
  - the far range grading yellow → emerald; the near, directly lit, yellow → orange; chrome green No.1 and light green vivid at the edges of the light;
  - blue and brown greys inside the white-lit cloud for depth.

  Full backlight, and still rich colour.
- **Light and shadow** (C-0792, gorge boulders):
  - Light cuts into the ravine, and **shadow is about 2/3 of the picture**, which makes the light dazzle on the rocks. Light falls only on certain planes; the upper cliff is in shadow. "**Don't spread the light around; concentrate it in one part.**"
  - There are three light levels: direct sun brightest, soft-lit parts, and **reflected light** in the shadow, dim but important.
  - By day the reflected light takes the sky's colour, so it's cool. Alone that's too cold, so add the object's own colour (rock browns, plant greens) to loosen it. "If the shadow reads as shadow compared to the light, warm colours in the shadow are fine", and that widens the range of light and colour.
- **Moonlight, two ways** (C-1482 vs C-1486): airbrush for light in the air itself (fantastical; don't raise its value too high or it goes whitish), or brush alone, where **shadows cast between trees express the light**: crisp, sharp-edged light. "If you don't want the light to diffuse, don't airbrush."
- **Shadows aren't just lower value** (talk 4): "background painters tend to make shadow by lowering value; Oga puts browns in the shadow." Miyazaki: "this cedar could be blacker." Oga admits he tends to paint as he sees, with not enough exaggeration.
- **Pompoko** (pp.94–97):
  - Tilted or limited light gives strong contrast, and **the light's colour enters the shadow**, which sets the dominant tone.
  - **Dusk** (C58-1A): warm light against cool shadow, **purple between blue and pink**, in harmonious combinations, or the colour muddies.
  - **Snow** (board, p.96): lit snow is basically **white**; colour goes only in the shadows, and distance and space must be expressed there. The snow's own shading (its volume) is blue-grey; shadows cast *on* the snow surface are celeste. **Two shadow families.** Scattered bounce from the snow is shown.
  - **Intrinsic colour vs light colour** (C11-1): every natural thing has its own colour, but browns look greenish or bluish under scattered and indirect light. An old cherry, black-brown to grey, is painted bluish because of moss; dry moss on old trees and rocks goes whitish and can take varied colours as if it reflects something. A trunk in shadow gets red-brown and green: "rich, not lonely". **A strong near shadow makes the far nuke good.**
  - **Low side sun into woods** (C2-2): the long shadows and complex ground are **organised**, then the point light and shadow are painted, and after that few strokes are needed. Backlight is easier (shapes as silhouettes, light easy to place). Front light is hard (colour, detail and volume of the lit object).
  - **Light on a floor** (C63-3): the lit floor must read as **the same plane** as the unlit floor. Too much difference in value or chroma and the lit part pops out. Shadow angles must be natural or they stop reading as the floor's.

**Rule:** one light, concentrated; shadow is the majority and is full of colour (cool reflected light plus the object's warm colour, at the widest range that still reads as shadow); the light's colour lives at its edges.

## 8. Balance and density: 画面のバランスと密度 (pp.58–59)

- "Density doesn't come from drawing-in alone. Cover everything with fine detail and it's just 'a fine picture'."
- **Narrow down the points**, where the eye will look. "The viewer looks first at the points; the vague parts get completed by the viewer. **Concentrate density at the points and the whole feels dense.** Scatter the points and the density thins."
- C-0027 and C-0051 (2 s and 2.5 s cuts): the contrast of a west-lit village against a mountain's shadow; the detail isn't fine; part is left at the ground stage.
- C-0049 (4.5 s): rough, quick touches, because the focus is the falling tower.
- Talk (p.134): "Density isn't about filling… find the **conditions under which the picture holds without detail**, place them well, and a different density is born." *Pompoko* settled its points by season: which flowers bloom, what state the grass is in.

**Rule:** density is a property of the points, not of the area. Choose them (few), give them the detail, and let the rest hold at ground level.

## 9. Omission and exaggeration: 省略と誇張 (デフォルメ) (pp.60–61)

- Narrowed points, omitted and exaggerated, look rough but have **tension**. The information must be **organised**, or omission looks like cutting corners.
- **C-0007** (p.60), board vs background: the board's strong west-sun orange and long shadows fall on the distant trees too, so there's little depth. The background moves to earlier in the afternoon and **softens the shadows' contrast going back**, so perspective appears. The near shrubs are in clear detail; the far ones are omitted. "Bringing the point to the front makes it possible to omit the rest."
- **C-0025** (p.61): the tower and the far mountains overlap; the middle mountains are split left and right; a shadow runs from centre front to the back. The staging has priorities (見得, a kabuki "pose").
- **C-0827** (p.61), close broadleaf evergreens, "**omission after capturing the features**": **form, colour and light are the three elements**. Real foliage is chaotic; organised foliage keeps its volume and a dynamic space. "It isn't an encyclopedia." Capture the whole impression of colour, form and light broadly, *then* add texture.
- Observation isn't carelessness (適当). Omission is a decision; carelessness isn't (p.89).

**Rule:** omission is the other half of the points: keep form, colour and light, drop the members, and let contrast soften with distance.

## 10. Location reference and research (pp.62–63, p.137)

- **Shadow colour** (C-0781, p.62): in shadow the tone range narrows, and the picture goes lonely and poor. **Use the widest range of colours that still reads as shadow.** For a moist shadow, don't rely on cool colours only: use the object's natural warm colours, from the memory of the air, texture, vegetation and weather on location.
- **Stone wall in shadow** (C-0008): at the ground stage, thin low-value paint lets particles float on the paper and gives a rough texture. Then opaque colour goes on firmly: a varied texture.
- **Reference** (C-0053, p.63): photos are hints, never copied into the space or composition. The red-barked Kurobe cedar is a one-point accent.
- "Just paint it naturally, **as if it is there**" (それがそこにあるように自然に, p.98). But that takes everything together: colour, contrast, degree of detail, omission, exaggeration.

## 11. Air: 空気感 (pp.98–99)

- **Humidity and air**: low humidity gives good nuke and more depth; hazy heat means high humidity.
- **C5-3** (p.98): the moonlit panorama in Oga's own low-humidity air. What makes the space is how things look at that distance, the detail at that distance, and the colour of moonlit space. The wide view isn't overdetailed, and the orange construction machinery is the one point that creates the distance.
- **C40-1**, aerial perspective (空気遠近, p.99): far objects approach the sky's colour and melt into it.
- **C24-1**, humid woods: few light colours, value held down, the objects' colours kept inside it, so there's **lustre in the dark**.

## 12. Layout and composition (pp.100–101)

- **C1-1** (p.100): a three-layer "book" of bamboo in front, dark, against bright paddies far. The shadow parts are coloured, so it never becomes a lonely diagram. The far is drawn from slightly above, the near bamboo from the front, which gives the not-too-neat **offset (ずれ)** of natural vegetation, "so the composition doesn't become explanatory".
- The picture holds as BG-only; seasonal plants and accurate structures give scale.

## 13. Colour and space (pp.102–103)

- **C1-2**, scattering colour: many colours, unified. The persimmon is the point. The far satoyama trees are each pale but spread widely through purple, pink and orange; the cedar's chrome green gives colour contrast. **The near grass's value is *not* lowered, so the brightness holds; a firm shadow along the path gives the contrast instead.**
- **C15-13**: the red earth divides the green near from the pale blue sky. A blue roof and red cones are accents, to add colours.

## 14. Elegance and play: 風流さと遊び心 (pp.104–108)

- Season, region, vegetation and weather are the art department's to decide. A **seasonal flower works as a kigo** (a season word in a haiku): a minimum of objects conveys the season.
- **C17-3**, cherry: the real sky in cherry season is whitish, but it's painted clear blue anyway. The blossom is **flat opaque dabs in three values (white, lilac, blue-lilac)** on the blue, with broken black branch strokes.

## 15. The working order, from the cover (pp.4–11)

1. Pencil drawing directly on the paper; stretch the paper (水張り).
2. Mix only as needed; control by the amount of paint and water on the brush.
3. **Ground stage, far to near**: sky (white, then greys) → far peak in the wet (the staggered flat brush) → middle rocks → near vegetation (the splayed flat brush, strokes vertical and horizontal) → fine branches and leaves in the ground stage.
4. Let it dry for 1–2 hours.
5. **Finish 1**: normally far to near, but first put **one deliberately strong touch** on the middle rocks, to read the balance of colour and contrast. Then **add only where it's weak**, "so at least you never overdraw".
6. **Finish 2**, bright and dark: lustrous deep colours in the shrub and rock shadows. The dark tightens the picture, so the bright parts now look lacking; add **vivid** brights. Then branch detail and highlights. "**Don't rely on value difference alone; always use bright colours that sing** (発色の良い)."
7. **Finish 3–4**: rock texture; **bright, conspicuous leaf shapes to make the shrub's contour stand out**; shadow into the branches. Grass with a slightly splayed sakuyo; moss with a one-sided blur (片ボカシ). Reference for the species.
8. **Finish 5**: flower petals; "if the picture wants a 'flower' (華), add more flowers as a service". Step back, check from a distance, add intuitively where something is lacking. About 11 hours from the ground stage.

The cover's palette by passage (p.10):

| Passage | Colours |
|---|---|
| far mountain | cobalt blue, chrome green No.3 to sepia to black, heliotrope, emerald (plus sky mixes) |
| middle rock | jaune brillant, French grey, blue celeste (plus sky) |
| shrubs | olive, cobalt violet, black, cobalt blue, sepia, heliotrope |
| dark foliage | chrome green No.2, peacock blue |
| grass area | jaune brillant, light green, emerald |
| near rock | the base plus scarlet lake |
| grass | cobalt green, chrome green No.1, orange |

## 16. Things said in passing that bind

- "**Look and steal**" (見て盗む) is the whole method of learning (p.129).
- Oga's mixing is a cook's, pinch by pinch; "don't copy others' mixes; learn the combinations in which colour comes alive in your own paint" (p.106).
- Summer leaves are the hardest (all green); autumn is easy. *Totoro*'s green was too bright and bluish (emerald); it should have been a deeper green with red-brown in it (p.107).
- "Monet plus Kawai Gyokudō, divided by two" (p.106).
- "Even when it isn't working, a big brush and a bold correction often beats nursing it" (p.132). A washed-out failure once left beautiful residual colour.
- The column on the airbrush (p.137): blowing the same colour back comes out whitish, because the particles float, so blow a slightly higher chroma.

---

## The model in one paragraph

A background is the ground and space for a life. Settle light, colour and atmosphere first, at the lowest level of detail, as nearly finished as possible (地塗り). Make depth by severing space and concentrating the points (抜け, 面). Keep one light, concentrated. Shadow takes most of the picture and holds its widest range of colour: cool reflected light, the object's warm colour, the light's colour at the edges. Hold the big value range together with saturated mid-tones and unmixed accents. Tint every grey. Paint crowds as organised impressions with extracted members, using known brush shapes at tempo, and in the light let a few lit marks stand for the unpainted mass. Put density only at the points. Omit the rest by keeping form, colour and light, and soften contrast with distance. Then add detail thinly, and only where it's weak.

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
for i in [0,1,2,3,4,5,147]:
    im=Image.open(f'pages/p-{i:03d}.jpg'); im.thumbnail((400,490)); im.save(f'(manager scratchpad)/t{i}.jpg')
" && python3 - <<'EOF'
from PIL import Image
S='(manager scratchpad)/'
ims=[Image.open(S+f't{i}.jpg') for i in [0,1,2,3,4,5,147]]
W=sum(i.width for i in ims); out=Image.new('RGB',(W,490),'white'); x=0
for i in ims: out.paste(i,(x,0)); x+=i.width
out.save(S+'front.jpg')
EOF

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && mkdir -p plates src sheets && cat > work/grid.py <<'EOF'
import sys
from PIL import Image, ImageDraw
i=int(sys.argv[1]); im=Image.open(f'pages/p-{i:03d}.jpg').convert('RGB'); im.thumbnail((700,860))
d=ImageDraw.Draw(im); W,H=im.size
for k in range(1,10):
    d.line([(W*k/10,0),(W*k/10,H)],fill=(255,0,0)); d.line([(0,H*k/10),(W,H*k/10)],fill=(255,0,0))
    d.text((W*k/10+2,2),str(k),fill=(255,0,0)); d.text((2,H*k/10+2),str(k),fill=(255,0,0))
im.save(f'(manager scratchpad)/g{i}.jpg')
EOF
for i in 0 46 58 54 62 105 98 50; do python3 work/grid.py $i; done; python3 - <<'EOF'
from PIL import Image
S='(manager scratchpad)/'
for grp,ids in [('A',[0,46,58,54]),('B',[62,105,98,50])]:
    ims=[Image.open(S+f'g{i}.jpg') for i in ids]
    out=Image.new('RGB',(sum(i.width for i in ims),max(i.height for i in ims)),'white');x=0
    for i in ims: out.paste(i,(x,0)); x+=i.width
    out.save(S+f'grid{grp}.jpg')
EOF

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && cat > work/plates.py <<'EOF'
from PIL import Image
P={ # name: (page_idx, x0,y0,x1,y1 fractions), folio = idx-2
 'cover_final':(0,0.0,0.08,1.0,1.0),
 'C0081_greens':(46,0.085,0.315,0.99,0.70),
 'C0772_sun':(58,0.365,0.345,0.94,0.63),
 'C0792_boulders':(58,0.365,0.66,0.94,0.915),
 'C0064_bg':(54,0.035,0.445,0.98,0.745),
 'C0007_board':(62,0.375,0.315,1.0,0.61),
 'C0007_bg':(62,0.375,0.645,1.0,0.92),
 'C39-5_greys':(105,0.365,0.525,0.95,0.855),
 'snow_board':(98,0.065,0.025,0.94,0.38),
 'C11-1_backlit':(98,0.06,0.44,1.0,0.64),
 'C1646_crowd':(50,0.045,0.205,0.62,0.51),
}
for k,(i,a,b,c,d) in P.items():
    im=Image.open(f'pages/p-{i:03d}.jpg').convert('RGB'); W,H=im.size
    im.crop((int(a*W),int(b*H),int(c*W),int(d*H))).save(f'plates/{k}.png')
    print(k, im.crop((int(a*W),int(b*H),int(c*W),int(d*H))).size)
EOF
python3 work/plates.py && python3 - <<'EOF'
from PIL import Image; import glob
S='(manager scratchpad)/'
fs=sorted(glob.glob('~/work/pixelart-studies/books/oga/plates/*.png'))
ims=[Image.open(f) for f in fs]
for i in ims: i.thumbnail((420,300))
out=Image.new('RGB',(4*430,3*310),'white')
for n,i in enumerate(ims): out.paste(i,((n%4)*430,(n//4)*310))
out.save(S+'plates.jpg')
EOF

# output:
cover_final (1236, 1392)
C0081_greens (1118, 582)
C0772_sun (710, 431)
C0792_boulders (710, 386)
C0064_bg (1168, 454)
C0007_board (773, 446)
C0007_bg (773, 416)
C39-5_greys (723, 499)
snow_board (1081, 537)
C11-1_backlit (1162, 302)
C1646_crowd (711, 462)

cd ~/work/pixelart-studies/books/oga && sed -i '' "s/'cover_final':(0,0.0,0.08,1.0,1.0)/'cover_final':(0,0.0,0.08,0.60,1.0)/; s/'snow_board':(98,0.065,0.025,0.94,0.38)/'snow_board':(98,0.065,0.03,0.60,0.37)/; s/'C1646_crowd':(50,0.045,0.205,0.62,0.51)/'C1646_crowd':(50,0.045,0.205,0.62,0.49)/" work/plates.py && python3 work/plates.py >/dev/null && python3 -c "
from PIL import Image
for k in ['cover_final','snow_board']:
  im=Image.open('plates/'+k+'.png'); im.thumbnail((500,500)); im.save('(manager scratchpad)/'+k+'.jpg')"

# output:
(Bash completed with no output)

ls ~/work/naturalist/ | head; find ~/work/naturalist ~/work/pixelart-studies/elements/{canopy,treeline,understory,conifers,broadleaf,water,snowpeak}/refs -iname '*.jp*g' 2>/dev/null | head -60; cat ~/work/pixelart-studies/tools/imgfetch.py | head -40

# output:
DECISIONS-FOR-DAVID.md
README.md
animals
geo
hydro
letters
people
plants
questions
shared
~/work/pixelart-studies/elements/canopy/refs/oly_obliques_2016.jpg
~/work/pixelart-studies/elements/canopy/refs/sj_obliques_2016.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/openverse_Mount_Stuart_from_Ingalls_Summit_e801651c.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/openverse_Ingalls_Lake_and_Mount_Stuart_66922da2.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/openverse_Mount_Stuart_in_fog_from_near_Ingalls_Pass_21_Oc_7b009b8c.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/commons_Mount_Stuart_House_marble_hall_2018_08_25_jpg_311951ad.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/commons_Mount_Stuart_House_Isle_of_Bute_east_view_jpg_c1570e72.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/commons_Mount_Stuart_House_2018_08_25_jpg_1748e912.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/openverse_Ingalls_Peak_and_Mount_Stuart_from_Headlight_Bas_71839d4d.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/openverse_View_from_Ingalls_Pass_3ec2f44f.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/_sheet.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/commons_Mount_Stuart_House_Isle_of_Bute_west_view_jpg_04a3e3f5.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/openverse_Mount_Stuart_d514267b.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/commons_Mount_Stuart_in_fog_from_near_Ingalls_Pass_21_Oc_464d60cf.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Stuart_from_Ingalls/commons_Mount_Stuart_from_Longs_Pass_jpg_19780859.jpg
~/work/pixelart-studies/elements/broadleaf/refs/row_madrone.jpg
~/work/pixelart-studies/elements/broadleaf/refs/row_oak.jpg
~/work/pixelart-studies/elements/broadleaf/refs/row_maple.jpg
~/work/pixelart-studies/elements/broadleaf/refs/row_alder.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Rainier_from_Sunrise/commons_Mount_Rainier_from_Sunrise_WA1_jpg_a0f784d8.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Rainier_from_Sunrise/openverse_Mount_Rainier_from_Sunrise_Point_e4eb37b8.jpg
~/work/pixelart-studies/elements/snowpeak/refs/Mount_Rainier_from_Sunrise/commons_Peak_of_Mount_Rainier_from_Washington_SR_410_jus_0b710789.jpg
~/work/pixelart-studies/elements/sno

cd ~/work/pixelart-studies/books/oga && mkdir -p refs && cat > refs/queries.txt <<'EOF'
hoh rain forest moss
olympic national park meadow
cascade mountains forest lake
subalpine meadow wildflowers washington
douglas fir forest light
mount rainier meadow
snowy forest clearing
mountain valley morning mist forest
larch autumn snow
river gravel bar forest washington
EOF
nice -n 10 python3 ~/work/pixelart-studies/tools/imgfetch.py -f refs/queries.txt -n 8 -o refs --width 1200 --sheet 2>&1 | tail -5; du -sh refs

# output:
Command did not complete within its 120s timeout and was moved to the background (ID: bsm5mhrp0). 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/pixelart-studies/library; directory changes made by the backgrounded command do not apply to subsequent commands.

"""OKLab / OKLCh helpers (numpy). Arrays of shape (...,3), sRGB in 0..1."""
import numpy as np


def srgb_to_lin(c):
    c = np.asarray(c, np.float64)
    return np.where(c <= 0.04045, c / 12.92, ((c + 0.055) / 1.055) ** 2.4)


def lin_to_srgb(c):
    c = np.clip(c, 0, 1)
    return np.where(c <= 0.0031308, c * 12.92, 1.055 * c ** (1 / 2.4) - 0.055)


_M1 = np.array([[0.4122214708, 0.5363325363, 0.0514459929],
                [0.2119034982, 0.6806995451, 0.1073969566],
                [0.0883024619, 0.2817188376, 0.6299787005]])
_M2 = np.array([[0.2104542553, 0.7936177850, -0.0040720468],
                [1.9779984951, -2.4285922050, 0.4505937099],
                [0.0259040371, 0.7827717662, -0.8086757660]])


def rgb_to_oklab(rgb):
    lms = srgb_to_lin(rgb) @ _M1.T
    return np.cbrt(lms) @ _M2.T


def oklab_to_rgb(lab):
    lms_ = np.asarray(lab) @ np.linalg.inv(_M2).T
    return lin_to_srgb((lms_ ** 3) @ np.linalg.inv(_M1).T)


def lab_to_lch(lab):
    L, a, b = lab[..., 0], lab[..., 1], lab[..., 2]
    return np.stack([L, np.hypot(a, b), np.arctan2(b, a)], -1)


def lch_to_lab(lch):
    L, C, h = lch[..., 0], lch[..., 1], lch[..., 2]
    return np.stack([L, C * np.cos(h), C * np.sin(h)], -1)


def hexrgb(h):
    h = h.lstrip('#')
    return np.array([int(h[i:i + 2], 16) for i in (0, 2, 4)]) / 255.0


def u8(rgb):
    return (np.clip(rgb, 0, 1) * 255 + 0.5).astype(np.uint8)

"""Measure Oga's plates (and photos / renders) for the book's claims.

  python3 measure.py img1 img2 ...   -> table of numbers

Every image is first area-reduced to 320 px wide, the size we paint at, so all numbers are
comparable across plates, photos and renders.

Numbers (all in OKLab):
  shadow%   share of pixels in the dark family (Otsu split of L)      [book: shadow ~2/3, p.56]
  Llit/Lsh  mean L of lit family / shadow family
  Csh/Clit  mean chroma of shadow family / lit family
  hue_sh    circular hue spread (0..1) in the shadow family: how many hues live in the shadow
  abSD_sh   std of (a,b) in shadow / in lit                              [book: widest range in shadow, p.62]
  grey%     share of low-chroma pixels (C<.04) ; pureGrey = share of those with C<.012
  tints     number of 45-degree hue sectors holding >=10% of the low-chroma pixels [coloured greys, p.48]
  midC      chroma of the mid-L third / mean chroma of top and bottom thirds    [bridging mid-tones, p.44]
  dens20    share of fine-detail energy in the busiest 20% of 16x16 blocks     [density at points, p.58]
"""
import sys
import numpy as np
from PIL import Image
sys.path.insert(0, __file__.rsplit('/', 1)[0])
from okl import rgb_to_oklab


def load320(path, w=320):
    im = Image.open(path).convert('RGB')
    h = max(1, round(im.height * w / im.width))
    return np.asarray(im.resize((w, h), Image.BOX), np.float64) / 255.0


def otsu(x, bins=128):
    h, e = np.histogram(x, bins=bins)
    c = (e[:-1] + e[1:]) / 2
    w0 = np.cumsum(h); w1 = w0[-1] - w0
    m0 = np.cumsum(h * c) / np.maximum(w0, 1)
    m1 = (np.sum(h * c) - np.cumsum(h * c)) / np.maximum(w1, 1)
    return c[np.argmax(w0 * w1 * (m0 - m1) ** 2)]


def circ_spread(h, w=None):
    w = np.ones_like(h) if w is None else w
    R = np.hypot((w * np.cos(h)).sum(), (w * np.sin(h)).sum()) / max(w.sum(), 1e-9)
    return 1 - R


def stats(rgb):
    lab = rgb_to_oklab(rgb)
    L, a, b = lab[..., 0], lab[..., 1], lab[..., 2]
    C = np.hypot(a, b); H = np.arctan2(b, a)
    t = otsu(L)
    sh = L < t; lt = ~sh
    out = {}
    out['shadow%'] = 100 * sh.mean()
    out['Llit'] = L[lt].mean(); out['Lsh'] = L[sh].mean()
    out['Csh'] = C[sh].mean(); out['Clit'] = C[lt].mean()
    out['hue_sh'] = circ_spread(H[sh], C[sh])
    out['abSD_sh'] = np.sqrt(a[sh].var() + b[sh].var())
    out['abSD_lit'] = np.sqrt(a[lt].var() + b[lt].var())
    g = C < 0.04
    out['grey%'] = 100 * g.mean()
    out['pureGrey'] = 100 * (C[g] < 0.012).mean() if g.any() else 0
    if g.sum() > 20:
        sec = ((H[g] + np.pi) / (np.pi / 4)).astype(int) % 8
        share = np.bincount(sec, minlength=8) / g.sum()
        out['tints'] = int((share >= 0.10).sum())
    else:
        out['tints'] = 0
    q1, q2 = np.quantile(L, [1 / 3, 2 / 3])
    mid = C[(L >= q1) & (L < q2)].mean()
    ends = 0.5 * (C[L < q1].mean() + C[L >= q2].mean())
    out['midC'] = mid / max(ends, 1e-9)
    # fine-detail energy: |L - 3x3 box blur|
    from scipy.ndimage import uniform_filter
    hf = np.abs(L - uniform_filter(L, 3))
    Hh, Ww = (L.shape[0] // 16) * 16, (L.shape[1] // 16) * 16
    blk = hf[:Hh, :Ww].reshape(Hh // 16, 16, Ww // 16, 16).sum((1, 3)).ravel()
    blk = np.sort(blk)[::-1]
    out['dens20'] = 100 * blk[:max(1, len(blk) // 5)].sum() / blk.sum()
    return out


COLS = ['shadow%', 'Llit', 'Lsh', 'Csh', 'Clit', 'hue_sh', 'abSD_sh', 'abSD_lit', 'grey%', 'pureGrey',
        'tints', 'midC', 'dens20']


def table(paths, names=None):
    rows = []
    for i, p in enumerate(paths):
        s = stats(load320(p))
        rows.append((names[i] if names else p.rsplit('/', 1)[-1][:28], s))
    hdr = f"{'image':30s}" + ''.join(f'{c:>9s}' for c in COLS)
    lines = [hdr]
    for n, s in rows:
        lines.append(f'{n:30s}' + ''.join(f'{s[c]:9.3f}' if isinstance(s[c], float) else f'{s[c]:9d}' for c in COLS))
    return '\n'.join(lines), rows


if __name__ == '__main__':
    print(table(sys.argv[1:])[0])

cd ~/work/pixelart-studies/books/oga && python3 src/measure.py plates/*.png; tail -3 (tmp)

# output:
image                           shadow%     Llit      Lsh      Csh     Clit   hue_sh  abSD_sh abSD_lit    grey% pureGrey    tints     midC   dens20
C0007_bg.png                     54.355    0.761    0.469    0.052    0.112    0.026    0.038    0.055   31.940   44.590        4    1.408   34.502
C0007_board.png                  49.963    0.838    0.470    0.052    0.127    0.027    0.034    0.061   28.615   38.937        3    1.340   36.316
C0064_bg.png                     55.701    0.807    0.525    0.059    0.103    0.016    0.028    0.058   24.143   28.758        3    1.289   31.591
C0081_greens.png                 41.733    0.819    0.527    0.044    0.106    0.042    0.035    0.051   29.884   57.671        3    1.571   35.228
C0772_sun.png                    38.950    0.852    0.524    0.036    0.058    0.236    0.031    0.047   52.614   21.177        3    2.808   46.548
C0792_boulders.png               83.064    0.713    0.409    0.026    0.028    0.066    0.016    0.030   86.862    9.420        2    1.048   35.461
C11-1_backlit.png                57.986    0.744    0.464    0.017    0.056    0.828    0.023    0.070   71.491   44.001        4    1.227   32.561
C1646_crowd.png                  68.690    0.699    0.442    0.019    0.034    0.409    0.021    0.036   83.990   32.061        4    1.190   30.831
C39-5_greys.png                  58.006    0.747    0.465    0.016    0.019    0.377    0.014    0.021   96.732   33.760        4    0.964   32.841
cover_final.png                  39.163    0.948    0.528    0.025    0.011    0.575    0.032    0.022   89.957   65.939        2    2.206   60.328
snow_board.png                   34.734    0.921    0.626    0.032    0.021    0.071    0.021    0.015   82.583   23.201        2    1.346   41.264
 32M    refs

[exited with code 0]

cd ~/work/pixelart-studies/books/oga/refs && ls; ls */ | head -100 | wc -l

# output:
cascade_mountains_forest_lake
douglas_fir_forest_light
hoh_rain_forest_moss
larch_autumn_snow
mount_rainier_meadow
mountain_valley_morning_mist_forest
olympic_national_park_meadow
queries.txt
river_gravel_bar_forest_washington
snowy_forest_clearing
subalpine_meadow_wildflowers_washington
     100

cd ~/work/pixelart-studies/books/oga/refs && python3 - <<'EOF'
from PIL import Image, ImageDraw
import glob,os
S='(manager scratchpad)/'
dirs=sorted(d for d in os.listdir('.') if os.path.isdir(d))
for k in range(0,len(dirs),5):
    rows=[]
    out=Image.new('RGB',(8*200,5*150+5*14),'white'); dr=ImageDraw.Draw(out)
    for r,d in enumerate(dirs[k:k+5]):
        fs=sorted(f for f in glob.glob(d+'/*.jpg') if '_sheet' not in f)[:8]
        dr.text((2,r*164),d,fill='black')
        for c,f in enumerate(fs):
            im=Image.open(f).convert('RGB'); im.thumbnail((196,148))
            out.paste(im,(c*200,r*164+14)); dr.text((c*200+2,r*164+14),str(c),fill='red')
    out.save(S+f'refs{k}.jpg')
EOF

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga/refs && mkdir -p pick && python3 - <<'EOF'
import glob,shutil
sel={'cascade_mountains_forest_lake':[1,4,5],'douglas_fir_forest_light':[2,4],'hoh_rain_forest_moss':[2,3,6],'larch_autumn_snow':[4,5],
'mount_rainier_meadow':[2,3,4],'mountain_valley_morning_mist_forest':[2,3],'olympic_national_park_meadow':[3],'river_gravel_bar_forest_washington':[1,3],
'snowy_forest_clearing':[2,3],'subalpine_meadow_wildflowers_washington':[3,4,5]}
for d,ix in sel.items():
    fs=sorted(f for f in glob.glob(d+'/*.jpg') if '_sheet' not in f)
    for i in ix:
        shutil.copy(fs[i], f'pick/{d.split("_")[0]}_{d.split("_")[1]}_{i}.jpg')
EOF
ls pick; cd .. && python3 src/measure.py refs/pick/*.jpg

# output:
cascade_mountains_1.jpg
cascade_mountains_4.jpg
cascade_mountains_5.jpg
douglas_fir_2.jpg
douglas_fir_4.jpg
hoh_rain_2.jpg
hoh_rain_3.jpg
hoh_rain_6.jpg
larch_autumn_4.jpg
larch_autumn_5.jpg
mount_rainier_2.jpg
mount_rainier_3.jpg
mount_rainier_4.jpg
mountain_valley_2.jpg
mountain_valley_3.jpg
olympic_national_3.jpg
river_gravel_1.jpg
river_gravel_3.jpg
snowy_forest_2.jpg
snowy_forest_3.jpg
subalpine_meadow_3.jpg
subalpine_meadow_4.jpg
subalpine_meadow_5.jpg
image                           shadow%     Llit      Lsh      Csh     Clit   hue_sh  abSD_sh abSD_lit    grey% pureGrey    tints     midC   dens20
cascade_mountains_1.jpg          40.442    0.661    0.368    0.054    0.084    0.139    0.038    0.070   22.236    7.657        6    1.289   31.765
cascade_mountains_4.jpg          44.109    0.666    0.295    0.028    0.021    0.175    0.021    0.023   86.015   27.118        4    1.441   44.877
cascade_mountains_5.jpg          51.621    0.776    0.469    0.065    0.053    0.700    0.073    0.066   41.235   41.326        3    1.730   34.944
douglas_fir_2.jpg                72.383    0.709    0.395    0.025    0.032    0.286    0.023    0.029   79.184   26.169        4    1.147   28.175
douglas_fir_4.jpg                74.604    0.742    0.390    0.057    0.030    0.052    0.026    0.020   30.294    3.923        2    1.377   35.965
hoh_rain_2.jpg                   44.711    0.577    0.334    0.073    0.119    0.017    0.029    0.028    5.728   12.193        2    1.077   26.305
hoh_rain_3.jpg                   46.335    0.635    0.377    0.087    0.147    0.028    0.035    0.031    2.933    2.290        2    1.076   24.837
hoh_rain_6.jpg                   57.698    0.581    0.309    0.062    0.116    0.017    0.025    0.028    9.706    7.955        1    1.018   27.693
larch_autumn_4.jpg               47.925    0.833    0.408    0.029    0.044    0.338    0.033    0.031   54.434   47.701        4    1.185   38.666
larch_autumn_5.jpg               37.641    0.686    0.329    0.042    0.066    0.740    0.045    0.072   27.012   21.577        3    1.470   32.558
mount_rainier_2.jpg              30.234    0.579    0.277    0.027    0.076    0.228    0.026    0.057   35.615   33.956        2    1.496   47.223
mount_rainier_3.jpg              58.636    0.747    0.405    0.064    0.039    0.098    0.043    0.047   42.735   27.473        3    1.533   36.990
mount_rainier_4.jpg              79.616    0.813    0.430    0.051    0.032    0.074    0.038    0.034   46.516   37.663        4    2.053   31.715
mountain_valley_2.jpg            48.212    0.793    0.422    0.034    0.017    0.045    0.021    0.016   83.036   28.712        2    0.892   49.141
mountain_valley_3.jpg            21.835    0.706    0.162    0.028    0.051    0.257    0.023    0.018   40.158    5.366        3    1.425   56.319
olympic_national_3.jpg           57.701    0.720    0.449    0.088    0.146    0.076    0.041    0.056    2.141   10.064        2    0.935   26.980
river_gravel_1.jpg   

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np, glob
from measure import load320, otsu
from okl import rgb_to_oklab
def row(p):
    lab=rgb_to_oklab(load320(p)); L=lab[...,0]; C=np.hypot(lab[...,1],lab[...,2])
    t=otsu(L); sh=L<t
    p2,p50,p98=np.quantile(L,[.02,.5,.98])
    dark=L<np.quantile(L,.1)
    return p2,p50,p98,C[dark].mean(),L[sh].std(),np.sqrt(lab[...,1][sh].var()+lab[...,2][sh].var())/L[sh].std()
for grp,fs in [('OGA',sorted(glob.glob('plates/*.png'))),('PHOTO',sorted(glob.glob('refs/pick/*.jpg')))]:
    R=np.array([row(f) for f in fs])
    for f,r in zip(fs,R): print(f'{f.split("/")[-1][:24]:26s}'+' '.join(f'{x:6.3f}' for x in r))
    print(grp,'median  Lp2 Lp50 Lp98 Cdark10 LSDsh ab/L_sh:', ' '.join(f'{x:6.3f}' for x in np.median(R,0)));print()
EOF

# output:
C0007_bg.png               0.340  0.595  0.973  0.011  0.087  0.439
C0007_board.png            0.334  0.652  0.976  0.015  0.089  0.386
C0064_bg.png               0.386  0.629  0.963  0.027  0.077  0.360
C0081_greens.png           0.378  0.711  0.963  0.007  0.098  0.357
C0772_sun.png              0.409  0.762  0.965  0.021  0.071  0.428
C0792_boulders.png         0.314  0.419  0.880  0.018  0.063  0.261
C11-1_backlit.png          0.351  0.554  0.960  0.009  0.070  0.321
C1646_crowd.png            0.321  0.501  0.961  0.007  0.074  0.279
C39-5_greys.png            0.323  0.563  0.963  0.013  0.081  0.176
cover_final.png            0.376  0.850  0.992  0.012  0.112  0.290
snow_board.png             0.439  0.889  0.966  0.021  0.102  0.206
OGA median  Lp2 Lp50 Lp98 Cdark10 LSDsh ab/L_sh:  0.351  0.629  0.963  0.013  0.081  0.321

cascade_mountains_1.jpg    0.174  0.570  0.801  0.029  0.105  0.367
cascade_mountains_4.jpg    0.172  0.545  0.839  0.026  0.084  0.246
cascade_mountains_5.jpg    0.244  0.613  0.980  0.038  0.111  0.655
douglas_fir_2.jpg          0.216  0.454  0.939  0.014  0.092  0.254
douglas_fir_4.jpg          0.202  0.439  0.889  0.041  0.096  0.268
hoh_rain_2.jpg             0.163  0.476  0.739  0.039  0.085  0.338
hoh_rain_3.jpg             0.201  0.519  0.828  0.049  0.090  0.394
hoh_rain_6.jpg             0.168  0.406  0.787  0.031  0.079  0.319
larch_autumn_4.jpg         0.144  0.647  0.959  0.016  0.140  0.237
larch_autumn_5.jpg         0.134  0.593  0.939  0.026  0.110  0.411
mount_rainier_2.jpg        0.146  0.542  0.783  0.013  0.090  0.285
mount_rainier_3.jpg        0.178  0.506  0.914  0.031  0.102  0.416
mount_rainier_4.jpg        0.221  0.482  0.942  0.009  0.105  0.359
mountain_valley_2.jpg      0.291  0.621  0.906  0.032  0.081  0.259
mountain_valley_3.jpg      0.058  0.692  0.826  0.022  0.093  0.246
olympic_national_3.jpg     0.220  0.552  0.887  0.054  0.099  0.416
river_gravel_1.jpg         0.250  0.445  0.661  0.039  0.060  0.303
river_gravel_3.jpg         0.200  0.435  0.949  0.009  0.096  0.176
snowy_forest_2.jpg         0.326  0.652  0.902  0.010  0.080  0.198
snowy_forest_3.jpg         0.267  0.641  0.974  0.010  0.105  0.081
subalpine_meadow_3.jpg     0.216  0.531  0.814  0.036  0.082  0.423
subalpine_meadow_4.jpg     0.297  0.647  0.985  0.072  0.098  0.652
subalpine_meadow_5.jpg     0.169  0.462  0.963  0.025  0.085  0.498
PHOTO median  Lp2 Lp50 Lp98 Cdark10 LSDsh ab/L_sh:  0.201  0.542  0.902  0.029  0.093  0.319

cd ~/work/pixelart-studies/books/oga && python3 -c "
import sys; sys.path.insert(0,'src'); import numpy as np
from PIL import Image; from okl import rgb_to_oklab
for i in [0,46,105,52]:
  a=np.asarray(Image.open(f'pages/p-{i:03d}.jpg').convert('RGB'),float)/255
  L=rgb_to_oklab(a[::2,::2])[...,0]; print(i, np.quantile(L,[.001,.01]).round(3))
"

# output:
0 [0.312 0.351]
46 [0.349 0.379]
105 [0.292 0.331]
52 [0.354 0.395]

cd ~/work/pixelart-studies/books/oga && cat >> work/plates.py <<'EOF'

# --- levels calibration: the scan's black point is ~L .30 (text black), paper white slightly tinted.
import numpy as np
def page_levels(i):
    a=np.asarray(Image.open(f'pages/p-{i:03d}.jpg').convert('RGB'),float)[::2,::2].reshape(-1,3)
    s=a.sum(1); o=np.argsort(s)
    k=np.median(a[o[:max(50,len(o)//1000)]],0); w=np.median(a[o[-len(o)//100:]],0)
    return k,w
for k_,(i,a,b,c,d) in P.items():
    k,w=page_levels(i)
    im=np.asarray(Image.open(f'plates/{k_}.png'),float)
    # linearise-ish: do levels in sRGB, then gentle so mid tones keep; clip
    out=np.clip((im-k)/(w-k),0,1)
    Image.fromarray((out*255+.5).astype(np.uint8)).save(f'plates/lv/{k_}.png')
    print(k_, 'black',k.round(0),'white',w.round(0))
EOF
mkdir -p plates/lv && python3 work/plates.py | tail -11

# output:
cover_final black [40. 46. 56.] white [252. 253. 254.]
C0081_greens black [57. 56. 57.] white [254. 255. 255.]
C0772_sun black [38. 46. 52.] white [254. 255. 255.]
C0792_boulders black [38. 46. 52.] white [254. 255. 255.]
C0064_bg black [49. 57. 49.] white [254. 255. 255.]
C0007_board black [42. 48. 43.] white [254. 255. 255.]
C0007_bg black [42. 48. 43.] white [254. 255. 255.]
C39-5_greys black [38. 43. 49.] white [254. 255. 255.]
snow_board black [48. 49. 53.] white [255. 255. 255.]
C11-1_backlit black [48. 49. 53.] white [255. 255. 255.]
C1646_crowd black [30. 36. 35.] white [254. 255. 255.]

cd ~/work/pixelart-studies/books/oga && python3 src/measure.py plates/lv/*.png && python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np, glob
from measure import load320
from okl import rgb_to_oklab
for f in sorted(glob.glob('plates/lv/*.png')):
    L=rgb_to_oklab(load320(f))[...,0]; print(f'{f[10:]:24s}', np.quantile(L,[.02,.5,.98]).round(3))
EOF

# output:
image                           shadow%     Llit      Lsh      Csh     Clit   hue_sh  abSD_sh abSD_lit    grey% pureGrey    tints     midC   dens20
C0007_bg.png                     50.992    0.696    0.320    0.052    0.123    0.099    0.045    0.059   31.561   43.388        3    1.439   34.272
C0007_board.png                  49.174    0.802    0.330    0.053    0.133    0.063    0.039    0.062   27.936   43.016        3    1.346   36.379
C0064_bg.png                     54.572    0.751    0.375    0.060    0.115    0.034    0.034    0.065   24.572   15.200        3    1.316   31.491
C0081_greens.png                 37.489    0.756    0.351    0.052    0.126    0.043    0.039    0.058   25.165   29.417        3    1.549   34.977
C0772_sun.png                    38.628    0.821    0.409    0.037    0.069    0.365    0.039    0.058   48.882   14.888        4    3.088   47.118
C0792_boulders.png               82.110    0.638    0.254    0.020    0.032    0.251    0.022    0.039   86.058   40.541        4    0.998   33.968
C11-1_backlit.png                56.736    0.676    0.310    0.021    0.071    0.840    0.028    0.088   63.547   39.270        4    1.188   32.454
C1646_crowd.png                  66.128    0.638    0.336    0.029    0.042    0.243    0.024    0.042   72.639    5.293        3    1.167   30.607
C39-5_greys.png                  57.627    0.692    0.339    0.021    0.023    0.272    0.018    0.026   92.050   20.445        4    1.055   32.642
cover_final.png                  38.124    0.940    0.407    0.035    0.013    0.294    0.038    0.028   83.546   63.239        4    1.858   60.464
snow_board.png                   34.214    0.900    0.525    0.038    0.026    0.091    0.027    0.019   74.947   12.169        2    1.385   41.330
C0007_bg.png             [0.155 0.501 0.968]
C0007_board.png          [0.146 0.574 0.971]
C0064_bg.png             [0.179 0.524 0.954]
C0081_greens.png         [0.155 0.629 0.953]
C0772_sun.png            [0.258 0.715 0.958]
C0792_boulders.png       [0.119 0.272 0.856]
C11-1_backlit.png        [0.155 0.436 0.951]
C1646_crowd.png          [0.188 0.414 0.956]
C39-5_greys.png          [0.149 0.467 0.957]
cover_final.png          [0.209 0.824 0.998]
snow_board.png           [0.281 0.863 0.958]

cd ~/work/pixelart-studies/books/oga && cat > src/sheet.py <<'EOF'
"""Tiny sheet helpers: nearest-neighbour zoom, labelled rows."""
from PIL import Image, ImageDraw, ImageFont
import numpy as np
try:
    FONT = ImageFont.truetype('/System/Library/Fonts/Helvetica.ttc', 14)
    FONT_S = ImageFont.truetype('/System/Library/Fonts/Helvetica.ttc', 11)
except Exception:
    FONT = FONT_S = ImageFont.load_default()


def to_img(a):
    if isinstance(a, Image.Image):
        return a.convert('RGB')
    a = np.asarray(a)
    if a.dtype != np.uint8:
        a = (np.clip(a, 0, 1) * 255 + .5).astype(np.uint8)
    return Image.fromarray(a).convert('RGB')


def zoom(a, k):
    im = to_img(a)
    return im.resize((im.width * k, im.height * k), Image.NEAREST)


def fit(a, w=None, h=None, nearest=False):
    im = to_img(a)
    s = min((w or 1e9) / im.width, (h or 1e9) / im.height)
    return im.resize((max(1, round(im.width * s)), max(1, round(im.height * s))),
                     Image.NEAREST if nearest else Image.LANCZOS)


def grid(cells, cols, labels=None, pad=8, title=None, bg=(240, 238, 232)):
    """cells: list of PIL images (any sizes); returns a sheet with labels under each."""
    cw = max(c.width for c in cells); ch = max(c.height for c in cells)
    rows = (len(cells) + cols - 1) // cols
    th = 26 if title else 0; lh = 18 if labels else 0
    W = cols * (cw + pad) + pad; H = th + rows * (ch + lh + pad) + pad
    out = Image.new('RGB', (W, H), bg); d = ImageDraw.Draw(out)
    if title:
        d.text((pad, 5), title, fill=(20, 20, 20), font=FONT)
    for i, c in enumerate(cells):
        x = pad + (i % cols) * (cw + pad); y = th + pad + (i // cols) * (ch + lh + pad)
        out.paste(c, (x, y))
        if labels:
            d.text((x, y + c.height + 2), labels[i], fill=(30, 30, 30), font=FONT_S)
    return out


def area(a, w):
    im = to_img(a); h = max(1, round(im.height * w / im.width))
    return im.resize((w, h), Image.BOX)
EOF
python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
from sheet import *
from PIL import Image
cells=[];labs=[]
for n in ['C0064_bg','C0007_bg','C0792_boulders','cover_final']:
    im=Image.open(f'plates/lv/{n}.png')
    cells.append(fit(im,w=640)); labs.append(n+' (book, scan)')
    cells.append(zoom(area(im,160),4)); labs.append(n+' area-reduced to 160 px, 4x')
grid(cells,2,labs,title='What survives of Oga at our pixel scales').save('sheets/00_survives.png')
EOF
echo ok

# output:
ok

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
import re
s=open('src/sheet.py').read()
s=s.replace('''    cw = max(c.width for c in cells); ch = max(c.height for c in cells)
    rows = (len(cells) + cols - 1) // cols
    th = 26 if title else 0; lh = 18 if labels else 0
    W = cols * (cw + pad) + pad; H = th + rows * (ch + lh + pad) + pad
    out = Image.new('RGB', (W, H), bg); d = ImageDraw.Draw(out)
    if title:
        d.text((pad, 5), title, fill=(20, 20, 20), font=FONT)
    for i, c in enumerate(cells):
        x = pad + (i % cols) * (cw + pad); y = th + pad + (i // cols) * (ch + lh + pad)
        out.paste(c, (x, y))''','''    rows = (len(cells) + cols - 1) // cols
    colw = [max(c.width for c in cells[j::cols]) for j in range(cols)]
    rowh = [max(c.height for c in cells[r * cols:(r + 1) * cols]) for r in range(rows)]
    th = 26 if title else 0; lh = 18 if labels else 0
    W = sum(colw) + pad * (cols + 1); H = th + sum(rowh) + rows * (lh + pad) + pad
    out = Image.new('RGB', (W, H), bg); d = ImageDraw.Draw(out)
    if title:
        d.text((pad, 5), title, fill=(20, 20, 20), font=FONT)
    for i, c in enumerate(cells):
        r, j = divmod(i, cols)
        x = pad + sum(colw[:j]) + j * pad; y = th + pad + sum(rowh[:r]) + r * (lh + pad)
        out.paste(c, (x, y))''')
open('src/sheet.py','w').write(s)
EOF
echo ok

# output:
ok

cd ~/work/pixelart-studies/books/oga && sed -i '' "s/^ 'C1646_crowd'/ 'cover_step8':(11,0.05,0.085,0.95,0.46),\n 'C1646_crowd'/" work/plates.py && python3 work/plates.py >/dev/null && python3 -c "
from PIL import Image; im=Image.open('plates/lv/cover_step8.png'); print(im.size); im.thumbnail((700,400)); im.save('(manager scratchpad)/s8.jpg')"

# output:
(1113, 567)

cd ~/work/pixelart-studies/books/oga && sed -i '' "s/'cover_step8':(11,0.05,0.085,0.95,0.46)/'cover_step8':(11,0.05,0.56,0.95,0.94)/" work/plates.py && python3 work/plates.py >/dev/null && python3 -c "
from PIL import Image; im=Image.open('plates/lv/cover_step8.png'); print(im.size); im.thumbnail((700,400)); im.save('(manager scratchpad)/s8.jpg')"

# output:
(1113, 575)

"""地塗り (ground laying) in pixels.

Oga (p.46-47): ground laying is the most important process. It settles light direction, overall
colour and atmosphere, and he brings it "as close to finished as possible" at the lowest level of
detail. On wet paper the paints bleed (にじみ) and blur (ぼかし) into each other without mixing fully
(混ざり切らない), and the unevenness of the paint (塗りムラ) reads as light and texture.

Pixel translation:
  * a small set of paints (k colours, the "few colours freely" of p.41), chosen for the picture;
  * the picture laid at a coarse cell size (the width of a flat brush);
  * no averaging between paints: every pixel is one paint, and a soft coarse weight field is
    sampled with a clumped noise, so two paints interleave in patches (unevenness) and bleed
    across a boundary in ragged tongues (wet edges) instead of a straight cut or a smooth blend.
"""
import numpy as np
from scipy.ndimage import gaussian_filter, zoom as ndzoom
from okl import rgb_to_oklab, oklab_to_rgb


def clumped_noise(shape, scale=2.0, seed=0, octaves=((1.0, 1.0), (0.35, 0.5))):
    """uniform-ish [0,1) noise with patches ~scale px (gaussian-filtered white noise, rank-normalised)."""
    rng = np.random.default_rng(seed)
    n = np.zeros(shape)
    for amp, sm in octaves:
        n += amp * gaussian_filter(rng.standard_normal(shape), scale * sm)
    r = n.ravel().argsort().argsort().reshape(shape)
    return (r + 0.5) / r.size


def kmeans(X, k, iters=25, seed=0, w=None):
    rng = np.random.default_rng(seed)
    w = np.ones(len(X)) if w is None else w
    # k-means++ init
    c = [X[rng.choice(len(X), p=w / w.sum())]]
    for _ in range(k - 1):
        d = np.min(((X[:, None] - np.array(c)[None]) ** 2).sum(-1), 1) * w
        c.append(X[rng.choice(len(X), p=d / d.sum())])
    c = np.array(c)
    for _ in range(iters):
        lab = np.argmin(((X[:, None] - c[None]) ** 2).sum(-1), 1)
        for j in range(k):
            m = lab == j
            if m.any():
                c[j] = (X[m] * w[m, None]).sum(0) / w[m].sum()
    return c


def choose_paints(lab, k, seed=0, Lweight=1.6):
    """pick k paints from an OKLab image; L weighted up so value structure wins over hue noise."""
    X = lab.reshape(-1, 3).copy()
    sc = np.array([Lweight, 1, 1])
    c = kmeans(X * sc, k, seed=seed) / sc
    return c[np.argsort(c[:, 0])]                       # dark -> light


def paint_weights(lab, paints, sharp=40.0):
    """soft membership of each pixel in each paint (softmax of -distance)."""
    d = ((lab[..., None, :] - paints[None, None]) ** 2 * np.array([1.6, 1, 1])).sum(-1)
    w = np.exp(-sharp * (d - d.min(-1, keepdims=True)) / max(d.mean(), 1e-9))
    return w / w.sum(-1, keepdims=True)


def ground(rgb, W=320, cell=4, k=10, bleed=1.0, clump=1.6, seed=0, paints=None, sharp=6.0):
    """Lay the ground of an image.

    rgb   : float image 0..1 (any size), the subject (photo, plate, render, or a planned scene)
    W     : output width in pixels
    cell  : flat-brush width in px; the picture is decided at this resolution
    k     : number of paints
    bleed : how far (in cells) paints bleed into each other at boundaries
    clump : patch size of the interleaving noise, px (unevenness)
    sharp : how decisively a cell takes its main paint (low = more half-mixed interleave)
    returns (index image HxW, paints OKLab kx3)
    """
    from PIL import Image
    im = Image.fromarray((np.clip(rgb, 0, 1) * 255).astype(np.uint8))
    H = round(im.height * W / im.width)
    Hc, Wc = max(2, round(H / cell)), max(2, round(W / cell))
    coarse = np.asarray(im.resize((Wc, Hc), Image.BOX), np.float64) / 255
    lab_c = rgb_to_oklab(coarse)
    if paints is None:
        paints = choose_paints(lab_c, k, seed)
    wc = paint_weights(lab_c, paints, sharp)                       # Hc,Wc,k
    # bleed: soften the coarse weights by `bleed` cells, then upsample smoothly to full res
    if bleed > 0:
        wc = np.stack([gaussian_filter(wc[..., j], bleed * 0.6) for j in range(len(paints))], -1)
    wf = ndzoom(wc, (H / Hc, W / Wc, 1), order=1)[:H, :W]
    wf /= wf.sum(-1, keepdims=True)
    # sample: cumulative weights against one clumped noise -> one paint per pixel, patches not grain
    u = clumped_noise((H, W), clump, seed)
    cum = np.cumsum(wf, -1)
    idx = (u[..., None] > cum).sum(-1)
    return np.clip(idx, 0, len(paints) - 1), paints


def render(idx, paints):
    return oklab_to_rgb(paints[idx])

cd ~/work/pixelart-studies/books/oga && cat > work/ex1.py <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image
from ground import ground, render
from sheet import *
def load(p): return np.asarray(Image.open(p).convert('RGB'),float)/255
cells=[];labs=[]
for n,p in [('C-0064','plates/lv/C0064_bg.png'),('cover step 8','plates/lv/cover_step8.png'),('photo: Rainier valley','refs/pick/mount_rainier_4.jpg')]:
    a=load(p)
    cells.append(fit(a,w=640)); labs.append(n)
    for cell,k in [(4,10),(8,8)]:
        idx,P=ground(a,W=160,cell=cell,k=k,seed=1)
        cells.append(zoom(render(idx,P),4)); labs.append(f'ground: 160px, cell {cell}, {k} paints, 4x')
grid(cells,3,labs,title='Ex1a  ground stage in pixels').save('sheets/ex1a_ground.png')
EOF
python3 work/ex1.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/ground.py').read()
i=s.index('def ground(')
s=s[:i]+'''def split_paint(p, amount=0.03, warm=np.array([0.55, 0.83])):
    """the two paints a mass colour was 'not fully mixed' from: same L, pushed apart along a
    warm/cool axis in (a,b). Their average is the mass colour."""
    d = warm / np.linalg.norm(warm)
    return p + np.r_[0, d * amount], p - np.r_[0, d * amount]


def ground(rgb, W=320, cell=4, k=10, bleed=1.0, clump=1.6, seed=0, paints=None,
           gamma=4.0, mix=0.03, mix_clump=None, mix_share=0.5):
    """Lay the ground of an image.

    rgb    : float image 0..1 (any size): the subject (photo, plate, render, or a planned scene)
    W      : output width in pixels
    cell   : flat-brush width in px; the picture is decided at this resolution
    k      : number of paints (mass colours)
    bleed  : how far (in cells) paints bleed into each other at boundaries
    clump  : patch size of the boundary noise, px (ragged wet edges)
    gamma  : decisiveness of a mass; high = paints bleed only in a boundary band
    mix    : OKLab distance of the two half-mixed components of each paint (0 = flat paint)
    mix_clump : patch size of the unevenness inside a mass (default 1.5 cells)
    returns (index image HxW into palette, palette OKLab (2k)x3 ; index 2j,2j+1 = paint j's halves)
    """
    from PIL import Image
    im = Image.fromarray((np.clip(rgb, 0, 1) * 255).astype(np.uint8))
    H = round(im.height * W / im.width)
    Hc, Wc = max(2, round(H / cell)), max(2, round(W / cell))
    coarse = np.asarray(im.resize((Wc, Hc), Image.BOX), np.float64) / 255
    lab_c = rgb_to_oklab(coarse)
    if paints is None:
        paints = choose_paints(lab_c, k, seed)
    k = len(paints)
    d = ((lab_c[..., None, :] - paints[None, None]) ** 2 * np.array([1.6, 1, 1])).sum(-1)
    lab_hard = np.argmin(d, -1)
    wc = np.eye(k)[lab_hard]
    if bleed > 0:
        wc = np.stack([gaussian_filter(wc[..., j], bleed * 0.6) for j in range(k)], -1)
    wf = ndzoom(wc, (H / Hc, W / Wc, 1), order=1)[:H, :W]
    wf = np.clip(wf, 0, None) ** gamma
    wf /= wf.sum(-1, keepdims=True)
    u = clumped_noise((H, W), clump, seed)
    idx = np.clip((u[..., None] > np.cumsum(wf, -1)).sum(-1), 0, k - 1)
    pal = np.concatenate([np.stack(split_paint(p, mix)) for p in paints])
    u2 = clumped_noise((H, W), mix_clump or 1.5 * cell, seed + 7)
    half = (u2 < mix_share).astype(int)
    return 2 * idx + half, pal


def render(idx, pal):
    return oklab_to_rgb(pal[idx])
'''
open('src/ground.py','w').write(s)
EOF
sed -i '' 's/W=160,cell=cell,k=k,seed=1/W=320,cell=cell,k=k,seed=1/; s/zoom(render(idx,P),4)/zoom(render(idx,P),2)/; s/160px, cell/320px, cell/; s/paints, 4x/paints, 2x/' work/ex1.py && python3 work/ex1.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image,ImageDraw
im=Image.open('refs/pick/mount_rainier_4.jpg').convert('RGB'); print(im.size); im=im.resize((640,round(im.height*640/im.width)))
d=ImageDraw.Draw(im)
for k in range(1,10):
  d.line([(64*k,0),(64*k,im.height)],fill=(255,0,0)); d.line([(0,im.height*k/10),(640,im.height*k/10)],fill=(255,0,0))
im.save('(manager scratchpad)/rg.jpg')"

# output:
(1024, 771)

cd ~/work/pixelart-studies/books/oga && mkdir -p plans && cat > plans/rainier_valley.py <<'EOF'
# Hand plan (the "art setting") for refs/pick/mount_rainier_4.jpg. Polygons in fractions (x,y); drawn in order.
PHOTO = 'refs/pick/mount_rainier_4.jpg'
PLANES = [
 ('sky',        'sky',    None),
 ('cliff',      'rock',   [(0.12,0),(0.27,0),(0.36,0.14),(0.44,0.24),(0.52,0.34),(0.52,0.4),(0.4,0.35),(0.25,0.22),(0.15,0.15)]),
 ('far_forest', 'forest', [(0.12,0.1),(0.25,0.22),(0.4,0.35),(0.52,0.4),(0.52,0.52),(0.3,0.52),(0.2,0.5)]),
 ('meadow',     'grass',  [(0,0.82),(0.2,0.7),(0.28,0.55),(0.5,0.5),(0.62,0.46),(0.85,0.34),(1,0.3),(1,1),(0,1)]),
 ('conif_r',    'conifer',[(0.52,0.45),(0.53,0.25),(0.6,0.15),(0.7,0.1),(0.82,0.05),(0.9,0),(1,0),(1,0.32),(0.85,0.34),(0.7,0.42),(0.6,0.46)]),
 ('conif_l',    'conifer',[(0,0),(0.12,0),(0.15,0.2),(0.24,0.35),(0.3,0.5),(0.28,0.62),(0.2,0.7),(0,0.82)]),
 ('stream',     'water',  [(0,0.92),(0.12,0.8),(0.2,0.72),(0.3,0.64),(0.31,0.66),(0.22,0.76),(0.15,0.86),(0.05,0.96),(0,0.97)]),
 ('path',       'earth',  [(0.87,0.58),(0.855,0.6),(0.77,0.78),(0.74,1),(0.86,1),(0.84,0.8),(0.87,0.65)]),
]
EOF
cat > src/plan.py <<'EOF'
"""Scene plans: named planes (masks) with a material and a depth order.

A plan is what Oga's pencil art setting gives him: which masses exist, what they are, what is in
front. For voxsim it comes from the simulator (material id, depth, normals). For photo tests I draw
it by hand as polygons (plans/*.py)."""
import importlib.util
import numpy as np
from PIL import Image, ImageDraw


def load_plan(path):
    spec = importlib.util.spec_from_file_location('plan', path)
    m = importlib.util.module_from_spec(spec); spec.loader.exec_module(m)
    return m


def rasterize(planes, W, H):
    """-> plane id image (H,W) (index into planes; later polygons overwrite earlier)."""
    im = Image.new('L', (W * 4, H * 4), 0); d = ImageDraw.Draw(im)
    for i, (_, _, poly) in enumerate(planes):
        if poly is None:
            d.rectangle([0, 0, W * 4, H * 4], fill=i)
        else:
            d.polygon([(x * W * 4, y * H * 4) for x, y in poly], fill=i)
    return np.asarray(im.resize((W, H), Image.NEAREST))
EOF
echo ok

# output:
ok

cd ~/work/pixelart-studies/books/oga && cat >> src/ground.py <<'EOF'


def otsu1(x):
    h, e = np.histogram(x, 64); c = (e[:-1] + e[1:]) / 2
    w0 = np.cumsum(h); w1 = w0[-1] - w0
    m0 = np.cumsum(h * c) / np.maximum(w0, 1); m1 = (np.sum(h * c) - np.cumsum(h * c)) / np.maximum(w1, 1)
    return c[np.argmax(w0 * w1 * (m0 - m1) ** 2)]


def ground_from_plan(rgb, pid, cell=4, organise=1.2, rag=0.35, clump=1.4, mix=0.012, seed=0, nplanes=None):
    """Organised ground: each plane gets two paints, lit and shadow, and the lit/shadow shapes are
    decided at cell resolution and smoothed `organise` cells (the painter organising the crowd).

    rgb : subject image (colour source), any size
    pid : plane-id map at the OUTPUT size (H,W)
    rag : raggedness of the lit/shadow boundary (wet bleed), in units of the family field
    returns idx (H,W) into pal, pal OKLab, fam (H,W) 0 shadow / 1 lit
    """
    from PIL import Image
    H, W = pid.shape
    im = Image.fromarray((np.clip(rgb, 0, 1) * 255).astype(np.uint8))
    full = rgb_to_oklab(np.asarray(im.resize((W, H), Image.BOX), float) / 255)
    Hc, Wc = max(2, round(H / cell)), max(2, round(W / cell))
    Lc = rgb_to_oklab(np.asarray(im.resize((Wc, Hc), Image.BOX), float) / 255)[..., 0]
    Lc = gaussian_filter(Lc, organise)
    Lf = ndzoom(Lc, (H / Hc, W / Wc), order=1)[:H, :W]
    nplanes = nplanes or int(pid.max()) + 1
    u = clumped_noise((H, W), clump, seed) - 0.5
    fam = np.zeros((H, W), int); pal = []
    for p in range(nplanes):
        m = pid == p
        if not m.any():
            pal += [np.zeros(3)] * 4; continue
        t = otsu1(full[..., 0][m]) if m.sum() > 30 else full[..., 0][m].mean()
        spread = max(full[..., 0][m].std(), 0.02)
        f = (Lf - t) / spread + rag * 2 * u
        fam[m] = (f[m] > 0)
        for fv in (0, 1):
            mm = m & ((full[..., 0] > t) == bool(fv))
            c = full[mm].mean(0) if mm.sum() > 3 else full[m].mean(0)
            pal += list(split_paint(c, mix))
    pal = np.array(pal)
    half = (clumped_noise((H, W), 1.5 * cell, seed + 7) < 0.5).astype(int)
    idx = pid * 4 + fam * 2 + half
    return idx, pal, fam
EOF
cat > work/ex1b.py <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image
from ground import ground, ground_from_plan, render
from plan import load_plan, rasterize
from sheet import *
def load(p): return np.asarray(Image.open(p).convert('RGB'),float)/255
P=load_plan('plans/rainier_valley.py'); a=load(P.PHOTO)
W=320; H=round(a.shape[0]*W/a.shape[1])
pid=rasterize(P.PLANES,W,H)
rng=np.random.default_rng(3); cols=rng.uniform(.2,.9,(len(P.PLANES),3))
idx0,P0=ground(a,W=W,cell=4,k=10,seed=1,mix=0.012)
idx,pal,fam=ground_from_plan(a,pid,cell=4)
cells=[fit(a,w=640),zoom(cols[pid],2),zoom(render(idx0,P0),2),zoom(render(idx,pal),2)]
labs=['photo','my plan (art setting): 8 planes','ground by reduction (k-means, 10 paints)','ground from plan: 2 paints per plane, organised lit/shadow']
grid(cells,2,labs,title='Ex1b  a ground stage is a plan, not a reduction').save('sheets/ex1b_plan.png')
EOF
python3 work/ex1b.py

# output:
(Bash completed with no output)

"""A small procedural test world and a renderer to *fields* (not colours).

The Oga painter never sees colours from here, only what voxsim can give a painter:
  mat    material id per pixel      (SKY, FAR, ROCK, GRASS, FOREST, CONIFER, WATER, EARTH, SNOW)
  depth  metres from the eye
  nrm    world normal (x east, y up, z north)
  sun    direct light 0..1 (n.s times cast-shadow visibility)
  shadow cast-shadow mask (1 = in cast shadow)
  wx,wz  world position (for texture that sticks to the ground)
  crown  per-pixel crown id for trees (-1 if none), and crown-local normal

Views:
  landscape : eye ~1.7 m .. 40 m above ground, looking along +z, perspective (voxel-space columns)
  iso       : 30 degree parallel projection over a patch
The world: a valley meadow slope with a stream, forest and conifer stands, a lake, rock
outcrops, and far ridges as layered silhouettes (the book's far range, p.54)."""
import numpy as np
from scipy.ndimage import gaussian_filter, map_coordinates

SKY, FAR, ROCK, GRASS, FOREST, CONIFER, WATER, EARTH, SNOW = range(9)
MAT_NAMES = ['sky', 'far', 'rock', 'grass', 'forest', 'conifer', 'water', 'earth', 'snow']


def fbm(shape, seed, scales=(64, 32, 16, 8, 4), amps=(1, .5, .25, .12, .06)):
    rng = np.random.default_rng(seed)
    out = np.zeros(shape)
    for s, a in zip(scales, amps):
        out += a * gaussian_filter(rng.standard_normal(shape), s, mode='wrap') * s ** 0.5
    return out / np.abs(out).max()


class World:
    """heightfield on an N x N grid of `res` metres. z grows away from the default camera."""

    def __init__(self, N=1024, res=2.0, seed=0, kind='valley', snow=False, lake=False):
        self.N, self.res, self.seed, self.snow = N, res, seed, snow
        n = N
        z, x = np.mgrid[0:n, 0:n] * res
        self.X, self.Z = x, z
        cx = n * res / 2
        L = n * res
        # valley: floor rising gently away, walls rising left and right
        u = (x - cx) / (L / 2)
        base = 0.035 * z + 260 * np.abs(u) ** 1.6 + 30 * u
        base += 40 * fbm((n, n), seed, (96, 48, 24), (1, .5, .25))
        base += 6 * fbm((n, n), seed + 1, (12, 6, 3), (1, .5, .3))
        # a meadow bench on the right of the camera: flatten a band
        bench = np.exp(-((u - 0.18) / 0.16) ** 2) * np.exp(-((z - 700) / 500) ** 2)
        base = base * (1 - 0.5 * bench) + bench * (0.035 * z + 30) * 0.5
        # stream along the valley floor
        sx = cx - 60 + 70 * np.sin(z / 260 + seed)
        dstream = np.abs(x - sx)
        base -= 3.0 * np.exp(-(dstream / 6) ** 2)
        self.stream = dstream < 3.5
        if lake:
            lk = ((x - cx + 40) / 180) ** 2 + ((z - 1100) / 260) ** 2 < 1
            self.lake_level = np.percentile(base[lk], 40)
            base = np.where(lk, np.minimum(base, self.lake_level - 0.5), base)
            self.lake = lk & (base < self.lake_level)
        else:
            self.lake = np.zeros_like(self.stream)
        self.ground = base
        # slope
        gz, gx = np.gradient(base, res)
        self.slope = np.hypot(gx, gz)
        # vegetation: forest density field; forest on walls, meadow on bench/floor; rock on steep
        dens = fbm((n, n), seed + 2, (40, 20, 10), (1, .6, .3))
        forest = (dens + 0.9 * np.clip(np.abs(u) - 0.12, 0, 1) * 3 - 0.35 * bench) > 0.25
        forest &= self.slope < 1.1
        forest &= ~self.stream & ~self.lake
        # keep a clearing right in front of the camera
        forest &= ~((np.abs(x - cx - 10) < 90) & (z < 260))
        self.forest = forest
        self.rock = (self.slope > 0.95) & ~forest
        # canopy: crowns as bumps. conifers where colder/higher or on one side
        rng = np.random.default_rng(seed + 3)
        conif_pref = fbm((n, n), seed + 4, (80, 40), (1, .5)) + 0.004 * (base - base.mean())
        self.conifer_zone = conif_pref > 0.0
        canopy = np.zeros((n, n)); crown_id = -np.ones((n, n), int)
        # scatter trees
        k = int(forest.sum() / (5.5 / res) ** 2 * 0.9)
        ys, xs = np.nonzero(forest)
        pick = rng.choice(len(ys), size=min(k, len(ys)), replace=False)
        self.trees = []
        for t, i in enumerate(pick):
            ty, tx = ys[i], xs[i]
            con = self.conifer_zone[ty, tx]
            h = rng.uniform(18, 42) if con else rng.uniform(12, 24)
            r = (h * rng.uniform(0.16, 0.22)) if con else (h * rng.uniform(0.3, 0.42))
            self.trees.append((tx * res, ty * res, base[ty, tx], h, r, con))
        self._paint_canopy(canopy, crown_id)
        self.canopy = canopy
        self.crown_id = crown_id
        self.top = base + canopy

    def _paint_canopy(self, canopy, crown_id):
        res = self.res; n = self.N
        for t, (x0, z0, g, h, r, con) in enumerate(self.trees):
            R = int(np.ceil(r / res)) + 1
            ix, iz = int(x0 / res), int(z0 / res)
            a, b = max(0, iz - R), min(n, iz + R + 1)
            c, d = max(0, ix - R), min(n, ix + R + 1)
            if a >= b or c >= d:
                continue
            zz, xx = np.mgrid[a:b, c:d] * res
            dd = np.hypot(xx - x0, zz - z0) / r
            if con:   # cone crown
                hh = h * np.clip(1 - dd, 0, 1) ** 1.0 + 0.25 * h * (dd < 1)
            else:     # dome crown
                hh = (0.55 * h + 0.45 * h * np.sqrt(np.clip(1 - dd ** 2, 0, 1))) * (dd < 1)
            sub = canopy[a:b, c:d]
            m = hh > sub
            sub[m] = hh[m]
            crown_id[a:b, c:d][m] = t

    def sample(self, arr, x, z, order=1):
        return map_coordinates(arr, [z / self.res, x / self.res], order=order, mode='nearest')

    def sun_shadow(self, sun, steps=160, step=4.0):
        """cast-shadow visibility on the grid for a sun direction (unit, y up). 1 lit, 0 shadow."""
        n = self.N
        top = self.top
        vis = np.ones((n, n))
        horiz = np.hypot(sun[0], sun[2]) + 1e-9
        dx, dz = sun[0] / horiz, sun[2] / horiz
        rise = sun[1] / horiz
        for k in range(1, steps + 1):
            d = k * step
            h = self.sample(top, self.X + dx * d, self.Z + dz * d)
            vis = np.minimum(vis, np.clip(1 - (h - (top + 0.5 + rise * d)) / 2.0, 0, 1))
        return vis


def normals_from(h, res):
    gz, gx = np.gradient(h, res)
    n = np.stack([-gx, np.ones_like(h), -gz], -1)
    return n / np.linalg.norm(n, axis=-1, keepdims=True)


def render_landscape(w, W=320, H=180, eye=(None, 30.0, 40.0), yaw=0.0, pitch=-4.0, fov=58.0,
                     sun=(0.6, 0.55, -0.55), far_ridges=True, zmax=None, seed=0):
    """voxel-space column renderer. eye = (x, height above ground, z)."""
    sun = np.asarray(sun, float); sun /= np.linalg.norm(sun)
    ex = w.N * w.res / 2 if eye[0] is None else eye[0]
    ez = eye[2]
    eg = w.sample(w.ground, np.array([ex]), np.array([ez]))[0]
    ey = eg + eye[1]
    f = (W / 2) / np.tan(np.radians(fov / 2))
    horizon = H / 2 + f * np.tan(np.radians(pitch))
    yawr = np.radians(yaw)
    zmax = zmax or w.N * w.res * 0.97
    vis = w.sun_shadow(sun)
    nt = normals_from(w.top, w.res)
    ng = normals_from(w.ground, w.res)
    out = {k: np.zeros((H, W)) for k in ('depth', 'sun', 'shadow', 'wx', 'wz', 'crown')}
    out['mat'] = np.full((H, W), SKY, int)
    out['nrm'] = np.zeros((H, W, 3)); out['nrm'][..., 1] = 1
    out['depth'][:] = np.inf
    out['crown'][:] = -1
    xs = np.arange(W)
    ang = yawr + np.arctan((xs - W / 2) / f)
    cosc = np.cos(np.arctan((xs - W / 2) / f))
    ybuf = np.full(W, H, float)
    d = 1.0
    ds = np.concatenate([np.arange(1, 60, 0.25), np.geomspace(60, zmax, 1400)])
    for d in ds:
        px = ex + np.sin(ang) * d / cosc * cosc   # along-ray world pos
        pz = ez + np.cos(ang) * d
        inside = (px > 0) & (px < w.N * w.res - 1) & (pz > 0) & (pz < w.N * w.res - 1)
        if not inside.any():
            continue
        top = w.sample(w.top, px, pz)
        lake = w.sample(w.lake.astype(float), px, pz) > 0.5
        if w.lake.any():
            top = np.where(lake, np.maximum(top, w.lake_level), top)
        dist = d  # perpendicular distance for projection
        sy = horizon - (top - ey) / dist * f
        sy = np.clip(sy, -1, H)
        draw = inside & (sy < ybuf)
        if not draw.any():
            continue
        for c in np.nonzero(draw)[0]:
            y0, y1 = int(np.ceil(max(sy[c], 0))), int(np.ceil(ybuf[c]))
            if y1 <= y0:
                continue
            out['depth'][y0:y1, c] = d / cosc[c]
            out['wx'][y0:y1, c] = px[c]; out['wz'][y0:y1, c] = pz[c]
        ybuf = np.where(draw, np.maximum(sy, 0), ybuf)
    # fill per-pixel attributes from world position
    m = np.isfinite(out['depth'])
    wx, wz = out['wx'][m], out['wz'][m]
    ix = np.clip((wx / w.res).astype(int), 0, w.N - 1); iz = np.clip((wz / w.res).astype(int), 0, w.N - 1)
    canopy = w.canopy[iz, ix] > 1.0
    mat = np.full(m.sum(), GRASS)
    mat[w.rock[iz, ix]] = ROCK
    mat[canopy & w.conifer_zone[iz, ix]] = CONIFER
    mat[canopy & ~w.conifer_zone[iz, ix]] = FOREST
    mat[w.stream[iz, ix] & ~canopy] = WATER
    mat[w.lake[iz, ix]] = WATER
    if w.snow:
        mat[(mat == GRASS) | (mat == ROCK)] = SNOW
    nn = np.where(canopy[:, None], nt[iz, ix], ng[iz, ix])
    nn[mat == WATER] = [0, 1, 0]
    out['mat'][m] = mat
    out['nrm'][m] = nn
    v = vis[iz, ix]
    out['shadow'][m] = 1 - v
    out['sun'][m] = np.clip(nn @ sun, 0, 1) * v
    out['crown'][m] = np.where(canopy, w.crown_id[iz, ix], -1)
    out['depth'][~m] = 1e6
    if far_ridges:
        _far_ridges(out, W, H, horizon, f, ey, seed)
    out['sun_dir'] = sun
    out['horizon'] = horizon
    return out


def _far_ridges(out, W, H, horizon, f, ey, seed):
    """layered silhouettes beyond the world: the far range (p.54). Each layer: a 1-D ridge profile."""
    rng = np.random.default_rng(seed + 11)
    xs = np.arange(W)
    for dist, amp, base in [(22000, 1500, 400), (11000, 900, 300), (6000, 500, 250)]:
        prof = np.zeros(W)
        for s, a in [(W / 1.5, 1), (W / 4, .45), (W / 10, .2), (W / 30, .08)]:
            ph = rng.uniform(0, 2 * np.pi, 3)
            prof += a * (np.sin(xs / s * 2 + ph[0]) + 0.5 * np.sin(xs / s * 3.7 + ph[1]))
        prof = base + amp * (0.5 + 0.35 * prof)
        sy = horizon - (prof - ey) / dist * f
        for c in range(W):
            y0 = int(np.ceil(max(sy[c], 0)))
            col = out['mat'][:, c] == SKY
            rows = np.arange(H)
            sel = col & (rows >= y0)
            out['mat'][sel, c] = FAR
            out['depth'][sel, c] = dist
            # ridge normal: facing the viewer, tilted by profile slope
            g = np.gradient(prof)[c] * dist / f / 400
            nrm = np.array([-g, 0.5, -1.0]); nrm /= np.linalg.norm(nrm)
            out['nrm'][sel, c] = nrm
            out['sun'][sel, c] = 0.0

cd ~/work/pixelart-studies/books/oga && sed -i '' "s/            out\['sun'\]\[sel, c\] = 0.0/            out['sun'][sel, c] = 0.0  # set by the painter from nrm/" src/scene.py && cat > work/scene_test.py <<'EOF'
import sys,time; sys.path.insert(0,'src')
import numpy as np
from scene import *
from sheet import *
t=time.time(); w=World(N=1024,res=2.0,seed=5,lake=True); print('world',time.time()-t)
t=time.time(); F=render_landscape(w,eye=(None,25,60),sun=(0.8,0.5,0.35),pitch=-6); print('render',time.time()-t)
cols=np.array([[.6,.8,1],[.6,.6,.8],[.5,.45,.4],[.5,.8,.3],[.2,.5,.2],[.1,.35,.25],[.2,.3,.7],[.6,.4,.2],[.95,.95,1]])
mat=cols[F['mat']]
shade=(0.35+0.65*F['sun'])[...,None]*mat
dep=np.log(F['depth'].clip(1,3e4))/np.log(3e4)
grid([zoom(mat,2),zoom(shade,2),zoom(np.dstack([dep]*3),2),zoom(np.dstack([1-F['shadow']]*3),2)],2,['mat','sun-shaded','depth','cast shadow'],title='test world').save('(manager scratchpad)/scene.png')
np.savez_compressed('work/F_valley.npz',**{k:v for k,v in F.items()})
EOF
nice -n 10 python3 work/scene_test.py

# output:
world 34.61696219444275
render 45.8405020236969

cd ~/work/pixelart-studies/books/oga && cat > work/swatch.py <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image, ImageDraw
from okl import *
from ground import kmeans
from sheet import FONT_S
rows=[]
for n in ['C0064_bg','C0007_bg','C0081_greens','C0772_sun','C0792_boulders','snow_board','C39-5_greys','cover_final','C11-1_backlit']:
    a=np.asarray(Image.open(f'plates/lv/{n}.png').convert('RGB').resize((160,90),Image.BOX),float)/255
    lab=rgb_to_oklab(a).reshape(-1,3)
    c=kmeans(lab*[1.5,1,1],14,seed=0)/[1.5,1,1]; c=c[np.argsort(c[:,0])]
    lab2=np.argmin(((lab[:,None]-c[None])**2).sum(-1),1); share=np.bincount(lab2,minlength=14)/len(lab2)
    rows.append((n,c,share))
im=Image.new('RGB',(14*70+130,len(rows)*56),'white'); d=ImageDraw.Draw(im)
for r,(n,c,sh) in enumerate(rows):
    d.text((2,r*56+20),n,fill='black',font=FONT_S)
    for j,cc in enumerate(c):
        rgb=tuple(u8(oklab_to_rgb(cc)))
        d.rectangle([130+j*70,r*56,130+j*70+66,r*56+36],fill=rgb)
        L,C,h=lab_to_lch(cc[None])[0]
        d.text((130+j*70,r*56+37),f'{L:.2f} {C:.2f} {np.degrees(h)%360:.0f}',fill='black',font=FONT_S)
        d.text((130+j*70,r*56+46),f'{100*sh[j]:.0f}%',fill='gray',font=FONT_S)
im.save('sheets/00_plate_swatches.png')
EOF
python3 work/swatch.py

# output:
(Bash completed with no output)

"""Oga's colour, as measured on his plates (sheets/00_plate_swatches.png) and as he describes it.

Ramps are paths in OKLCh. The measured facts they encode:

  greens (C-0081, C-0064, C-0007, p.44): hue walks from blue-green in the dark (h~150) to yellow in
      the light (h~108); chroma *rises* with lightness all the way to the top (C .02 at L .23,
      .17 at L .89). The lights are chrome-green/lemon, never whitened green. That is
      "unmuddied mixing": the mid-tones keep their chroma and the highlight is a vivid colour,
      not a value step toward white (p.10, step 10: "don't rely on value difference alone").
  shadows of stone (C-0792, p.56): a separate family, hue 250-266 (cool reflected sky), C .01-.03.
  greys (C39-5, p.103): tinted, two alternating tints (red-grey h~10, purple-grey h~320) plus an
      ochre accent; almost no neutral.
  snow (p.96): lit snow white; shadows lavender-blue h~285, C .03-.05.
"""
import numpy as np
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab, lab_to_lch

D = np.pi / 180


def lch(L, C, hdeg):
    return lch_to_lab(np.array([L, C, hdeg * D], float))


def hue_lerp(h0, h1, t):
    d = (h1 - h0 + 180) % 360 - 180
    return h0 + d * t


def ramp_path(L0, L1, n, hue, chroma):
    """n colours from L0 to L1; hue(L) and chroma(L) are callables -> OKLab (n,3)."""
    Ls = np.linspace(L0, L1, n)
    return np.stack([lch(L, chroma(L), hue(L)) for L in Ls])


# ---- fitted to C-0081 (p.44): h = 160 - 58 L, C = 0.26 (L - 0.17), capped ------------------------
def oga_green(L0=0.26, L1=0.88, n=7, warm=0.0):
    return ramp_path(L0, L1, n, lambda L: 160 - 58 * L - 20 * warm,
                     lambda L: float(np.clip(0.26 * (L - 0.17), 0.012, 0.175)))


def mud_green(L0=0.26, L1=0.88, n=7):
    """the failure the book names: a mid green lightened with white, darkened with black."""
    mid = lch(0.55, 0.11, 125)
    out = []
    for L in np.linspace(L0, L1, n):
        t = (L - 0.55) / (1 - 0.55) if L > 0.55 else (0.55 - L) / 0.55
        tgt = lch(1.0, 0, 0) if L > 0.55 else lch(0.0, 0, 0)
        # mix in linear light, as paint (roughly) does
        a = rgb_to_lin_mix(mid, tgt, t)
        out.append(a)
    return np.stack(out)


def rgb_to_lin_mix(a, b, t):
    from okl import srgb_to_lin, lin_to_srgb
    ra, rb = srgb_to_lin(oklab_to_rgb(a)), srgb_to_lin(oklab_to_rgb(b))
    return rgb_to_oklab(lin_to_srgb(ra * (1 - t) + rb * t))


def linear_green(L0=0.26, L1=0.88, n=7):
    """a straight OKLab line between the same end colours as oga_green."""
    a, b = oga_green(L0, L1, 2)
    return np.stack([a * (1 - t) + b * t for t in np.linspace(0, 1, n)])


# ---- material palettes: lit family and shadow family, each a short ramp --------------------------
# Every family is written as (L, C, h) triplets, dark -> light. Values come from the plate swatches.
MATERIALS = {
    # meadow grass (C-0064/C-0007): lit yellow-greens, shadow deep blue-greens + a warm brown grey
    'grass':   dict(lit=[(0.62, 0.13, 122), (0.70, 0.145, 118), (0.79, 0.16, 112), (0.87, 0.165, 106)],
                    shadow=[(0.30, 0.035, 140), (0.37, 0.05, 136), (0.44, 0.07, 132), (0.50, 0.075, 128)],
                    warm=(0.42, 0.05, 80)),
    # broadleaf forest crowns (C-0064 trees)
    'forest':  dict(lit=[(0.55, 0.11, 125), (0.63, 0.13, 120), (0.72, 0.15, 114), (0.81, 0.16, 108)],
                    shadow=[(0.22, 0.02, 150), (0.28, 0.035, 145), (0.35, 0.05, 140), (0.42, 0.06, 135)],
                    warm=(0.36, 0.045, 70)),
    # conifers: darker, bluer, lower chroma (Oga's cedar "could be blacker", p.57)
    'conifer': dict(lit=[(0.44, 0.07, 140), (0.52, 0.09, 132), (0.60, 0.11, 126), (0.68, 0.12, 120)],
                    shadow=[(0.18, 0.015, 175), (0.23, 0.025, 165), (0.28, 0.035, 155), (0.34, 0.04, 148)],
                    warm=(0.30, 0.035, 60)),
    # rock (C-0792 / cover): lit warm grey, shadow cool blue-grey family
    'rock':    dict(lit=[(0.62, 0.02, 80), (0.70, 0.025, 75), (0.78, 0.028, 70), (0.86, 0.025, 70)],
                    shadow=[(0.24, 0.015, 255), (0.31, 0.02, 252), (0.38, 0.025, 250), (0.45, 0.03, 250)],
                    warm=(0.40, 0.03, 40)),
    'earth':   dict(lit=[(0.62, 0.06, 70), (0.70, 0.07, 72), (0.77, 0.075, 75), (0.84, 0.07, 80)],
                    shadow=[(0.33, 0.03, 50), (0.40, 0.035, 55), (0.46, 0.04, 60), (0.52, 0.04, 65)],
                    warm=(0.45, 0.05, 45)),
    'snow':    dict(lit=[(0.90, 0.012, 90), (0.93, 0.01, 95), (0.96, 0.006, 100), (0.985, 0.004, 100)],
                    # form shading of the snow (blue-grey) -- p.96
                    shadow=[(0.62, 0.035, 280), (0.68, 0.035, 283), (0.74, 0.032, 285), (0.80, 0.028, 285)],
                    # shadows cast ON the snow surface: celeste family
                    cast=[(0.64, 0.05, 250), (0.70, 0.05, 248), (0.76, 0.045, 245), (0.82, 0.04, 242)],
                    warm=(0.78, 0.02, 60)),
    'water':   dict(lit=[(0.62, 0.06, 225), (0.70, 0.06, 228), (0.78, 0.05, 230), (0.86, 0.04, 232)],
                    shadow=[(0.28, 0.04, 200), (0.34, 0.045, 205), (0.40, 0.05, 210), (0.46, 0.05, 215)],
                    warm=(0.40, 0.04, 150)),
}


def fam(m, key):
    return np.stack([lch(*t) for t in MATERIALS[m][key]])


def sky_ramp(hour='day'):
    """zenith -> horizon, near-isovalue walk (C-0772: celeste sky, pale at the horizon)."""
    if hour == 'day':
        return np.stack([lch(0.70, 0.11, 252), lch(0.75, 0.09, 250), lch(0.80, 0.07, 248),
                         lch(0.85, 0.05, 245), lch(0.90, 0.03, 240), lch(0.94, 0.02, 230)])
    raise ValueError(hour)

"""The Oga method as a painter over fields.  (MODEL.md sections in brackets.)

paint(F, **params) -> dict(rgb=HxWx3, slot=HxW int, fam=HxW (0 shadow,1 lit), ...)

Passes, in the order Oga works (the cover, p.4-11):
  1  light plan [7]: one sun; light CONCENTRATED on the points (pool), most of the picture in shadow;
     contrast softened with distance [9, C-0007].
  2  ground [2]: the step field decided at cell resolution (the flat brush), per material, then
     laid with ragged wet edges (clumped-noise dithering between adjacent steps only).
  3  shadow colour [7,10]: shadow is its own family (cool reflected light on up-facing planes, the
     object's warm colour in patches, core darkest just past the terminator).
  4  air [11]: far things approach the sky colour; black point lifts with distance.
  5  edge of light [7, 際]: the light's colour where light meets the shadow edge.
  6  crowd / marks [3,5]: in the point areas only, lit leaf dabs on the sun side of crowns
     and tufts on near grass; "painting the unpainted" (C-0822).
"""
import numpy as np
from scipy.ndimage import gaussian_filter, binary_dilation, uniform_filter
from okl import oklab_to_rgb
from palette import MATERIALS, fam, sky_ramp, lch
from ground import clumped_noise
import scene as S

MATKEY = {S.GRASS: 'grass', S.FOREST: 'forest', S.CONIFER: 'conifer', S.ROCK: 'rock',
          S.EARTH: 'earth', S.SNOW: 'snow', S.WATER: 'water', S.FAR: 'conifer'}

DEFAULTS = dict(
    points=[(0.62, 0.55, 0.22)],   # light pools: (x frac, y frac, radius frac)
    conc=0.6,                       # 0 = light everywhere the sun reaches; 1 = only in the pools
    terminator=0.30,                # sun value below which a surface is in the shadow family
    cell=3.0,                       # flat-brush width in px (organising size, near)
    rag=0.5,                        # raggedness of step boundaries (0 = clean bands)
    clump=1.3,                      # patch size of the ragged noise, px
    refl=0.8,                       # reflected light strength in shadow (sky-facing)
    warm_share=0.28,                # share of shadow area that takes the object's warm colour
    air=2600.0,                     # metres for aerial perspective to reach 63%
    air_max=0.85,
    edge=True,                      # light's colour at the edge of the light (際)
    edge_chroma=0.035,
    marks=True,
    seed=0,
    flat=False,                     # debug: plain lambert, no Oga (the 'before')
)


def organise(x, mask, sigma):
    """normalized gaussian blur of x inside mask (the painter organising a crowd into a shape)."""
    if sigma <= 0:
        return x
    w = gaussian_filter(mask.astype(float), sigma)
    v = gaussian_filter(np.where(mask, x, 0.0), sigma)
    return np.where(mask, v / np.maximum(w, 1e-6), x)


def pools(H, W, pts):
    yy, xx = np.mgrid[0:H, 0:W]
    p = np.zeros((H, W))
    for (px, py, r) in pts:
        p = np.maximum(p, np.exp(-(((xx - px * W) ** 2 + (yy - py * H) ** 2) / (r * W) ** 2)))
    return p


def paint(F, **kw):
    P = dict(DEFAULTS); P.update(kw)
    mat, depth, nrm = F['mat'], F['depth'], F['nrm']
    H, W = mat.shape
    sun = np.asarray(F['sun_dir'])
    s = F['sun'].copy()
    far = mat == S.FAR
    s[far] = np.clip(nrm[far] @ sun, 0, 1) * 0.8
    rng_seed = P['seed']

    # ---------- 1 light plan -------------------------------------------------------------------
    pool = pools(H, W, P['points'])
    s_eff = s * (1 - P['conc'] * (1 - pool)) if not P['flat'] else s
    # contrast softens with distance: lit and shadow converge toward the middle
    dfac = np.exp(-depth / (P['air'] * 1.2))
    s_eff = 0.5 + (s_eff - 0.5) * (0.35 + 0.65 * dfac) if not P['flat'] else s_eff

    # ---------- 2 ground: organise per material at cell size, scaled with depth -----------------
    x = np.zeros((H, W))
    if not P['flat']:
        for m in np.unique(mat):
            if m == S.SKY:
                continue
            mm = mat == m
            x = np.where(mm, organise(s_eff, mm, P['cell'] * 0.6), x)
    else:
        x = s_eff
    lit = x > P['terminator']

    # step coordinate in each family (0..3.999)
    t = P['terminator']
    lit_step = np.clip((x - t) / (1 - t) * 1.25, 0, 1) * 3.999
    ny = nrm[..., 1]
    back = np.clip(-(nrm @ sun), 0, 1)
    refl = np.clip(ny, 0, 1) * P['refl'] * (1 - 0.6 * back)
    core = np.clip(1 - np.abs(x - t * 0.6) / (t * 0.6 + 1e-6), 0, 1)   # darkest just past the terminator
    sh_step = np.clip(1.2 + 2.6 * refl - 1.4 * core, 0, 3.999)
    if P['flat']:
        sh_step = np.clip(x / t * 3.999, 0, 3.999)
    if not P['flat']:
        for m in np.unique(mat):
            if m == S.SKY:
                continue
            mm = mat == m
            sh_step = np.where(mm, organise(sh_step, mm, P['cell'] * 0.5), sh_step)
    step = np.where(lit, lit_step, sh_step)
    # ragged wet edges: dither between adjacent steps with clumped noise
    u = clumped_noise((H, W), P['clump'], rng_seed) - 0.5
    stepi = np.clip(np.floor(step + 0.5 + P['rag'] * u), 0, 3).astype(int)
    if P['flat']:
        stepi = np.clip(np.floor(step + 0.5), 0, 3).astype(int)

    # ---------- 3 colour: families, warm patches in shadow, snow cast family ------------------
    lab = np.zeros((H, W, 3))
    warmmask = clumped_noise((H, W), 4.0, rng_seed + 5) < P['warm_share']
    cast = F['shadow'] > 0.5
    for m in np.unique(mat):
        mm = mat == m
        if m == S.SKY:
            continue
        key = MATKEY[m]
        L_ = fam(key, 'lit'); Sh = fam(key, 'shadow')
        c = np.where(lit[..., None], L_[stepi], Sh[stepi])
        if not P['flat']:
            wc = lch(*MATERIALS[key]['warm'])
            wsel = mm & ~lit & warmmask & (stepi <= 2)
            c[wsel] = 0.5 * c[wsel] + 0.5 * (wc + (Sh[stepi[wsel]] - Sh[1]) * 0.6)
            if key == 'snow':
                Cc = fam('snow', 'cast')
                csel = mm & ~lit & cast
                c[csel] = Cc[stepi[csel]]
        lab[mm] = c[mm]
    # sky
    sky = mat == S.SKY
    sr = sky_ramp()
    hz = F.get('horizon', H * 0.4)
    yy = np.mgrid[0:H, 0:W][0]
    sv = np.clip(yy / max(hz, 1), 0, 1) * (len(sr) - 1)
    svi = np.clip(np.floor(sv + 0.5 + 0.6 * u), 0, len(sr) - 1).astype(int)
    lab[sky] = sr[svi[sky]]

    # ---------- 4 air: far approaches the horizon sky colour ------------------------------------
    horizon_col = sr[-2]
    a = P['air_max'] * (1 - np.exp(-np.where(sky, 0, depth) / P['air']))
    if P['flat']:
        a = a * 0.5
    lab = lab * (1 - a[..., None]) + horizon_col * a[..., None]

    # ---------- 5 edge of light: 際 -------------------------------------------------------------
    if P['edge'] and not P['flat']:
        shad = ~lit & ~sky
        near_sh = binary_dilation(shad, iterations=1) & lit & ~sky
        e = near_sh & (depth < P['air'] * 1.5)
        L, A, B = lab[..., 0], lab[..., 1], lab[..., 2]
        C = np.hypot(A, B) + 1e-9
        hh = np.arctan2(B, A)
        target = 95 * np.pi / 180        # light's colour: warm yellow
        dh = (target - hh + np.pi) % (2 * np.pi) - np.pi
        hh2 = hh + 0.35 * dh
        C2 = C + P['edge_chroma']
        lab[e, 1] = (C2 * np.cos(hh2))[e]; lab[e, 2] = (C2 * np.sin(hh2))[e]

    return dict(rgb=oklab_to_rgb(lab), lab=lab, lit=lit, step=stepi, pool=pool, s_eff=s_eff)

cd ~/work/pixelart-studies/books/oga && cat > work/paint_test.py <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from oga import paint
from sheet import *
F=dict(np.load('work/F_valley.npz'))
a=paint(F,flat=True); b=paint(F)
grid([zoom(a['rgb'],2),zoom(b['rgb'],2),zoom(np.dstack([b['pool']]*3),2),zoom(np.dstack([b['lit']*1.0]*3),2)],2,
     ['before: lambert, same palette','Oga passes v0','light pool','lit family']).save('(manager scratchpad)/p0.png')
EOF
python3 work/paint_test.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/oga.py').read()
s=s.replace("""    points=[(0.62, 0.55, 0.22)],   # light pools: (x frac, y frac, radius frac)
    conc=0.6,                       # 0 = light everywhere the sun reaches; 1 = only in the pools""",
"""    points=[],                      # world points (x, z, radius m) that must stay in light
    cover=0.45,                     # cloud-shadow cover: share of the ground put in shadow by clouds
    cloud_scale=260.0,              # metres, size of cloud shadows
    cloud_soft=0.08,                # softness of cloud-shadow edges (in noise units)""")
s=s.replace("""    pool = pools(H, W, P['points'])
    s_eff = s * (1 - P['conc'] * (1 - pool)) if not P['flat'] else s""",
"""    # light is concentrated by what the world puts between the sun and the ground (clouds,
    # ridges, trees), never by a screen-space spotlight. cloud shadows live in world space.
    pool = cloud_light(F, P) if not P['flat'] else np.ones((H, W))
    s_eff = s * pool""")
s=s.replace("""def paint(F, **kw):""","""def cloud_light(F, P):
    wx, wz, mat = F['wx'], F['wz'], F['mat']
    rng = np.random.default_rng(P['seed'] + 101)
    ph = rng.uniform(0, 1000, 8)
    sc = P['cloud_scale']
    n = np.zeros_like(wx)
    for k, (f, a) in enumerate([(1, 1), (2.1, .5), (4.3, .25)]):
        n += a * np.sin(wx / sc * f + ph[k]) * np.cos(wz / sc * f * 0.8 + ph[k + 3]) \\
            + a * 0.5 * np.sin((wx + wz) / sc * f * 0.7 + ph[k + 5])
    for (px, pz, r) in P['points']:
        n += 3.0 * np.exp(-((wx - px) ** 2 + (wz - pz) ** 2) / r ** 2)
    ground = (mat != S.SKY) & (mat != S.FAR)
    thr = np.quantile(n[ground], P['cover']) if ground.any() else 0
    lightv = np.clip((n - thr) / (P['cloud_soft'] * n[ground].std() + 1e-9) + 0.5, 0, 1)
    lightv[~ground] = 1.0
    return lightv


def paint(F, **kw):""")
s=s.replace("warm_share=0.28,","warm_share=0.15,")
s=s.replace("""            c[wsel] = 0.5 * c[wsel] + 0.5 * (wc + (Sh[stepi[wsel]] - Sh[1]) * 0.6)""","""            c[wsel] = 0.65 * c[wsel] + 0.35 * (wc + (Sh[stepi[wsel]] - Sh[1]) * 0.6)""")
s=s.replace("""        shad = ~lit & ~sky
        near_sh = binary_dilation(shad, iterations=1) & lit & ~sky""","""        # only where the FORM turns away (terminator) or a silhouette meets shadow, not at cloud edges
        formshadow = (~sky) & (s < t)
        near_sh = binary_dilation(formshadow, iterations=1) & lit & ~sky""")
s=s.replace("edge_chroma=0.035","edge_chroma=0.025")
open('src/oga.py','w').write(s)
EOF
sed -i '' "s/b=paint(F)/b=paint(F,points=[(1150,700,120)])/" work/paint_test.py && python3 work/paint_test.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && cat > work/ex2.py <<'EOF'
"""Ex2 unmuddied mixing (C-0081, p.44): same end colours, three ways to fill the middle."""
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image, ImageDraw
from okl import *
from palette import oga_green, linear_green, mud_green, lch
from ground import kmeans
from sheet import *
# his greens, measured
a=np.asarray(Image.open('plates/lv/C0081_greens.png').convert('RGB').resize((160,84),Image.BOX),float)/255
lab=rgb_to_oklab(a).reshape(-1,3)
c=kmeans(lab*[1.5,1,1],9,seed=0)/[1.5,1,1]; his=c[np.argsort(c[:,0])][1:8]
ramps={'his (C-0081, measured)':his,'fitted: hue walks, chroma rises':oga_green(n=7),
       'straight OKLab line, same ends':linear_green(n=7),'mid green + white / + black (mud)':mud_green(n=7)}
# a mound: sphere lit from upper right, quantised to 7 steps with ordered dither
H,W=48,80
yy,xx=np.mgrid[0:H,0:W]; cx,cy,r=40,52,38
dx,dy=(xx-cx)/r,(yy-cy)/r; inside=dx**2+dy**2<1
nz=np.sqrt(np.clip(1-dx**2-dy**2,0,1)); nrm=np.stack([dx,-dy,nz],-1)
sun=np.array([0.6,0.6,0.5]); sun/=np.linalg.norm(sun)
v=np.clip(nrm@sun,0,1)
B=np.array([[0,8,2,10],[12,4,14,6],[3,11,1,9],[15,7,13,5]])/16
cells=[];labs=[]
for name,rp in ramps.items():
    x=v*(len(rp)-1); q=np.clip(np.floor(x+B[yy%4,xx%4]),0,len(rp)-1).astype(int)
    img=np.where(inside[...,None],oklab_to_rgb(rp[q]),oklab_to_rgb(lch(0.93,0.02,240))[None,None])
    sw=np.repeat(np.repeat(oklab_to_rgb(rp)[None],12,0),12,1)
    sw=np.asarray(Image.fromarray(u8(sw)).resize((W,12),Image.NEAREST))/255
    cells.append(zoom(np.concatenate([img,sw],0),5)); 
    C=lab_to_lch(rp)[:,1]; labs.append(f'{name}   C: '+' '.join(f'{x:.2f}' for x in C))
grid(cells,2,labs,title='Ex2  unmuddied mixing: the middle keeps its chroma, the light is a colour (C-0081, p.44)').save('sheets/ex2_ramps.png')
EOF
python3 work/ex2.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image
from okl import *
from ground import kmeans
from scipy.optimize import curve_fit
pts=[]
for n in ['C0081_greens','C0064_bg','C0007_bg']:
    a=np.asarray(Image.open(f'plates/lv/{n}.png').convert('RGB').resize((160,84),Image.BOX),float)/255
    lab=rgb_to_oklab(a).reshape(-1,3); c=kmeans(lab*[1.5,1,1],12,seed=0)/[1.5,1,1]
    l=lab_to_lch(c); l=l[(np.degrees(l[:,2])%360>95)&(np.degrees(l[:,2])%360<170)]
    pts+=list(l)
pts=np.array(pts); L,C,h=pts[:,0],pts[:,1],np.degrees(pts[:,2])%360
f=lambda L,cm,l0,s: cm*(1-np.exp(-np.clip(L-l0,0,None)/s))
p,_=curve_fit(f,L,C,p0=[.17,.17,.2]); print('C fit',p.round(3))
ph=np.polyfit(L,h,1); print('h fit',ph.round(1))
for l,c,hh in sorted(zip(L,C,h)): print(f'{l:.2f} {c:.3f} {hh:.0f}  fit {f(l,*p):.3f} {np.polyval(ph,l):.0f}')
EOF

# output:
C fit [0.155 0.222 0.264]
h fit [-37.3 141.2]
0.17 0.004 157  fit 0.000 135
0.19 0.012 109  fit 0.000 134
0.23 0.013 132  fit 0.005 133
0.24 0.020 148  fit 0.012 132
0.28 0.031 106  fit 0.028 131
0.30 0.036 131  fit 0.038 130
0.33 0.043 138  fit 0.052 129
0.34 0.049 114  fit 0.057 128
0.38 0.070 131  fit 0.070 127
0.40 0.066 118  fit 0.076 126
0.42 0.067 133  fit 0.083 125
0.46 0.083 119  fit 0.092 124
0.46 0.099 131  fit 0.092 124
0.51 0.095 125  fit 0.102 122
0.52 0.098 119  fit 0.105 122
0.54 0.121 129  fit 0.108 121
0.56 0.112 123  fit 0.112 120
0.59 0.114 117  fit 0.116 119
0.62 0.132 124  fit 0.120 118
0.62 0.127 122  fit 0.121 118
0.65 0.129 117  fit 0.124 117
0.69 0.143 121  fit 0.128 116
0.69 0.142 119  fit 0.129 115
0.71 0.135 112  fit 0.130 115
0.75 0.154 118  fit 0.134 113
0.77 0.147 111  fit 0.135 112
0.78 0.143 107  fit 0.136 112
0.82 0.159 114  fit 0.138 111
0.86 0.137 104  fit 0.141 109
0.86 0.171 110  fit 0.141 109
0.86 0.017 99  fit 0.141 109
0.89 0.156 108  fit 0.143 108

cd ~/work/pixelart-studies/books/oga && sed -i '' "s/return ramp_path(L0, L1, n, lambda L: 160 - 58 \* L - 20 \* warm,/return ramp_path(L0, L1, n, lambda L: 145 - 40 * L - 20 * warm,/; s/lambda L: float(np.clip(0.26 \* (L - 0.17), 0.012, 0.175)))/lambda L: float(np.clip(0.27 * (L - 0.18), 0.012, 0.17)))/; s/# ---- fitted to C-0081 (p.44): h = 160 - 58 L, C = 0.26 (L - 0.17), capped/# ---- fitted to 36 green clusters of C-0081, C-0064, C-0007: h = 145 - 40 L, C = 0.27 (L - 0.18), capped .17/" src/palette.py && python3 work/ex2.py && cat > work/ex3.py <<'EOF'
"""Ex3 coloured greys (p.48, p.103 C39-5). Same values, three palettes: neutral greys, one tint,
Oga's alternating tints. Which reproduces his overcast plate?"""
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image
from okl import *
from palette import lch
from ground import clumped_noise
from sheet import *
from scipy.ndimage import gaussian_filter
a=np.asarray(Image.open('plates/lv/C39-5_greys.png').convert('RGB'),float)/255
W=240; im=Image.fromarray(u8(a)); H=round(im.height*W/im.width)
small=np.asarray(im.resize((W,H),Image.BOX),float)/255
lab=rgb_to_oklab(small); L=lab[...,0]
Ls=np.quantile(L,np.linspace(0.03,0.97,9))
def pal_neutral(): return np.stack([lch(l,0.0,0) for l in Ls])
def pal_one(): return np.stack([lch(l,0.02,30) for l in Ls])
def pal_oga():
    # measured on the plate: red-grey h~10 and purple-grey h~320 alternate with value; an ochre sits high
    out=[]
    for i,l in enumerate(Ls):
        h=12 if i%2==0 else 320
        out.append(lch(l,0.022,h))
    out[6]=lch(Ls[6],0.05,63)   # the ochre (dry grass) step
    return np.stack(out)
def quant(pal,mode='value'):
    # value -> nearest two palette steps by L, dithered with clumped noise (organic)
    x=np.interp(L,Ls,np.arange(len(Ls)))
    u=clumped_noise(L.shape,1.2,3)-0.5
    q=np.clip(np.floor(x+0.5+0.6*u),0,len(Ls)-1).astype(int)
    return pal[q]
def quant_hue(pal_list):
    # choose, for each pixel, the palette entry nearest in full OKLab (value AND hue)
    P=np.concatenate(pal_list)
    d=((lab[...,None,:]-P[None,None])**2*np.array([2,1,1])).sum(-1)
    return P[np.argmin(d,-1)]
res={}
res['neutral greys (9 values)']=quant(pal_neutral())
res['one tint (warm grey)']=quant(pal_one())
res['Oga: alternating red/purple greys + ochre']=quant(pal_oga())
# a free choice: 9 neutral + 9 tinted, pixel picks nearest (does the plate WANT the tints?)
both=quant_hue([pal_neutral(),pal_oga()])
def blurde(x):
    return np.mean(np.linalg.norm(gaussian_filter(x,(1.5,1.5,0))-gaussian_filter(lab,(1.5,1.5,0)),axis=-1))
cells=[zoom(small,3)];labs=['his C39-5 (board, p.103), 240 px']
for k,v in res.items():
    cells.append(zoom(oklab_to_rgb(v),3)); labs.append(f'{k}   blurdE {100*blurde(v):.2f}')
cells.append(zoom(oklab_to_rgb(both),3))
Pn=pal_neutral(); share_t=np.mean(np.min(((both[...,None,:]-Pn[None,None])**2).sum(-1),-1)>1e-9)
labs.append(f'free choice neutral vs tinted: plate picks tinted for {100*share_t:.0f}% of pixels')
grid(cells,2,labs,title='Ex3  coloured greys: the same 9 values, different tints (C39-5, p.103)').save('sheets/ex3_greys.png')
EOF
python3 work/ex3.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && cat >> work/ex3.py <<'EOF'
# --- v2: tints by PLACE (nearest family at the pixel's value), not by value step ---------------
fams={'red-grey':(0.022,12),'purple-grey':(0.022,320)}
P=[lch(l,c,h) for l in Ls for (c,h) in fams.values()]
P+= [lch(l,0.07,65) for l in Ls[4:]]          # the lit ochre ground (the point)
P+= [lch(Ls[3],0.05,240)]                     # the one blue accent
P=np.stack(P)
d=((lab[...,None,:]-P[None,None])**2*np.array([2,1,1])).sum(-1)
v2=P[np.argmin(d,-1)]
Pn=np.stack([lch(l,0,0) for l in np.quantile(L,np.linspace(0.02,0.98,len(P)))])
dn=((lab[...,None,:]-Pn[None,None])**2*np.array([2,1,1])).sum(-1); vn=Pn[np.argmin(dn,-1)]
cells=[zoom(small,3),zoom(oklab_to_rgb(vn),3),zoom(oklab_to_rgb(v2),3)]
labs=['his C39-5',f'{len(P)} neutral greys, nearest   blurdE {100*blurde(vn):.2f}',f'{len(P)} tinted: red-grey + purple-grey per value, lit ochre, one blue   blurdE {100*blurde(v2):.2f}']
grid(cells,3,labs,title='Ex3b  tints belong to places, not to value steps').save('sheets/ex3b_greys_by_place.png')
print(100*blurde(vn),100*blurde(v2))
EOF
python3 work/ex3.py

# output:
2.0585572971902377 1.370978571289311

# What Kazuo Oga teaches, in pixels: lessons

The book's model, in its own terms and with page references, is in [MODEL.md](MODEL.md). This file covers what I did with it: each principle translated into pixels, what carried and what didn't, and every dead end. Sheets are in `sheets/`, code in `src/`, and the exercise scripts in `work/`.

Scales: *close* is about 0.1 m/px, *landscape* is a 320×180 view from a person or a low hill, *iso* is a 30° parallel projection, *region* is about 1 m/px from above.

## 0. Before copying anything: calibrating the plates

- **The scan lies about black.** My first measurements said Oga keeps his darkest 2% at OKLab L 0.35, where photos sit at 0.20. That looked like a finding ("Oga lifts the black point") until I measured the black of the printed text on the same pages: L 0.29–0.35. It was the printing and scanning, not Oga. Every plate is now levels-corrected per page: black is the page's darkest 0.1%, white is the paper (`work/plates.py`, output in `plates/lv/`). After correction his black point (L 0.12–0.26) is like a photo's. **Measure the paper and the ink before you measure the painter.**
- **Global statistics barely separate Oga from photos** (`src/measure.py`: shadow share, chroma by value, tint count, detail concentration). Photos of the same subjects give numbers in the same ranges. What makes his pictures his is *where* things are put (which plane is lit, which is in shadow, where the detail is), not the histogram. So the measurements below are local, made inside one passage or on one kind of colour.
- **His pictures survive reduction to our size** (`sheets/00_survives.png`). C-0064, C-0007, C-0792 and the cover, area-reduced to 160 px wide, still read almost completely: the masses, the light and the space. Everything the reduction removes is his last layer. That is the book's claim about the ground stage (§2 of MODEL) seen from the other side, and it's why this translation is possible at all.

## 1. Colour: few paints, unmuddied, coloured greys

### 1a. The green ramp (C-0081, p.44) — `sheets/ex2_ramps.png`, `src/palette.py`

- **Measured:** 36 green clusters from C-0081, C-0064 and C-0007.
  - Hue walks from blue-green in the dark to yellow in the light, h ≈ 145 − 40·L.
  - Chroma *rises* almost linearly with value all the way to the top, C ≈ 0.27·(L − 0.18), capped at about 0.17.
  - His lightest green is lemon or chrome green, never a whitened green.
  - In C-0081 the mid-tones carry more chroma than a straight line between the ends: step 3 is C 0.10 against the line's 0.07, and step 4 is 0.13 against 0.10. These are the "bridging mid-tones" the book describes.
- **Pixel method:** a ramp is a path in OKLCh with hue(L) and chroma(L), not a line between two colours and never a colour plus white or black. `oga_green()` is the fitted path.
- **The failure the book names, reproduced:** the same mid green lightened with white and darkened with black. The lit side of the mound goes grey-white and the picture goes chalky. That's "mud" in pixel form: chroma falls as value rises.
- **Carries fully.** Pixel art already uses hue-shifted ramps. What Oga adds is the rule that chroma keeps rising into the light, and a measured slope for it.

### 1b. Coloured greys (C39-5, p.103) — `sheets/ex3_greys.png`, `sheets/ex3b_greys_by_place.png`

- **Measured on the overcast board:**
  - 92% of the pixels are low-chroma (C < 0.04).
  - They split into two tints that alternate: red-grey (h ≈ 10) and purple-grey (h ≈ 320).
  - One ochre (h 63) and one blue sit among them.
- **Dead end:** I tied the tints to value steps (red, purple, red, purple…) as in a pixel-art ramp. The ochre smeared across the sky, and the result was *worse* than neutral grey by eye, while the numbers barely moved (blurΔE 2.27 against neutral 2.34). **Tints belong to places, not to value steps**: ochre is the lit dry grass, red-grey the earth bank and trunks, purple-grey the sky and the far buildings.
- **What worked:** the same number of colours (24), with a red-grey and a purple-grey at each value, the lit ochre, and the one blue. Each pixel takes the nearest entry.
  - Tinted: blurΔE **1.37**. Neutral: **2.06**.
  - The tinted version reads as his picture; the neutral one reads as a photograph with the colour turned off.
- **Rule for us:** in low light, give every material its own tinted grey ramp: earth and wood warm, sky and distance violet. Put all the saturation of the picture in the one lit point. His grey world sings because of the orange patch the tanuki stands in.

## 2. The ground stage (地塗り)

### 2a. Reduction is not a ground stage — `sheets/ex1a_ground.png`, `src/ground.py`

- **What I tried:** a pixel "ground" made from an image. I chose *k* paints for the picture by k-means, decided them at the width of a flat brush (a 4–8 px cell), and never averaged two paints: each pixel is one paint. A soft weight field is sampled with a *clumped* noise, so paints bleed across boundaries in ragged tongues, and each mass is split into two "not fully mixed" halves in broad patches (塗りムラ).
- **First version: camouflage.** I sampled the soft weights everywhere, so every pixel was a coin toss and no mass had an identity. Fix: masses are decisive (weights raised to a power), bleeding happens only in a boundary band, and the unevenness is a separate, weak, broad split. The split amount has to stay small, about 0.012 in OKLab; at 0.03 the paper white splits into pink and blue.
- **The finding.** The same machine run on Oga's C-0064 gives a ground stage that reads as his painting. Run on a photo of the Rainier meadow, it gives camouflage. **A painting is already organised; a photo isn't.** Oga's ground stage fixes the light direction, the overall colour and the atmosphere (p.48). Those are decisions, and clustering doesn't make them.

### 2b. A ground from a plan — `sheets/ex1b_plan.png`, `src/plan.py`, `plans/rainier_valley.py`

- **What I did:** I drew an "art setting" for the photo: eight planes (sky, cliff, far forest, the two conifer stands, meadow, stream, path). Each plane gets exactly two paints, lit and shadow, and the lit/shadow shapes are decided at cell size and smoothed by one more cell, which is the painter organising the crowd.
- **Result:** the dark conifer masses, the lit meadow plane and the pale far slope read at once, and the picture has a structure the k-means version lacks.
- **Where it falls short:** my straight-edged polygons read as cut paper where they meet the sky. The plane boundary needs the same care as a mass outline: the conifer spires and the ragged treeline of the studio's earlier work.
- **Lesson:** the ground stage needs a plan with planes and one lit/shadow decision per plane. voxsim can supply the plan, since it knows the material, the depth and the normal of every pixel. So from here on I paint from simulated fields (`src/scene.py`), not from photos, and use the photos only as references.

"""Close-scale boulder field (the gorge of C-0792, p.56) rendered to fields by ray casting.

Each boulder is an ellipsoid cut by a few joint planes (convex), so it has faces and edges, as rock
does. The gorge: a back wall (rising plane), a water surface, and a LIGHT WINDOW: the sun reaches the
floor only through a gap between the canyon rims, a band in world space. Most of the picture is in
the wall's shadow; light falls on the few boulder planes that face the sun inside the band.
"""
import numpy as np
from scipy.spatial.transform import Rotation as R

ROCK, WATER, WALL, SKY = 2, 6, 10, 0


def make_boulders(n=26, seed=0, spread=(9.0, 14.0)):
    rng = np.random.default_rng(seed)
    bs = []
    for i in range(n):
        z = rng.uniform(2.5, spread[1])
        x = rng.uniform(-spread[0], spread[0]) * (0.4 + z / spread[1])
        s = rng.uniform(0.7, 2.0) * (0.8 + z / 20)
        radii = s * np.array([rng.uniform(0.9, 1.5), rng.uniform(0.55, 0.85), rng.uniform(0.8, 1.2)])
        rot = R.from_euler('xyz', rng.uniform(-0.35, 0.35, 3) * [1, 3, 1]).as_matrix()
        c = np.array([x, radii[1] * 0.55, z])
        cuts = []
        for k in range(rng.integers(2, 5)):
            nrm = rng.standard_normal(3); nrm[1] = abs(nrm[1]) * 0.6 + 0.2; nrm /= np.linalg.norm(nrm)
            cuts.append((nrm, rng.uniform(0.55, 0.85)))      # plane: n.(p-c) <= d * |radii along n|
        bs.append((c, radii, rot, cuts))
    return bs


def render(W=200, H=110, seed=0, eye=(0, 2.2, -2.0), look=(0, 0.6, 8.0), fov=62,
           sun=(-0.55, 0.62, 0.55), window=(-2.0, 3.5), wall_z=15.0, water_y=0.15):
    sun = np.asarray(sun, float); sun /= np.linalg.norm(sun)
    eye = np.asarray(eye, float); fwd = np.asarray(look, float) - eye; fwd /= np.linalg.norm(fwd)
    right = np.cross([0, 1, 0], fwd); right /= np.linalg.norm(right); up = np.cross(fwd, right)
    f = (W / 2) / np.tan(np.radians(fov / 2))
    yy, xx = np.mgrid[0:H, 0:W]
    d = (fwd[None, None] * f + right[None, None] * (xx - W / 2)[..., None] - up[None, None] * (yy - H / 2)[..., None])
    d /= np.linalg.norm(d, axis=-1, keepdims=True)
    D = d.reshape(-1, 3); O = np.broadcast_to(eye, D.shape)
    bs = make_boulders(seed=seed)
    t, nrm, bid = hit_all(O, D, bs)
    mat = np.full(len(D), SKY)
    # back wall: plane z = wall_z, leaning back
    tw = (wall_z - O[:, 2]) / np.where(np.abs(D[:, 2]) > 1e-6, D[:, 2], 1e-6)
    tw = np.where(tw > 0, tw, np.inf)
    # water plane
    tq = (water_y - O[:, 1]) / np.where(np.abs(D[:, 1]) > 1e-6, D[:, 1], 1e-6)
    tq = np.where(tq > 0, tq, np.inf)
    tt = np.minimum(np.minimum(t, tw), tq)
    mat[tt == t] = ROCK
    mat[(tt == tw) & (tw < np.inf)] = WALL
    mat[(tt == tq) & (tq < tw)] = WATER
    N = np.zeros_like(D); N[:, 1] = 1
    N[mat == ROCK] = nrm[mat == ROCK]
    wn = np.array([0, 0.25, -1.0]); wn /= np.linalg.norm(wn)
    N[mat == WALL] = wn
    P = O + D * np.where(np.isfinite(tt), tt, 0)[:, None]
    # light: window band on the ground plane, projected along the sun; plus boulder cast shadows
    proj = P - sun[None] * (P[:, 1:2] / sun[1])          # where the sun ray through P hits y=0
    inwin = (proj[:, 0] > window[0]) & (proj[:, 0] < window[1])
    inwin &= mat != WALL
    occl = np.zeros(len(D), bool)
    so = P + N * 1e-3
    t2, _, _ = hit_all(so[inwin], np.broadcast_to(sun, (inwin.sum(), 3)), bs)
    occl[np.nonzero(inwin)[0][np.isfinite(t2)]] = True
    lightv = inwin & ~occl
    ndl = np.clip(N @ sun, 0, 1)
    out = dict(mat=mat.reshape(H, W), nrm=N.reshape(H, W, 3), depth=np.where(np.isfinite(tt), tt, 1e3).reshape(H, W),
               sun=(ndl * lightv).reshape(H, W), ndl=ndl.reshape(H, W), window=lightv.reshape(H, W),
               bid=np.where(mat == ROCK, bid, -1).reshape(H, W), pos=P.reshape(H, W, 3), sun_dir=sun)
    return out


def hit_all(O, D, bs):
    n = len(D)
    best = np.full(n, np.inf); nb = np.zeros((n, 3)); bid = np.full(n, -1)
    for i, (c, radii, rot, cuts) in enumerate(bs):
        # to local ellipsoid space
        o = (O - c) @ rot; dd = D @ rot
        os, ds = o / radii, dd / radii
        a = (ds * ds).sum(1); b = 2 * (os * ds).sum(1); cc = (os * os).sum(1) - 1
        disc = b * b - 4 * a * cc
        ok = disc > 0
        sq = np.sqrt(np.where(ok, disc, 0))
        t0 = (-b - sq) / (2 * a); t1 = (-b + sq) / (2 * a)
        tin = np.where(ok, t0, np.inf); tout = np.where(ok, t1, -np.inf)
        p_in = os + ds * tin[:, None]
        nin = p_in / radii; nsrc = nin.copy()             # ellipsoid normal (local)
        for (pn, dd_) in cuts:
            pnl = pn @ rot                                  # plane normal in local coords
            ext = dd_ * np.sqrt(((pnl * radii) ** 2).sum())
            den = dd @ pnl; num = ext - o @ pnl
            tp = num / np.where(np.abs(den) > 1e-9, den, 1e-9)
            entering = den < 0
            upd = entering & (tp > tin)
            tin = np.where(upd, tp, tin)
            nsrc[upd] = pnl
            tout = np.where(~entering & (tp < tout), tp, tout)
            # ray parallel & outside: kill
            tout = np.where((np.abs(den) <= 1e-9) & (num < 0), -np.inf, tout)
        valid = (tin < tout) & (tin > 1e-4) & (tin < best)
        best = np.where(valid, tin, best)
        nw = nsrc @ rot.T
        nw /= np.linalg.norm(nw, axis=1, keepdims=True) + 1e-12
        nb[valid] = nw[valid]; bid[valid] = i
    return best, nb, bid

cd ~/work/pixelart-studies/books/oga && cat > work/ex4.py <<'EOF'
"""Ex4 light concentrated, shadow the majority, colour in the shadow (C-0792, p.56)."""
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image
from okl import *
from palette import lch, fam
from ground import clumped_noise
from oga import organise
from scipy.ndimage import binary_dilation, gaussian_filter
import boulders as B
from sheet import *

def paint_gorge(F, mode='oga', seed=0, cell=2.0, rag=0.55):
    mat,N,ndl,sun=F['mat'],F['nrm'],F['ndl'],F['sun']
    H,W=mat.shape; lab=np.zeros((H,W,3))
    lit_f=fam('rock','lit'); sh_f=fam('rock','shadow')
    full=np.concatenate([sh_f,lit_f])                 # 8 steps dark->light
    u=clumped_noise((H,W),1.2,seed)-0.5
    rock=mat==B.ROCK
    if mode=='before':
        # every boulder lit by the same sun, lambert through the whole ramp
        x=np.clip(0.15+0.85*ndl,0,1)*7.999
        q=np.clip(np.floor(x+0.5),0,7).astype(int)
        lab[rock]=full[q][rock]
    else:
        lit=(sun>0.22)&rock
        # organise per boulder: faces become planes
        s=np.where(lit,ndl,0)
        for b in np.unique(F['bid'][rock]):
            m=F['bid']==b
            s=np.where(m,organise(s,m&lit,cell*0.5),s)
        lstep=np.clip((s-0.22)/0.6,0,1)*3.999
        ny=N[...,1]
        tow=np.clip(N@np.array([0.7,0.2,-0.5]),0,1)       # faces turned to the lit floor get bounce
        pos=F['pos']; low=np.clip(1-pos[...,1]/0.5,0,1)      # contact: dark near the ground
        sstep=np.clip(0.9+2.2*np.clip(ny,0,1)+0.8*tow-1.6*low,0,3.999)
        for b in np.unique(F['bid'][rock]):
            m=(F['bid']==b)&~lit
            sstep=np.where(m,organise(sstep,m,cell*0.6),sstep)
        step=np.where(lit,lstep,sstep)
        q=np.clip(np.floor(step+0.5+rag*u),0,3).astype(int)
        c=np.where(lit[...,None],lit_f[q],sh_f[q])
        # the rock's own warm colour in the shadow, in patches (world-anchored would be better)
        warm=lch(0.40,0.035,45)
        wm=(clumped_noise((H,W),3.0,seed+4)<0.22)&rock&~lit&(q>=1)
        c[wm]=0.55*c[wm]+0.45*(warm+(sh_f[q[wm]]-sh_f[1])*0.8)
        # the edge of the light (際): lit face pixels touching shadow get the light's colour
        edge=binary_dilation(rock&~lit)&lit
        cl=lab_to_lch(c[edge]); cl[:,1]+=0.03; cl[:,2]=cl[:,2]*0.6+np.radians(85)*0.4
        c[edge]=lch_to_lab(cl)
        lab[rock]=c[rock]
    # wall: dark, in shadow, cool with warm streaks (same in both, so the comparison is fair)
    wall=mat==B.WALL
    vs=clumped_noise((H,W),1.0,seed+9)
    vs=gaussian_filter(vs,(3,0.4)); vs=(vs-vs.min())/(vs.max()-vs.min())
    wq=np.clip((vs*3.2+0.3*u).astype(int),0,3)
    wall_f=np.stack([lch(0.20,0.02,240),lch(0.25,0.025,235),lch(0.30,0.03,60),lch(0.36,0.03,200)])
    if mode=='before': wall_f=np.stack([lch(0.30+0.08*i,0.02,70) for i in range(4)])
    lab[wall]=wall_f[wq][wall]
    wat=mat==B.WATER
    wf=np.stack([lch(0.24,0.03,220),lch(0.30,0.035,215),lch(0.40,0.04,210),lch(0.62,0.05,215)])
    wq=np.clip((F['window']*2.5+1+0.8*u).astype(int),0,3) if mode!='before' else np.full((H,W),2)
    lab[wat]=wf[wq][wat]
    lab[mat==B.SKY]=lch(0.8,0.04,220)
    return oklab_to_rgb(lab)

F=B.render(W=200,H=110,seed=3)
before=paint_gorge(F,'before'); after=paint_gorge(F,'oga')
plate=Image.open('plates/lv/C0792_boulders.png')
ph=Image.open('refs/pick/river_gravel_3.jpg')
cells=[fit(plate,w=600),zoom(before,3),zoom(after,3),fit(ph,w=600)]
labs=['his C-0792 (p.56): shadow 2/3, light on a few planes',
      'before: every boulder lit by the sun, one lambert ramp',
      'Oga: light only through the gap; shadow family blue-grey with reflected light, warm patches, edge of light',
      'photo (Washington river) for the rock itself']
grid(cells,2,labs,title='Ex4  concentrate the light; the shadow is most of the picture and holds its colour (C-0792)').save('sheets/ex4_gorge.png')
# 8x detail
c1=zoom(np.asarray(plate.resize((200,109),Image.BOX))[20:70,40:120]/255,8); c2=zoom(after[25:75,60:140],8)
grid([c1,c2],2,['his, area-reduced to our size, 8x','mine, 8x'],title='Ex4 detail').save('sheets/ex4_gorge_8x.png')
print('shadow share', 1-(F['sun']>0.22)[F['mat']==B.ROCK].mean())
EOF
python3 work/ex4.py

# output:
~/work/pixelart-studies/books/oga/src/boulders.py:105: RuntimeWarning: invalid value encountered in matmul
  nw = nsrc @ rot.T
shadow share 0.8546770601336303

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/boulders.py').read()
s=s.replace("def make_boulders(n=26, seed=0, spread=(9.0, 14.0)):","def make_boulders(n=48, seed=0, spread=(7.0, 18.0)):")
s=s.replace("        z = rng.uniform(2.5, spread[1])\n        x = rng.uniform(-spread[0], spread[0]) * (0.4 + z / spread[1])\n        s = rng.uniform(0.7, 2.0) * (0.8 + z / 20)",
"        z = 3.0 + (spread[1] - 3.0) * rng.uniform(0, 1) ** 0.8\n        x = rng.uniform(-spread[0], spread[0]) * (0.35 + z / spread[1])\n        s = rng.uniform(0.6, 1.7) * (0.8 + z / 25)")
s=s.replace("eye=(0, 2.2, -2.0), look=(0, 0.6, 8.0), fov=62","eye=(0.5, 3.4, -3.0), look=(0, 0.4, 9.0), fov=58")
open('src/boulders.py','w').write(s)
s=open('work/ex4.py').read()
s=s.replace("""        warm=lch(0.40,0.035,45)
        wm=(clumped_noise((H,W),3.0,seed+4)<0.22)&rock&~lit&(q>=1)
        c[wm]=0.55*c[wm]+0.45*(warm+(sh_f[q[wm]]-sh_f[1])*0.8)""","""        # the rock's own warm colour in the shadow: per boulder (some stones are browner) and on
        # down-facing planes (warm bounce from the lit floor), never as noise patches
        warm=lch(0.40,0.035,45)
        rng=np.random.default_rng(seed+4); bw=rng.uniform(0,1,200)**2
        wt=np.clip(bw[np.clip(F['bid'],0,199)]*0.7+np.clip(-N[...,1],0,1)*0.8,0,0.7)
        wm=rock&~lit
        c[wm]=c[wm]*(1-wt[wm,None])+(warm+(sh_f[q]-sh_f[1])*0.8)[wm]*wt[wm,None]""")
open('work/ex4.py','w').write(s)
EOF
python3 work/ex4.py 2>/dev/null

# output:
shadow share 0.8470326409495549

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/palette.py').read()
s=s.replace("""    'rock':    dict(lit=[(0.62, 0.02, 80), (0.70, 0.025, 75), (0.78, 0.028, 70), (0.86, 0.025, 70)],
                    shadow=[(0.24, 0.015, 255), (0.31, 0.02, 252), (0.38, 0.025, 250), (0.45, 0.03, 250)],""",
"""    'rock':    dict(lit=[(0.60, 0.018, 85), (0.69, 0.02, 80), (0.78, 0.022, 75), (0.88, 0.02, 75)],
                    # C-0792 swatches: shadow L .14-.43, h 248-262, C .01-.03
                    shadow=[(0.17, 0.012, 262), (0.23, 0.016, 256), (0.30, 0.021, 251), (0.38, 0.026, 250)],""")
open('src/palette.py','w').write(s)
s=open('src/boulders.py').read()
s=s.replace("rng.uniform(0.55, 0.85)","rng.uniform(0.7, 1.0)")
s=s.replace("eye=(0.5, 3.4, -3.0), look=(0, 0.4, 9.0), fov=58","eye=(0.5, 2.4, -2.0), look=(0, 0.9, 9.0), fov=60")
s=s.replace("window=(-2.0, 3.5)","window=(-3.5, 1.5)")
open('src/boulders.py','w').write(s)
s=open('work/ex4.py').read()
s=s.replace("""        # the edge of the light (際)""","""        # detail lives in the light: short dark marks (cracks, lichen) on lit planes only;
        # the shadow stays simple (the cover, step 11: 'raise the rock texture')
        mk=(clumped_noise((H,W),0.7,seed+21)<0.10)&lit&(q>=1)
        c[mk]=lit_f[np.maximum(q[mk]-2,0)]
        # the edge of the light (際)""")
open('work/ex4.py','w').write(s)
EOF
python3 work/ex4.py 2>/dev/null

# output:
shadow share 0.9001629703110607

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/boulders.py').read()
s=s.replace("rng.uniform(0.7, 1.0)","rng.uniform(0.35, 0.7)")
s=s.replace("rng.integers(2, 5)","rng.integers(3, 7)")
s=s.replace("window=(-3.5, 1.5)","window=(-4.5, 2.0)")
s=s.replace("sun=(-0.55, 0.62, 0.55)","sun=(-0.5, 0.75, 0.3)")
open('src/boulders.py','w').write(s)
s=open('work/ex4.py').read()
s=s.replace("bw=rng.uniform(0,1,200)**2","bw=rng.uniform(0,1,200)**3*0.6")
open('work/ex4.py','w').write(s)
EOF
python3 work/ex4.py 2>/dev/null

# output:
shadow share 0.5796795952782462

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/boulders.py').read()
s=s.replace("rng.uniform(0.55, 0.85)","rng.uniform(0.75, 1.05)")
s=s.replace("eye=(0.5, 2.4, -2.0), look=(0, 0.9, 9.0), fov=60","eye=(0.5, 4.2, -2.5), look=(0, 0.3, 8.0), fov=60")
s=s.replace("window=(-4.5, 2.0)","window=(-3.8, 0.6)")
open('src/boulders.py','w').write(s)
s=open('work/ex4.py').read()
s=s.replace("<0.10)&lit&(q>=1)","<0.06)&lit&(q>=1)")
open('work/ex4.py','w').write(s)
EOF
python3 work/ex4.py 2>/dev/null

# output:
shadow share 0.6624891961970614

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('work/ex4.py').read()
s=s.replace("wq=np.clip((F['window']*2.5+1+0.8*u).astype(int),0,3) if mode!='before' else np.full((H,W),2)",
"""dash=gaussian_filter(clumped_noise((H,W),0.8,seed+13),(0.3,2.5)); dash=(dash-dash.mean())/dash.std()
    wq=np.clip(np.floor(F['window']*1.3+0.6+0.45*dash),0,3).astype(int) if mode!='before' else np.full((H,W),2)""")
s=s.replace("sstep=np.clip(0.9+2.2*np.clip(ny,0,1)+0.8*tow-1.6*low,0,3.999)","sstep=np.clip(0.4+2.4*np.clip(ny,0,1)**1.5+0.9*tow-1.8*low,0,3.999)")
s=s.replace("lstep=np.clip((s-0.22)/0.6,0,1)*3.999","lstep=np.clip((s-0.22)/0.55,0,1)**1.3*3.999")
open('work/ex4.py','w').write(s)
EOF
python3 work/ex4.py 2>/dev/null

# output:
shadow share 0.6624891961970614

cd ~/work/voxsim-wt; grep -rl "fields\|gbuffer\|G-buffer\|mat_id\|material id" --include=*.md place-skykomish paint-studio paint-land 2>/dev/null | head; ls paint-studio paint-land | head -40

# output:
(eval):1: no matches found: --include=*.md
paint-land:
Cargo.lock
Cargo.toml
REF_lowangle_stamped.png
RESULTS.md
SPEC.md
crates
docs
refs
renders
runs

paint-studio:
Cargo.lock
Cargo.toml
REEL.md
RESULTS.md
SPEC.md
crates
docs
reels
renders
runs

cd ~/work/voxsim-wt; head -60 paint-land/RESULTS.md; grep -rn -i "gbuffer\|g-buffer\|dump.*field\|material id\|npz\|\.npy" paint-land/RESULTS.md paint-land/SPEC.md paint-studio/SPEC.md paint-studio/RESULTS.md | head

# output:
# Survival lane (lane-survival-human) — results log

Checkpointed per phase. Runs: `runs/surv/<name>.log` (worktree), all
`vox-app --headless --size 1024x1024x192 --seed 1`, 1 tick = 1 sim-minute.

## Phase 0 — starting facts (from ~/work/voxsim/runs/e2e2/run.log, before any change)

- 72/72 dead by tick 3500 (day 2.4). Clothed 72 at init -> 41 at t100 -> 5 at t500.
- Air at people: -2.6 .. 9.3 C over the run (spring, dry hill country); the
  per-tick spread across all people is ~0.2 C (temperature is sea-level temp
  minus lapse rate only; no local microclimate). Rain ~0.
- thirst>=0.75 in 16 people by t500 (8 h), hunger>=0.75 in 10 by t600.
- Physiology in code (exec.rs person_tick): thirst 0->1 in 16 h, then health
  -1/2880 per min (2 days); cold: comfort = air + 8 clothed + 14 fire + 10 home
  + 8 carried + 3/huddler - 4*rain, cold rises (12-comfort)/900 per min, at 1
  health -1/2880 per min; hunger 0->1 in 24 h then 14 days. Drains add.
- Offline random decider: uniform category, then uniform option.

## Phase 1 — instrumentation (in progress)

Added (vox-human): `Stats.surv` counters (frames of thirsty / cold-and-bare /
hungry people and whether they offered drink / put-on / make-clothing /
fire / eat), clothing-verb choice counts, drinks that found no water, a
per-death line (`[human] death ...`: stage, worn, carried clothing, needs,
hours since last drink, nearest water, parents alive, task), and the
survival line no longer prints +-3.4e38 when nobody is alive.
Added instrument: `vox-app --oracle` = `vox_human::oracle::NeedsOracle`
(random, except people serve bodily needs and never undress/drop clothing).
Runs started: `base` (random, instrumented), `oracle0` (needs-oracle, no mechanics changes).

### Phase 1 measurements from `base` (random decider, OLD mechanics, instrumented; partial, t~1600)

- Water is reachable: 6666/6746 (99%) frames of people with thirst>=0.75
  offered a drink option; at death the nearest water was 0-15 m away
  (mostly 0-2 m). Hungry frames offered eating 12032/12033.
- Random picks bathe (1191) twice as often as any drink verb (drink_from 608,
  drink_here 130, drink_at_place 56), and 72% of drink_from tasks were
  interrupted by the next decision before arriving (437/608). Several children
  died having **never** drunk in 26-29 h, with water 0-2 m away.
  -> thirst deaths are the random decider (plus random interrupts), not reachability.
- Clothing flow: take_off 141 vs put_on 69; drop_item 70, give 35 (of those
  involving clothing). Dropped items were DELETED (no ground item) and the
  dead's clothing/belongings vanished with them -> mechanics bug.
- cold_bare frames (cold>=0.75 and unclothed): put_on offered only 9% (only
  when carrying clothing), a fire option 2%.
- Cold model (old) had no dependence on how cold, wind, wet, activity, body
  size; clothed people at -2 C were "very cold" and on a 2-day death clock.

## Phase 2 — mechanics changes (commit c6f6d31)

1. `thermo.rs` body heat + water balance

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/scene.py').read()
s=s.replace("def __init__(self, N=1024, res=2.0, seed=0, kind='valley', snow=False, lake=False):",
            "def __init__(self, N=1024, res=2.0, seed=0, kind='valley', snow=False, lake=False, relief=1.0):")
s=s.replace("        base = 0.035 * z + 260 * np.abs(u) ** 1.6 + 30 * u\n        base += 40 * fbm",
            "        base = relief * (0.035 * z + 260 * np.abs(u) ** 1.6 + 30 * u)\n        base += relief * 40 * fbm")
s=s.replace("base = base * (1 - 0.5 * bench) + bench * (0.035 * z + 30) * 0.5","base = base * (1 - 0.5 * bench) + bench * relief * (0.035 * z + 30) * 0.5")
s=s.replace("bench = np.exp(-((u - 0.18) / 0.16) ** 2) * np.exp(-((z - 700) / 500) ** 2)","bench = np.exp(-((u - 0.18) / 0.16) ** 2) * np.exp(-((z - 0.35 * L) / (0.25 * L)) ** 2)")
s=s.replace("sx = cx - 60 + 70 * np.sin(z / 260 + seed)","sx = cx - 0.03 * L + 0.035 * L * np.sin(z / (0.13 * L) + seed)")
s=s.replace("forest &= ~((np.abs(x - cx - 10) < 90) & (z < 260))","forest &= ~((np.abs(x - cx - 0.005 * L) < 0.045 * L) & (z < 0.13 * L))")
s+='''

def render_iso(w, x0, z0, width_m, mpp=0.5, elev=30.0, sun=(0.6, 0.55, -0.55), H=None):
    """30-degree parallel projection looking north (+z) over a patch [x0, x0+width_m] x [z0, ...].
    screen x = world x; screen y = (z - z0) * sin(e) down->up ... drawn front to back with a y-buffer."""
    sun = np.asarray(sun, float); sun /= np.linalg.norm(sun)
    e = np.radians(elev); se, ce = np.sin(e), np.cos(e)
    W = int(width_m / mpp); H = H or int(W * 9 / 16)
    vis = w.sun_shadow(sun, steps=120, step=1.0)
    nt = normals_from(w.top, w.res); ng = normals_from(w.ground, w.res)
    xs = x0 + (np.arange(W) + 0.5) * mpp
    out = {k: np.zeros((H, W)) for k in ('depth', 'sun', 'shadow', 'wx', 'wz', 'crown')}
    out['mat'] = np.full((H, W), SKY, int); out['nrm'] = np.zeros((H, W, 3)); out['nrm'][..., 1] = 1
    out['crown'][:] = -1
    h0 = w.sample(w.ground, np.array([x0 + width_m / 2]), np.array([z0]))[0]
    ybuf = np.full(W, float(H))
    zmax = z0 + (H * mpp) / se + 80
    for zz in np.arange(z0 - 40, zmax, mpp * se * 0.8):
        top = w.sample(w.top, xs, np.full(W, zz))
        sy = H - ((zz - z0) * se + (top - h0) * ce) / mpp
        for c in np.nonzero(sy < ybuf)[0]:
            y0, y1 = int(np.ceil(max(sy[c], 0))), int(np.ceil(min(ybuf[c], H)))
            if y1 > y0:
                out['wx'][y0:y1, c] = xs[c]; out['wz'][y0:y1, c] = zz
                out['depth'][y0:y1, c] = (zz - z0) * ce - (top[c] - h0) * se + 100
        ybuf = np.minimum(ybuf, np.maximum(sy, 0))
    m = out['wz'] != 0
    wx, wz = out['wx'][m], out['wz'][m]
    ix = np.clip((wx / w.res).astype(int), 0, w.N - 1); iz = np.clip((wz / w.res).astype(int), 0, w.N - 1)
    canopy = w.canopy[iz, ix] > 1.0
    mat = np.full(m.sum(), GRASS)
    mat[w.rock[iz, ix]] = ROCK
    mat[canopy & w.conifer_zone[iz, ix]] = CONIFER
    mat[canopy & ~w.conifer_zone[iz, ix]] = FOREST
    mat[w.stream[iz, ix] & ~canopy] = WATER
    mat[w.lake[iz, ix]] = WATER
    if w.snow:
        mat[(mat == GRASS) | (mat == ROCK)] = SNOW
    nn = np.where(canopy[:, None], nt[iz, ix], ng[iz, ix]); nn[mat == WATER] = [0, 1, 0]
    out['mat'][m] = mat; out['nrm'][m] = nn
    v = vis[iz, ix]; out['shadow'][m] = 1 - v
    out['sun'][m] = np.clip(nn @ sun, 0, 1) * v
    out['crown'][m] = np.where(canopy, w.crown_id[iz, ix], -1)
    out['depth'][~m] = 1e6
    out['sun_dir'] = sun; out['horizon'] = 0
    return out
'''
open('src/scene.py','w').write(s)
EOF
cat > work/iso_test.py <<'EOF'
import sys,time; sys.path.insert(0,'src')
import numpy as np
from scene import *
from sheet import *
t=time.time(); w=World(N=768,res=0.5,seed=8,relief=0.25); print('world',time.time()-t, len(w.trees))
t=time.time(); F=render_iso(w,x0=60,z0=40,width_m=160,mpp=0.5,sun=(0.55,0.6,-0.45)); print('iso',time.time()-t)
np.savez_compressed('work/F_iso.npz',**F)
cols=np.array([[.6,.8,1],[.6,.6,.8],[.5,.45,.4],[.5,.8,.3],[.2,.5,.2],[.1,.35,.25],[.2,.3,.7],[.6,.4,.2],[.95,.95,1]])
sh=(0.35+0.65*F['sun'])[...,None]*cols[F['mat']]
zoom(sh,2).save('(manager scratchpad)/iso.png')
EOF
nice -n 10 python3 work/iso_test.py

# output:
world 20.682862997055054 3102
iso 40.649131059646606

cd ~/work/pixelart-studies/books/oga && for i in 7 8 9 10 11 12 13; do python3 work/grid.py $i; done; python3 - <<'EOF'
from PIL import Image
S='(manager scratchpad)/'
for grp,ids in [('C',[7,8,9,10]),('D',[11,12,13])]:
    ims=[Image.open(S+f'g{i}.jpg') for i in ids]
    out=Image.new('RGB',(sum(i.width for i in ims),max(i.height for i in ims)),'white');x=0
    for i in ims: out.paste(i,(x,0)); x+=i.width
    out.save(S+f'grid{grp}.jpg')
EOF

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && mkdir -p copies && cat > work/gridref.py <<'EOF'
# gridref.py plate W scale out   : area-reduce plate to W px wide, show at scale with labelled 8px grid
import sys; sys.path.insert(0,'src')
from PIL import Image, ImageDraw
from sheet import FONT_S
p,W,k,out=sys.argv[1],int(sys.argv[2]),int(sys.argv[3]),sys.argv[4]
im=Image.open(p).convert('RGB'); H=round(im.height*W/im.width)
sm=im.resize((W,H),Image.BOX); sm.save(out.replace('.png','_small.png'))
big=sm.resize((W*k,H*k),Image.NEAREST); d=ImageDraw.Draw(big)
for x in range(0,W,8):
    d.line([(x*k,0),(x*k,H*k)],fill=(255,0,0) if x%32==0 else (255,150,150)); d.text((x*k+1,1),str(x),fill=(255,0,0),font=FONT_S)
for y in range(0,H,8):
    d.line([(0,y*k),(W*k,y*k)],fill=(255,0,0) if y%32==0 else (255,150,150)); d.text((1,y*k+1),str(y),fill=(255,0,0),font=FONT_S)
big.save(out); print(W,H)
EOF
python3 work/gridref.py plates/lv/cover_final.png 128 6 copies/cover_ref_grid.png

# output:
128 240

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('copies/cover_ref_grid.png'); w,h=im.size
im.crop((0,0,w,h//2)).save('(manager scratchpad)/cg1.png')
im.crop((0,h//2,w,h)).save('(manager scratchpad)/cg2.png')"

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('plates/lv/cover_final.png'); W,H=im.size; s=W/128
for n,(x0,y0,x1,y1) in {'rocks':(0,150,70,240),'shrub':(60,120,128,200),'peak':(70,40,128,120)}.items():
  c=im.crop((int(x0*s),int(y0*s),int(x1*s),int(y1*s))); c.thumbnail((900,900)); c.save('(manager scratchpad)/cz_'+n+'.png')
"

# output:
(Bash completed with no output)

"""copykit: deliberate pixel placement for master copies of Oga.

A Canvas holds palette indices. Everything is placed by the copyist: polygons for masses
(the flat brush), ragged 'wet' edges, and small brush marks (dabs) at chosen positions.
Nothing here decides *where*; the copy script does, by eye from the gridded plate.

Brush vocabulary, from the book:
  mass      flat brush area (地塗り); optional wet edge (にじみ): the boundary is broken into a
            1-2 px band of tongues instead of a cut
  flat_stagger  the flat brush shifted vertically in steps (cover step 6): vertical dashes of
            random length, staggered, along a ridge: conifers on a far peak
  splay     the splayed flat brush (バサつかせ, step 7): a fan of 1-px ticks: shrub silhouettes
  dab       a leaf shape of the sakuyo tip: tiny glyphs (1x1..3x2) in a lit colour
  line      clean 1-px run (branches, the blue rim of light on a rock edge)
  blade     grass: 1-px run with a lean, lit tip
"""
import numpy as np
from PIL import Image, ImageDraw
from scipy.ndimage import gaussian_filter, binary_dilation, binary_erosion


class Canvas:
    def __init__(self, W, H, pal, bg=0, seed=0):
        self.W, self.H = W, H
        self.pal = np.asarray(pal, float)          # sRGB 0..1, (n,3)
        self.a = np.full((H, W), bg, np.int16)
        self.rng = np.random.default_rng(seed)
        self.stages = []

    # ---------------------------------------------------------------- utilities
    def mask_poly(self, pts, ss=4):
        im = Image.new('L', (self.W * ss, self.H * ss), 0)
        ImageDraw.Draw(im).polygon([(x * ss, y * ss) for x, y in pts], fill=255)
        return np.asarray(im.resize((self.W, self.H), Image.BOX)) > 127

    def noise(self, scale=1.2, seed=None):
        r = np.random.default_rng(self.rng.integers(1 << 30) if seed is None else seed)
        n = gaussian_filter(r.standard_normal((self.H, self.W)), scale)
        return (n - n.mean()) / (n.std() + 1e-9)

    def snapshot(self, name):
        self.stages.append((name, self.a.copy()))

    def rgb(self, a=None):
        return self.pal[self.a if a is None else a]

    # ---------------------------------------------------------------- masses
    def mass(self, pts_or_mask, idx, wet=0, wet_scale=0.9, where=None):
        """fill a mass. wet>0: the edge is ragged by `wet` px (bleeding tongues)."""
        m = self.mask_poly(pts_or_mask) if not isinstance(pts_or_mask, np.ndarray) else pts_or_mask
        if wet > 0:
            n = self.noise(wet_scale)
            from scipy.ndimage import distance_transform_edt as edt
            din = edt(m); dout = edt(~m)
            sd = np.where(m, din, -dout)                  # signed distance, + inside
            m = sd + wet * 0.8 * n > 0.5
        if where is not None:
            m &= where
        self.a[m] = idx
        return m

    def split(self, mask, p0, p1, idx_side, wet=0.8):
        """paint the part of `mask` on the left of the line p0->p1 with idx_side (a lit plane or
        shadow plane of a rock): planes are decided by a drawn line, not by a normal."""
        yy, xx = np.mgrid[0:self.H, 0:self.W]
        (x0, y0), (x1, y1) = p0, p1
        side = (x1 - x0) * (yy - y0) - (y1 - y0) * (xx - x0)
        side = side / (np.hypot(x1 - x0, y1 - y0) + 1e-9)
        if wet:
            side = side + wet * self.noise(0.8)
        m = mask & (side < 0)
        self.a[m] = idx_side
        return m

    def mottle(self, mask, idx, share=0.25, scale=1.6):
        """塗りムラ: broad uneven patches of a second paint inside a mass."""
        n = self.noise(scale)
        thr = np.quantile(n[mask], 1 - share) if mask.any() else 0
        m = mask & (n > thr)
        self.a[m] = idx
        return m

    def gradient(self, mask, idxs, axis_pts, rag=0.6, scale=1.0):
        """a hake gradation across a mass through the listed paints (adjacent steps interleaved)."""
        yy, xx = np.mgrid[0:self.H, 0:self.W]
        (x0, y0), (x1, y1) = axis_pts
        d = np.array([x1 - x0, y1 - y0], float); L2 = (d ** 2).sum()
        t = ((xx - x0) * d[0] + (yy - y0) * d[1]) / L2
        t = np.clip(t, 0, 0.9999) * len(idxs)
        q = np.clip(np.floor(t + rag * self.noise(scale) * 0.5), 0, len(idxs) - 1).astype(int)
        self.a[mask] = np.asarray(idxs)[q][mask]

    # ---------------------------------------------------------------- marks
    def put(self, x, y, idx):
        x, y = int(round(x)), int(round(y))
        if 0 <= x < self.W and 0 <= y < self.H:
            self.a[y, x] = idx

    def line(self, pts, idx, width=1):
        """clean 1-px runs through the listed points (Bresenham-like, no anti-aliasing)."""
        for (x0, y0), (x1, y1) in zip(pts[:-1], pts[1:]):
            n = int(max(abs(x1 - x0), abs(y1 - y0))) + 1
            for t in np.linspace(0, 1, n + 1):
                x = x0 + (x1 - x0) * t; y = y0 + (y1 - y0) * t
                self.put(x, y, idx)
                if width > 1:
                    self.put(x, y + 1, idx)

    DABS = {
        'dot': [(0, 0)], 'h2': [(0, 0), (1, 0)], 'v2': [(0, 0), (0, 1)],
        'leaf': [(0, 0), (1, 0), (0, 1)], 'leafr': [(0, 0), (1, 0), (1, 1)],
        'blob': [(0, 0), (1, 0), (0, 1), (1, 1)], 'h3': [(-1, 0), (0, 0), (1, 0)],
        'drop': [(0, -1), (-1, 0), (0, 0), (1, 0)], 'diag': [(0, 0), (1, 1)], 'adiag': [(1, 0), (0, 1)],
    }

    def dab(self, x, y, idx, shape='leaf', where=None):
        for dx, dy in self.DABS[shape]:
            X, Y = int(round(x + dx)), int(round(y + dy))
            if 0 <= X < self.W and 0 <= Y < self.H and (where is None or where[Y, X]):
                self.a[Y, X] = idx

    def scatter_dabs(self, region, idx, n, shapes=('leaf', 'leafr', 'dot', 'h2'), bias=None, seed=None):
        """place n dabs inside region; bias: array of weights (e.g. toward the lit side)."""
        r = np.random.default_rng(self.rng.integers(1 << 30) if seed is None else seed)
        ys, xs = np.nonzero(region)
        if len(ys) == 0:
            return
        w = np.ones(len(ys)) if bias is None else np.clip(bias[ys, xs], 0, None) + 1e-9
        pick = r.choice(len(ys), size=min(n, len(ys)), replace=False, p=w / w.sum())
        for i in pick:
            self.dab(xs[i], ys[i], idx, shapes[r.integers(len(shapes))], where=region)

    def flat_stagger(self, ridge, idx, lens=(1, 4), width=1, spacing=1, seed=None, down=True):
        """cover step 6: flat brush shifted vertically -> staggered vertical dashes hanging from a
        ridge line (list of (x,y)); models conifers on a far peak."""
        r = np.random.default_rng(self.rng.integers(1 << 30) if seed is None else seed)
        xs = np.arange(min(p[0] for p in ridge), max(p[0] for p in ridge) + 1, spacing)
        rx = np.array([p[0] for p in ridge], float); ry = np.array([p[1] for p in ridge], float)
        for x in xs:
            y0 = np.interp(x, rx, ry) + r.integers(-1, 2)
            L = r.integers(lens[0], lens[1] + 1)
            for k in range(L):
                for w in range(width):
                    self.put(x + w, y0 + (k if down else -k), idx)

    def splay(self, x, y, idx, n=4, length=3, spread=1.2, angle=-90, seed=None):
        """splayed flat brush tip: a fan of short 1-px ticks from (x,y)."""
        r = np.random.default_rng(self.rng.integers(1 << 30) if seed is None else seed)
        for i in range(n):
            a = np.radians(angle + (i - (n - 1) / 2) * spread * 12 + r.normal(0, 6))
            L = length * r.uniform(0.6, 1.1)
            for t in np.arange(0, L, 0.7):
                self.put(x + np.cos(a) * t, y + np.sin(a) * t, idx)

    def blade(self, x, y, idx, length=5, lean=0.3, tip=None):
        for k in range(length):
            self.put(x + lean * k, y - k, idx)
        if tip is not None:
            self.put(x + lean * (length - 1), y - length + 1, tip)


def sample_colors(img_small, pts):
    """average the 3x3 around each (x,y) of an area-reduced reference -> sRGB 0..1."""
    a = np.asarray(img_small.convert('RGB'), float) / 255
    out = []
    for x, y in pts:
        out.append(a[max(0, y - 1):y + 2, max(0, x - 1):x + 2].reshape(-1, 3).mean(0))
    return np.array(out)

cd ~/work/pixelart-studies/books/oga && cat > work/palpick.py <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image, ImageDraw
from okl import *
from ground import kmeans
from sheet import FONT_S
src,k,out=sys.argv[1],int(sys.argv[2]),sys.argv[3]
a=np.asarray(Image.open(src).convert('RGB'),float)/255
lab=rgb_to_oklab(a).reshape(-1,3)
c=kmeans(lab*[1.4,1,1],k,seed=1,iters=40)/[1.4,1,1]
# order: by hue family then L
lch=lab_to_lch(c); o=np.lexsort((lch[:,0], np.round(((np.degrees(lch[:,2])+30)%360)/45)*(lch[:,1]>0.025)))
c=c[o]
lab2=np.argmin(((lab[:,None]-c[None])**2*[1.4,1,1]).sum(-1),1); share=np.bincount(lab2,minlength=k)/len(lab2)
np.save(out.replace('.png','.npy'),oklab_to_rgb(c))
im=Image.new('RGB',(k*48,70),'white'); d=ImageDraw.Draw(im)
for j,cc in enumerate(c):
    d.rectangle([j*48,0,j*48+46,40],fill=tuple(u8(oklab_to_rgb(cc))))
    L,C,h=lab_to_lch(cc[None])[0]
    d.text((j*48+2,42),f'{j}',fill='black',font=FONT_S); d.text((j*48+14,42),f'{100*share[j]:.0f}%',fill='gray',font=FONT_S)
    d.text((j*48+2,55),f'{L:.2f} {np.degrees(h)%360:.0f}',fill='black',font=FONT_S)
im.save(out)
q=np.asarray(oklab_to_rgb(c[lab2]).reshape(a.shape)); Image.fromarray(u8(q)).resize((a.shape[1]*3,a.shape[0]*3),Image.NEAREST).save(out.replace('.png','_q.png'))
EOF
python3 work/palpick.py copies/cover_ref_grid_small.png 28 copies/cover_pal.png

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('copies/cover_ref_grid.png'); w,h=im.size
im.crop((0,h*120//240,w,h*170//240)).save('(manager scratchpad)/cg3.png')"

# output:
(Bash completed with no output)

"""Master copy 1: the cover painting (Ishizuchi, mist before rain), pp.4-11, at 128x240.

Painted in Oga's order:
  5 sky (white, then grey and celeste worked in)
  6 far peak into the wet sky (sky colours; flat brush staggered for the conifers; one step darker)
  7 whole colour, middle rock -> near vegetation (splayed flat brush; direction changes; thicker paint)
  8 fine branches and leaves already at the ground stage
  9 one strong touch to judge balance, then only the weak parts
 10 lustrous darks in shrub and rock shadows, then vivid brights
 11 rock texture; bright leaf shapes to make the shrub contour stand out
 12 near leaves, grass, moss, flowers

Masses are drawn by hand (polygons read off copies/cover_ref_grid.png). Inside a mass, the split
between its two paints follows his value design ("carbon transfer" of the plate at 1/4 res), smoothed
so it stays a shape, not a texture. Marks are placed by hand or where his plate has a lit feature,
always drawn with my glyphs in my palette.
"""
import sys
sys.path.insert(0, __file__.rsplit('/', 2)[0] + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter, zoom as ndzoom
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab
from copykit import Canvas

ROOT = __file__.rsplit('/', 2)[0]
REF = Image.open(f'{ROOT}/copies/cover_ref_grid_small.png').convert('RGB')
W, H = REF.size
refL = rgb_to_oklab(np.asarray(REF, float) / 255)[..., 0]
refLab = rgb_to_oklab(np.asarray(REF, float) / 255)


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


# ---- the palette: 30 paints, named ------------------------------------------------------------
P = dict(
    paper=c(1.0, 0, 0), mist=c(0.965, 0.008, 225), skyp=c(0.93, 0.03, 230), sky=c(0.87, 0.055, 235),
    pk1=c(0.86, 0.015, 190), pk2=c(0.79, 0.02, 215), pk3=c(0.73, 0.022, 205), pk4=c(0.66, 0.025, 195),
    pkg=c(0.58, 0.045, 165), pkd=c(0.49, 0.045, 160),
    mr1=c(0.80, 0.03, 45), mr2=c(0.71, 0.03, 40), mr3=c(0.61, 0.028, 35),
    rl1=c(0.83, 0.03, 60), rl2=c(0.74, 0.03, 300), rim=c(0.58, 0.16, 268),
    rs1=c(0.43, 0.022, 65), rs2=c(0.36, 0.02, 90), rs3=c(0.29, 0.018, 90), rs4=c(0.22, 0.012, 100),
    g1=c(0.33, 0.04, 135), g2=c(0.41, 0.06, 125), g3=c(0.50, 0.08, 120), g4=c(0.59, 0.10, 118),
    g5=c(0.68, 0.12, 115), g6=c(0.77, 0.13, 110), lem=c(0.87, 0.15, 105),
    pale=c(0.84, 0.06, 120), orange=c(0.66, 0.14, 62), flower=c(0.975, 0.012, 100), viol=c(0.34, 0.03, 300),
)
NAMES = list(P)
I = {k: i for i, k in enumerate(NAMES)}
PAL = np.array([P[k] for k in NAMES])


def ref_split(mask, sigma=1.0, q=0.5, bias=0.0):
    """his value design inside a mask: lit where his (smoothed) L is above the mask's quantile."""
    Ls = gaussian_filter(refL, sigma)
    t = np.quantile(Ls[mask], q) if mask.any() else 0
    return mask & (Ls > t + bias)


def paint(stop=99, seed=3):
    cv = Canvas(W, H, PAL, bg=I['paper'], seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]

    # ---------------- 5  sky: white everywhere, then grey/celeste worked in ----------------------
    sky_blue = cv.mass([(96, 0), (128, 0), (128, 64), (122, 50), (114, 36), (104, 24), (96, 10)], I['skyp'], wet=2.5, wet_scale=1.5)
    cv.mass([(110, 0), (128, 0), (128, 40), (120, 26), (112, 12)], I['sky'], wet=2.5, wet_scale=1.5)
    cv.mass([(60, 20), (96, 14), (100, 30), (80, 36), (62, 32)], I['mist'], wet=3, wet_scale=2)
    cv.snapshot('5 sky')
    if stop <= 5: return cv

    # ---------------- 6  far peak, painted into the wet sky --------------------------------------
    peak = cv.mask_poly([(86, 45), (89, 45), (95, 49), (103, 54), (111, 59), (120, 63), (128, 66), (128, 112),
                         (110, 104), (98, 96), (90, 86), (85, 72), (84, 60)])
    cv.mass(peak, I['pk2'], wet=1.2)
    cv.gradient(peak, [I['pk1'], I['pk2'], I['pk3']], [(86, 90), (110, 55)], rag=1.2)   # lit left face melts into mist below
    lower = cv.mask_poly([(72, 80), (76, 74), (80, 76), (84, 73), (90, 74), (97, 75), (104, 77), (112, 79),
                          (120, 81), (128, 83), (128, 125), (104, 122), (88, 118), (78, 110), (72, 98)])
    cv.mass(lower, I['pk3'], wet=1.5)
    # mist swallows the ridge's left foot: fade to mist/paper with ragged tongues
    fade = lower & (xx < 84) & (yy > 92)
    cv.mass(fade, I['pk1'], wet=2)
    cv.mass(lower & (xx < 78) & (yy > 100), I['mist'], wet=2)
    # one step darker for shading: his value design on the ridge
    dark = ref_split(lower & ~fade, 1.0, 0.45)
    cv.a[(~dark) & lower & ~fade] = I['pk4']
    # the conifers: flat brush shifted vertically along both ridges
    cv.flat_stagger([(74, 79), (80, 76), (86, 74), (94, 75), (102, 77), (112, 79), (122, 82)], I['pk4'], lens=(1, 4), seed=1)
    cv.flat_stagger([(88, 47), (95, 50), (103, 55), (111, 60)], I['pk3'], lens=(1, 3), seed=2, spacing=2)
    # green patch lower ridge (where his dark greens are)
    gp = cv.mask_poly([(96, 92), (104, 90), (114, 96), (118, 108), (108, 118), (98, 112)])
    cv.mass(gp, I['pkg'], wet=1.5)
    cv.flat_stagger([(96, 92), (104, 90), (114, 96)], I['pkd'], lens=(2, 6), seed=3)
    cv.mottle(gp, I['pkd'], share=0.35, scale=0.9)
    cv.snapshot('6 far peak')
    if stop <= 6: return cv

    # ---------------- 7  whole colour: middle rock -> near vegetation ----------------------------
    mrock = cv.mask_poly([(102, 112), (110, 108), (120, 104), (128, 102), (128, 138), (112, 134), (102, 126)])
    cv.mass(mrock, I['mr2'], wet=0.8)
    cv.a[ref_split(mrock, 0.8, 0.5)] = I['mr1']
    cv.a[mrock & ~ref_split(mrock, 0.8, 0.18)] = I['mr3']

    # the big shrub dome on the right (dark mass first)
    shrub = cv.mask_poly([(72, 132), (80, 124), (92, 120), (104, 124), (116, 128), (128, 126), (128, 205),
                          (110, 200), (92, 196), (74, 186), (70, 160)])
    cv.mass(shrub, I['g2'], wet=2.2, wet_scale=0.8)
    shrub = cv.a == I['g2']
    cv.a[shrub & ~ref_split(shrub, 1.2, 0.35)] = I['g1']
    cv.a[ref_split(shrub, 1.2, 0.72)] = I['g3']
    # splayed flat brush along the shrub's top: silhouettes against mist and rock
    for x in range(74, 128, 3):
        ytop = np.argmax(shrub[:, x]) if shrub[:, x].any() else None
        if ytop:
            cv.splay(x, ytop + 1, I['g3'], n=3, length=3, angle=-95 + (x % 7) * 3, seed=x)

    # left airy shrubs (pale against paper, splayed tips)
    airy = cv.mask_poly([(8, 170), (20, 158), (32, 148), (46, 140), (62, 136), (72, 138), (74, 160), (60, 166),
                         (40, 170), (20, 176)])
    cv.mass(airy, I['pale'], wet=2.5, wet_scale=0.7)
    airy = cv.a == I['pale']
    cv.a[airy & ~ref_split(airy, 1.0, 0.45)] = I['g4']
    for x in range(10, 72, 2):
        col = np.nonzero(airy[:, x])[0]
        if len(col):
            cv.splay(x, col[0] + 1, I['pale'], n=3, length=4, spread=1.6, seed=100 + x)

    # middle rocks, dark, with their lit tops (planes)
    rocks_mid = [
        [(56, 156), (66, 150), (78, 148), (84, 154), (80, 166), (66, 170), (56, 166)],
        [(74, 162), (86, 156), (94, 160), (96, 176), (84, 182), (74, 178)],
        [(26, 170), (40, 164), (54, 160), (60, 168), (52, 178), (34, 182), (24, 180)],
        [(36, 156), (46, 150), (56, 152), (54, 160), (42, 164)],
    ]
    for pts in rocks_mid:
        m = cv.mask_poly(pts)
        cv.mass(m, I['rs3'], wet=0.6)
        cv.a[ref_split(m, 0.7, 0.55)] = I['rs1']
        cv.a[ref_split(m, 0.7, 0.85)] = I['rl2']

    # grass band between rocks
    grass = cv.mask_poly([(40, 176), (60, 170), (76, 176), (84, 186), (76, 196), (56, 194), (44, 188)])
    cv.mass(grass, I['g4'], wet=1.5)
    cv.a[grass & ~ref_split(grass, 1.0, 0.4)] = I['g3']

    # the big near rocks (left, bottom): top planes lit, faces in shadow
    rA = cv.mask_poly([(0, 176), (10, 172), (20, 174), (24, 186), (20, 200), (8, 206), (0, 208)])
    rB = cv.mask_poly([(0, 214), (18, 200), (34, 190), (44, 188), (52, 196), (60, 208), (64, 240), (0, 240)])
    rC = cv.mask_poly([(40, 186), (60, 184), (74, 190), (80, 204), (72, 240), (60, 240), (56, 206)])
    rD = cv.mask_poly([(100, 214), (116, 208), (128, 210), (128, 240), (102, 240)])
    for m in (rA, rB, rC, rD):
        cv.mass(m, I['rs3'], wet=0.5)
        cv.mottle(m, I['rs2'], share=0.3, scale=1.4)          # 塗りムラ in the shadow
        cv.mottle(m, I['rs4'], share=0.18, scale=1.1)
    # lit planes: the top face of B is a long diagonal strip (drawn), A's top, D's lit face
    cv.split(rB, (0, 222), (46, 190), I['rl2'], wet=0.8)
    topB = rB & (cv.a == I['rl2'])
    cv.a[rB & ((yy - 190) < -0.62 * (xx - 46) - 11)] = I['rs2']   # the far edge of the top plane, in half shade
    cv.split(rA, (0, 190), (22, 178), I['rl2'], wet=0.6)
    cv.a[rD & ref_split(rD, 0.8, 0.45)] = I['rl2']
    cv.snapshot('7 whole colour')
    if stop <= 7: return cv

    # ---------------- 8  fine branches and leaves already in the ground --------------------------
    cv.line([(30, 168), (36, 160), (40, 152), (44, 146)], I['rs3'])       # dead branch, left shrub
    cv.line([(36, 160), (30, 154)], I['rs3'])
    cv.line([(96, 150), (104, 146), (110, 140)], I['g1'])
    cv.line([(104, 146), (104, 156)], I['g1'])
    # leaves inside the shrub mass, mid value, at ground stage (blend with the under colour)
    cv.scatter_dabs(shrub, I['g3'], 110, bias=gaussian_filter(refL, 1.0), seed=8)
    cv.scatter_dabs(airy, I['g4'], 50, seed=9)
    cv.snapshot('8 ground complete')
    if stop <= 8: return cv

    # ---------------- 10 lustrous darks, then vivid brights --------------------------------------
    cv.scatter_dabs(shrub & (gaussian_filter(refL, 1) < np.quantile(refL[shrub], 0.3)), I['viol'], 40, shapes=('blob', 'h2', 'leaf'), seed=10)
    lit_bias = np.clip(gaussian_filter(refL, 0.8) - np.quantile(refL[shrub], 0.6), 0, None)
    cv.scatter_dabs(shrub, I['g5'], 90, bias=lit_bias, seed=11)
    cv.scatter_dabs(shrub, I['g6'], 40, bias=lit_bias ** 2, seed=12)
    cv.scatter_dabs(airy, I['lem'], 30, bias=np.clip(gaussian_filter(refL, 0.8) - 0.8, 0, None) + 0.01, seed=13)
    cv.snapshot('10 bright & dark')
    if stop <= 10: return cv

    # ---------------- 11 rock texture; the blue rim of light; bright leaf shapes on the contour --
    # the electric cobalt line on the rock top edges (the sky's colour where the light meets the edge)
    for pts in ([(0, 211), (16, 202), (32, 192), (44, 188)], [(0, 177), (10, 173), (20, 175)],
                [(58, 150), (68, 149), (78, 148)], [(28, 170), (40, 164), (52, 160)], [(76, 162), (86, 157)],
                [(100, 214), (116, 208)]):
        cv.line(pts, I['rim'])
    # the lit top plane: lighter pink-ochre strokes along the plane (brush direction = plane direction)
    for k in range(9):
        x0 = 4 + k * 5; y0 = 219 - k * 3.2 + (k % 2)
        cv.line([(x0, y0), (x0 + 3, y0 - 2)], I['rl1'])
    # lichen dots in the rock shadow
    cv.scatter_dabs(rB & ~topB, I['g6'], 12, shapes=('dot',), seed=14)
    cv.scatter_dabs(rC, I['g6'], 5, shapes=('dot',), seed=15)
    # bright leaf shapes along the shrub contour
    edge = shrub & ~np.roll(shrub, 2, 0)
    cv.scatter_dabs(edge, I['g6'], 26, shapes=('leaf', 'leafr', 'h2'), seed=16)
    cv.snapshot('11 detail')
    if stop <= 11: return cv

    # ---------------- 12-13 near leaves, grass, flowers --------------------------------------------
    # the big leaves at right (orange & green), explicit shapes
    for (x, y, col) in [(118, 176, 'g5'), (122, 184, 'g5'), (116, 190, 'g6'), (124, 198, 'orange'), (120, 204, 'orange'),
                        (112, 182, 'g5'), (126, 172, 'g6')]:
        cv.mass([(x - 3, y), (x, y - 2), (x + 3, y - 1), (x + 1, y + 2)], I[col])
        cv.put(x - 3, y, I['g2'])
    cv.line([(114, 206), (116, 190), (118, 176), (120, 166)], I['orange'])
    # the yellow-green grass clump, lower middle: blades with lemon tips
    for i in range(46):
        x = 74 + (i * 37) % 30; y = 222 - (i * 11) % 14
        cv.blade(x, y, I['g5'] if i % 3 else I['g4'], length=6 + i % 5, lean=0.25 * ((i % 5) - 2), tip=I['lem'])
    # small grass blades between the rocks
    for i in range(18):
        x = 40 + (i * 13) % 40; y = 186 - (i * 7) % 12
        cv.blade(x, y, I['lem'] if i % 2 else I['g5'], length=3 + i % 3, lean=0.3 * ((i % 3) - 1))
    # white flower clusters (the "flower" he adds as a service)
    for (x, y) in [(110, 166), (112, 164), (114, 167), (111, 168), (98, 140), (100, 138), (104, 142), (92, 136), (108, 150), (86, 144)]:
        cv.dab(x, y, I['flower'], 'dot' if (x + y) % 3 else 'h2')
    cv.snapshot('13 complete')
    return cv


if __name__ == '__main__':
    import os
    sys.path.insert(0, f'{ROOT}/src')
    from sheet import zoom, grid, fit
    cv = paint()
    os.makedirs(f'{ROOT}/copies/out', exist_ok=True)
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/copies/out/cover_copy.png')
    # stages sheet
    cells = [zoom(cv.pal[a], 2) for _, a in cv.stages]
    grid(cells, len(cells), [n for n, _ in cv.stages], title='Master copy 1: the cover, stage by stage (128x240, 2x)').save(f'{ROOT}/sheets/copy1_cover_stages.png')
    plate = Image.open(f'{ROOT}/plates/lv/cover_final.png')
    grid([fit(plate, h=720), zoom(REF, 3), zoom(cv.rgb(), 3)], 3,
         ['his cover (scan)', 'his, area-reduced to 128 px, 3x', 'my copy, 3x'],
         title='Master copy 1: the cover').save(f'{ROOT}/sheets/copy1_cover.png')

cd ~/work/pixelart-studies/books/oga && python3 copies/cover.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/cover.py').read()
a=s.index("def paint(stop=99, seed=3):"); b=s.index("if __name__ == '__main__':")
new='''def ground_from_ref(cv, sigma=0.8, jitter=0.012, allowed=None, seed=0):
    """the ground stage, laid from his plate: each pixel takes the nearest of MY paints to his
    colour smoothed by `sigma` px (organised), with a clumped jitter so boundaries between two paints
    are wet tongues, not cuts. allowed: optional per-mask paint subsets [(mask, [names])]."""
    lab = np.stack([gaussian_filter(refLab[..., k], sigma) for k in range(3)], -1)
    r = np.random.default_rng(seed)
    n = gaussian_filter(r.standard_normal((H, W, 3)), (1.0, 1.0, 0))
    lab = lab + jitter * n / n.std()
    palab = rgb_to_oklab(PAL)
    wgt = np.array([1.6, 1, 1])
    d = ((lab[..., None, :] - palab[None, None]) ** 2 * wgt).sum(-1)
    if allowed:
        for mask, names in allowed:
            ban = np.ones(len(NAMES), bool); ban[[I[k] for k in names]] = False
            dd = d.copy(); dd[..., ban] = 1e9
            d = np.where(mask[..., None], dd, d)
    cv.a[:] = np.argmin(d, -1)


def paint(stop=99, seed=3):
    cv = Canvas(W, H, PAL, bg=I['paper'], seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]
    SKYP = ['paper', 'mist', 'skyp', 'sky', 'pk1', 'pk2']
    PEAK = ['paper', 'mist', 'pk1', 'pk2', 'pk3', 'pk4', 'pkg', 'pkd', 'skyp']
    upper = yy < 118
    rocks = [cv.mask_poly(p) for p in (
        [(0, 176), (12, 172), (22, 176), (24, 190), (18, 202), (0, 208)],
        [(0, 212), (18, 200), (34, 190), (44, 187), (56, 196), (64, 214), (62, 240), (0, 240)],
        [(102, 214), (116, 208), (128, 209), (128, 240), (104, 240)],
        [(56, 154), (64, 149), (76, 147), (82, 150), (80, 160), (70, 166), (58, 164)],
        [(74, 162), (84, 157), (90, 160), (90, 172), (80, 176), (74, 172)],
        [(22, 180), (34, 172), (48, 166), (54, 170), (48, 180), (32, 186)],
        [(40, 160), (50, 154), (58, 156), (56, 164), (46, 166)],
        [(102, 112), (112, 108), (122, 104), (128, 103), (128, 138), (112, 134), (102, 126)])]
    ROCK = ['rl1', 'rl2', 'rs1', 'rs2', 'rs3', 'rs4', 'viol', 'mr1', 'mr2', 'mr3', 'pk1', 'paper', 'mist']
    rockm = np.any(rocks[:7], 0)
    VEG = ['g1', 'g2', 'g3', 'g4', 'g5', 'g6', 'lem', 'pale', 'orange', 'flower', 'rs2', 'rs3', 'rs4', 'viol', 'paper', 'mist', 'pk1']
    ground_from_ref(cv, 0.8, allowed=[(upper, PEAK + SKYP), (~upper & ~rockm, VEG), (rockm, ROCK)], seed=seed)
    cv.snapshot('ground (5-8), laid from his value/colour design in my paints')
    if stop <= 8: return cv

    # ---------------- 6  the flat brush staggered: conifers on the far ridges -------------------
    cv.flat_stagger([(76, 77), (80, 75), (86, 74), (94, 75), (102, 77), (112, 79), (122, 81), (127, 82)], I['pk4'], lens=(1, 4), seed=1)
    cv.flat_stagger([(88, 47), (95, 50), (103, 55), (111, 60), (119, 63)], I['pk3'], lens=(1, 3), seed=2, spacing=2)
    cv.flat_stagger([(98, 92), (104, 90), (110, 93), (116, 98)], I['pkd'], lens=(2, 5), seed=3)

    # ---------------- 7  splayed brush on the shrub silhouettes ---------------------------------
    veg = np.isin(cv.a, [I[k] for k in ('g1', 'g2', 'g3', 'g4', 'g5', 'g6', 'pale', 'lem')]) & ~upper
    for x in range(8, 128, 2):
        col = np.nonzero(veg[:, x])[0]
        if len(col) and col[0] < 200:
            cv.splay(x, col[0] + 1, cv.a[col[0] + 2, x], n=3, length=3, spread=1.4, angle=-95 + (x % 5) * 4, seed=x)
    cv.snapshot('6-7 staggered conifers, splayed shrub tops')
    if stop <= 9: return cv

    # ---------------- 10-11 lustrous darks, vivid brights, the blue rim, rock planes -------------
    for pts in ([(0, 211), (16, 202), (30, 193), (43, 187)], [(0, 177), (10, 173), (20, 175)],
                [(57, 153), (65, 149), (76, 147)], [(24, 179), (34, 172), (47, 166)], [(75, 162), (84, 157)],
                [(41, 160), (50, 154)], [(103, 214), (116, 208), (126, 209)]):
        cv.line(pts, I['rim'])
    for k in range(8):
        x0 = 5 + k * 5; y0 = 216 - k * 3.1
        cv.line([(x0, y0), (x0 + 3, y0 - 2)], I['rl1'])
    shr = np.isin(cv.a, [I['g1'], I['g2'], I['g3']]) & ~upper
    lit_bias = np.clip(gaussian_filter(refL, 0.8) - np.quantile(refL[shr], 0.55), 0, None)
    cv.scatter_dabs(shr, I['g5'], 80, bias=lit_bias, seed=11)
    cv.scatter_dabs(shr, I['g6'], 30, bias=lit_bias ** 2 + 1e-6, seed=12)
    dk = shr & (gaussian_filter(refL, 1) < np.quantile(refL[shr], 0.25))
    cv.scatter_dabs(dk, I['viol'], 25, shapes=('blob', 'h2'), seed=10)
    cv.scatter_dabs(rockm & (cv.a == I['rs3']), I['g6'], 10, shapes=('dot',), seed=14)
    cv.snapshot('10-11 darks, brights, blue rims, plane strokes')
    if stop <= 11: return cv

    # ---------------- 12-13 near leaves, grass blades, flowers -----------------------------------
    for (x, y, col) in [(118, 177, 'g5'), (122, 185, 'g6'), (117, 191, 'g5'), (124, 199, 'orange'),
                        (119, 205, 'orange'), (112, 183, 'g5'), (125, 172, 'g6')]:
        cv.mass([(x - 3, y), (x, y - 2), (x + 3, y - 1), (x + 1, y + 2)], I[col])
        cv.put(x - 3, y, I['g2'])
    cv.line([(114, 207), (116, 191), (118, 177), (120, 167)], I['orange'])
    for i in range(50):
        x = 74 + (i * 37) % 30; y = 226 - (i * 11) % 16
        cv.blade(x, y, I['g5'] if i % 3 else I['g4'], length=5 + i % 5, lean=0.28 * ((i % 5) - 2), tip=I['lem'])
    for i in range(16):
        x = 42 + (i * 13) % 36; y = 188 - (i * 7) % 12
        cv.blade(x, y, I['lem'] if i % 2 else I['g5'], length=3 + i % 3, lean=0.3 * ((i % 3) - 1))
    for (x, y) in [(110, 166), (112, 164), (114, 167), (111, 168), (98, 140), (100, 138), (104, 142),
                   (92, 136), (108, 150), (86, 144), (95, 147)]:
        cv.dab(x, y, I['flower'], 'dot' if (x + y) % 3 else 'h2')
    cv.snapshot('12-13 near leaves, grass, flowers')
    return cv


'''
s=s[:a]+new+s[b:]
open('copies/cover.py','w').write(s)
EOF
python3 copies/cover.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image
from okl import *
a=np.asarray(Image.open('copies/cover_ref_grid_small.png').convert('RGB'),float)/255
l=lab_to_lch(rgb_to_oklab(a)); h=np.degrees(l[...,2])%360
m=(l[...,1]>0.05)&(h>245)&(h<290)
ys,xs=np.nonzero(m); print(len(ys)); print(sorted(zip(xs,ys)))
EOF

# output:
89
[(0, 185), (8, 209), (9, 208), (14, 209), (15, 176), (16, 206), (17, 206), (21, 182), (22, 182), (22, 183), (23, 184), (24, 179), (25, 178), (28, 174), (28, 175), (30, 173), (30, 194), (31, 173), (31, 193), (31, 194), (32, 172), (32, 173), (33, 171), (33, 172), (33, 176), (33, 177), (34, 171), (34, 175), (35, 171), (37, 165), (38, 166), (39, 166), (43, 169), (49, 190), (50, 191), (53, 194), (54, 194), (54, 195), (55, 195), (55, 196), (56, 196), (58, 156), (58, 157), (59, 156), (59, 157), (60, 158), (60, 200), (61, 157), (61, 158), (61, 160), (62, 158), (62, 159), (62, 180), (63, 158), (64, 158), (67, 158), (68, 158), (69, 155), (69, 158), (70, 155), (70, 158), (71, 158), (71, 159), (74, 178), (74, 179), (78, 148), (79, 169), (83, 164), (84, 152), (84, 162), (84, 163), (84, 164), (85, 164), (85, 181), (85, 182), (86, 164), (86, 166), (87, 166), (88, 166), (88, 183), (88, 184), (89, 126), (89, 127), (90, 125), (91, 125), (93, 125), (94, 131), (95, 129), (96, 129)]

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/cover.py').read()
# palette tweaks: extra pale peak grey, muted greens
s=s.replace("pk1=c(0.86, 0.015, 190),","pk0=c(0.915, 0.012, 200), pk1=c(0.86, 0.015, 190),")
s=s.replace("g1=c(0.33, 0.04, 135), g2=c(0.41, 0.06, 125), g3=c(0.50, 0.08, 120), g4=c(0.59, 0.10, 118),\n    g5=c(0.68, 0.12, 115), g6=c(0.77, 0.13, 110), lem=c(0.87, 0.15, 105),",
 "g1=c(0.32, 0.035, 130), g2=c(0.40, 0.05, 122), g3=c(0.48, 0.065, 118), g4=c(0.57, 0.08, 116),\n    g5=c(0.66, 0.10, 113), g6=c(0.75, 0.115, 110), lem=c(0.85, 0.14, 105),")
s=s.replace("PEAK = ['paper', 'mist', 'pk1',","PEAK = ['paper', 'mist', 'pk0', 'pk1',")
s=s.replace("SKYP = ['paper', 'mist', 'skyp', 'sky', 'pk1', 'pk2']","SKYP = ['paper', 'mist', 'skyp', 'sky', 'pk0', 'pk1', 'pk2']")
s=s.replace("upper = yy < 118","upper = (yy < 104) | ((yy < 124) & (xx < 100))")
s=s.replace("ROCK = ['rl1', 'rl2', 'rs1', 'rs2', 'rs3', 'rs4', 'viol', 'mr1', 'mr2', 'mr3', 'pk1', 'paper', 'mist']\n    rockm = np.any(rocks[:7], 0)",
 "ROCK = ['rl1', 'rl2', 'rs1', 'rs2', 'rs3', 'rs4', 'viol', 'mr1', 'mr2', 'mr3', 'pk1', 'paper', 'mist']\n    rockm = np.any(rocks, 0) & ~upper")
# no jitter in near-white sky
s=s.replace("    lab = lab + jitter * n / n.std()","    lab = lab + jitter * n / n.std() * (lab[..., :1] < 0.93)")
# rims from his plate
a=s.index("    for pts in ([(0, 211), (16, 202)"); b=s.index("    shr = np.isin(cv.a, [I['g1'], I['g2'], I['g3']]) & ~upper")
s=s[:a]+'''    # the blue rims: where HE put them (carbon transfer of his marks), joined into 1-px runs
    lch_ = np.stack([refLab[..., 0], np.hypot(refLab[..., 1], refLab[..., 2]),
                     np.degrees(np.arctan2(refLab[..., 2], refLab[..., 1])) % 360], -1)
    rim = (lch_[..., 1] > 0.05) & (lch_[..., 2] > 245) & (lch_[..., 2] < 290)
    ys, xs = np.nonzero(rim)
    pts = list(zip(xs, ys))
    for (x0, y0) in pts:
        cv.put(x0, y0, I['rim'])
        for (x1, y1) in pts:
            if 0 < x1 - x0 <= 3 and abs(y1 - y0) <= 3:
                cv.line([(x0, y0), (x1, y1)], I['rim'])
'''+s[b:]
open('copies/cover.py','w').write(s)
EOF
python3 copies/cover.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/copykit.py').read()
s+='''

def majority(a, passes=1, protect=None):
    """cluster cleanup: each pixel takes the most common index in its 3x3 if it is an orphan
    (fewer than 2 same-index neighbours). Keeps deliberate marks if protect is given."""
    a = a.copy()
    H, W = a.shape
    for _ in range(passes):
        p = np.pad(a, 1, mode='edge')
        nb = np.stack([p[1 + dy:H + 1 + dy, 1 + dx:W + 1 + dx] for dy in (-1, 0, 1) for dx in (-1, 0, 1) if (dy, dx) != (0, 0)])
        same = (nb == a[None]).sum(0)
        orphan = same < 2
        if protect is not None:
            orphan &= ~protect
        # mode of neighbours
        vals = np.sort(nb, 0)
        best = vals[0].copy(); bestc = np.zeros_like(a); run = np.ones_like(a); 
        for k in range(1, 8):
            eq = vals[k] == vals[k - 1]
            run = np.where(eq, run + 1, 1)
            upd = run > bestc
            best = np.where(upd, vals[k], best); bestc = np.where(upd, run, bestc)
        upd0 = bestc < 1
        a[orphan] = best[orphan]
    return a
'''
open('src/copykit.py','w').write(s)
s=open('copies/cover.py').read()
s=s.replace("from copykit import Canvas","from copykit import Canvas, majority")
s=s.replace("    ground_from_ref(cv, 0.8, allowed=","    ground_from_ref(cv, 1.0, jitter=0.0, allowed=")
s=s.replace("    cv.snapshot('ground (5-8), laid from his value/colour design in my paints')",
"    cv.a = majority(cv.a, 2)\n    cv.snapshot('ground (5-8), laid from his value/colour design in my paints')")
open('copies/cover.py','w').write(s)
EOF
python3 copies/cover.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('plates/lv/C0007_bg.png'); print(im.size)
im.crop((380,0,773,260)).resize((786,520),Image.LANCZOS).save('(manager scratchpad)/c7r.png')
im.crop((0,100,400,416)).resize((800,632),Image.LANCZOS).save('(manager scratchpad)/c7l.png')"

# output:
(773, 416)

cd ~/work/pixelart-studies/books/oga && python3 work/gridref.py plates/lv/C0007_bg.png 192 5 copies/c0007_ref_grid.png

# output:
192 103

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('plates/lv/C0007_bg.png'); im.crop((10,10,706,400)).save('plates/lv/C0007_bg_in.png'); print(696/390)" && python3 work/gridref.py plates/lv/C0007_bg_in.png 176 5 copies/c0007_ref_grid.png

# output:
1.7846153846153847
176 99

"""Master copy 2: C-0007 background (p.60), the path by the stone wall, at 176x99.

Order (Oga's): masses flat first -> each mass split into light and shadow shapes -> the crowd
(clumps of foliage, tufts of grass, stones) as organised members -> points and brights.

Layout ("carbon transfer"): the mass boundaries are my hand polygons read off copies/c0007_ref_grid.png;
where a mass's light/shadow shape follows his, it is his value design smoothed to shapes.
Marks: my brush glyphs (lobed clumps, tuft strokes, stones) placed where his painting has those
members, drawn in my palette.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter, maximum_filter, minimum_filter, label
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab
from copykit import Canvas, majority

REF = Image.open(f'{ROOT}/copies/c0007_ref_grid_small.png').convert('RGB')
W, H = REF.size
refLab = rgb_to_oklab(np.asarray(REF, float) / 255)
refL = refLab[..., 0]


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(
    # meadow, lit: lemon -> yellow green (the unmuddied ramp, chroma rising into the light)
    m1=c(0.94, 0.16, 106), m2=c(0.87, 0.17, 112), m3=c(0.79, 0.16, 118), m4=c(0.70, 0.14, 124),
    # meadow shadow and tufts
    t1=c(0.58, 0.11, 130), t2=c(0.46, 0.08, 136),
    # forest
    f1=c(0.80, 0.16, 114), f2=c(0.69, 0.15, 122), f3=c(0.57, 0.12, 130), f4=c(0.44, 0.08, 138),
    f5=c(0.31, 0.045, 150), f6=c(0.21, 0.025, 165),
    # stones
    s1=c(0.90, 0.07, 102), s2=c(0.78, 0.05, 108), s3=c(0.60, 0.035, 115), s4=c(0.40, 0.03, 125),
    # path
    p1=c(0.78, 0.11, 78), p2=c(0.64, 0.09, 75), p3=c(0.42, 0.05, 90),
    # the cast shadow band: cool deep green with a sheen
    b1=c(0.25, 0.03, 160), b2=c(0.32, 0.04, 150), b3=c(0.40, 0.055, 140),
    post=c(0.55, 0.06, 70),
)
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])


def ref_q(mask, names, sigma=0.9, qs=None):
    """split a mask into len(names) value shapes following his smoothed L (quantiles within mask)."""
    Ls = gaussian_filter(refL, sigma)
    qs = qs or list(np.linspace(0, 1, len(names) + 1)[1:-1])
    t = np.quantile(Ls[mask], qs)
    k = np.searchsorted(t, Ls)
    out = np.zeros((H, W), int)
    for j, n in enumerate(names):
        out[mask & (k == j)] = I[n]
    return out


def lobed_clump(cv, x, y, r, lit, mid, dark, seed=0, where=None):
    """one foliage clump as he paints it (C-0007, C-0827): a flat lit shape with a lobed top edge,
    a mid-value belly, a dark pocket under it. The lobes are the leaf-cluster size (~1-2 px here)."""
    rr = np.random.default_rng(seed)
    yy, xx = np.mgrid[0:H, 0:W]
    ang = np.arctan2(yy - y, xx - x)
    lobes = 1 + 0.22 * np.sin(ang * rr.integers(4, 7) + rr.uniform(0, 6)) + 0.1 * rr.standard_normal()
    d = np.hypot((xx - x) / 1.15, (yy - y)) / (r * lobes)
    body = d < 1
    if where is not None:
        body &= where
    # dark pocket below/left (cast into the mass beneath)
    pocket = (np.hypot((xx - x + 0.6 * r) / 1.2, (yy - y - 0.9 * r)) < 0.8 * r) & ~body
    if where is not None:
        pocket &= where
    cv.a[pocket] = dark
    cv.a[body] = mid
    # light from the upper right: the lit shape is the upper-right part of the body
    litp = body & (((xx - x) * 0.55 - (yy - y) * 0.85) > -0.15 * r)
    cv.a[litp] = lit


def paint(stop=99, seed=2):
    cv = Canvas(W, H, PAL, bg=I['m3'], seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]
    poly = cv.mask_poly
    # ---------------- masses (flat) --------------------------------------------------------------
    forest = poly([(20, 0), (176, 0), (176, 84), (150, 80), (130, 72), (112, 62), (100, 50), (96, 40), (90, 30),
                   (82, 22), (60, 20), (40, 14), (22, 8)])
    meadowR = poly([(84, 24), (94, 34), (100, 48), (112, 62), (132, 74), (150, 80), (176, 84), (176, 99), (104, 99),
                    (100, 76), (96, 60), (86, 44), (76, 34), (72, 28)])
    band = poly([(58, 26), (66, 30), (72, 34), (80, 40), (88, 48), (94, 58), (98, 66), (102, 80), (104, 99),
                 (54, 99), (56, 84), (60, 74), (64, 66), (66, 56), (66, 44), (62, 34)])
    wall_top = [(6, 16), (18, 20), (32, 24), (44, 26), (54, 30), (60, 36), (64, 44), (65, 54), (63, 62), (58, 68)]
    wall = poly(wall_top + [(52, 72), (48, 70), (58, 60), (60, 52), (58, 42), (52, 34), (40, 30), (28, 28), (14, 24), (4, 20)])
    wall2 = poly([(0, 60), (14, 60), (30, 64), (42, 66), (52, 70), (58, 76), (58, 99), (44, 99), (44, 80), (36, 72), (20, 70), (0, 68)])
    path_lit = poly([(98, 66), (102, 72), (106, 80), (109, 90), (112, 99), (105, 99), (103, 88), (100, 78), (96, 70)])
    path_up = poly([(68, 30), (72, 28), (80, 22), (86, 20), (86, 22), (78, 26), (72, 32), (70, 36)])
    meadowL = ~forest & ~band & ~meadowR & ~wall & ~wall2
    cv.a[meadowL] = I['m2']; cv.a[meadowR] = I['m4']; cv.a[forest] = I['f4']; cv.a[band] = I['b1']
    cv.a[wall | wall2] = I['s3']; cv.a[path_lit | path_up] = I['p1']
    cv.snapshot('1 masses, flat')
    if stop <= 1: return cv

    # ---------------- light and shadow shapes inside each mass --------------------------------------
    cv.a[meadowL] = ref_q(meadowL, ['m4', 'm3', 'm2', 'm1'], 1.4, [0.15, 0.4, 0.75])[meadowL]
    cv.a[meadowR] = ref_q(meadowR, ['t1', 'm4', 'm3', 'm2'], 1.2, [0.2, 0.5, 0.85])[meadowR]
    cv.a[forest] = ref_q(forest, ['f6', 'f5', 'f4', 'f3'], 1.0, [0.25, 0.5, 0.75])[forest]
    cv.a[band] = ref_q(band, ['b1', 'b2', 'b3'], 1.5, [0.6, 0.9])[band]
    pd = band & (gaussian_filter(np.abs(refLab[..., 2] / (np.hypot(refLab[..., 1], refLab[..., 2]) + 1e-6)), 0.5) > 0.9) & (xx > 70)
    cv.a = majority(cv.a, 2)
    cv.snapshot('2 light & shadow shapes (his value design, smoothed)')
    if stop <= 2: return cv

    # ---------------- the crowd: foliage clumps where his lit clumps are -----------------------------
    Ls = gaussian_filter(refL, 0.8)
    peaks = (Ls == maximum_filter(Ls, 5)) & forest & (Ls > np.quantile(Ls[forest], 0.45))
    ys, xs = np.nonzero(peaks)
    order = np.argsort(ys)          # paint far (top) first, near (bottom) overlaps
    for k in order:
        x, y = xs[k], ys[k]
        v = Ls[y, x]
        r = 2.2 + 3.0 * (y / H) + (1 if v > np.quantile(Ls[forest], 0.85) else 0)
        lit = I['f1'] if v > np.quantile(Ls[forest], 0.8) else I['f2']
        lobed_clump(cv, x, y, r, lit, I['f3'], I['f5'], seed=int(x * 131 + y), where=forest)
    # clumps in the right meadow's bushes (the lit bush left of the path, lower right bushes)
    cv.snapshot('3 the crowd: lobed clumps where his lit clumps are')
    if stop <= 3: return cv

    # ---------------- grass tufts: short dark strokes where his meadow has dark clusters -------------
    rr = np.random.default_rng(seed + 5)
    for mask, dark, lite in ((meadowL, 't1', 'm1'), (meadowR, 't2', 'm2')):
        lo = (Ls == minimum_filter(Ls, 3)) & mask
        ys, xs = np.nonzero(lo)
        for x, y in zip(xs, ys):
            n = 1 + int(3 * y / H)                  # tufts grow with nearness
            for j in range(n):
                xx0 = x + rr.integers(-1, 2)
                L = 1 + int(rr.integers(1, 3) * (0.5 + y / H))
                lean = rr.choice([-0.5, 0, 0.5])
                cv.blade(xx0, y, I[dark], length=L, lean=lean)
            if rr.uniform() < 0.3:
                cv.put(x + 1, y - L, I[lite])        # a lit blade tip beside the tuft
    cv.snapshot('4 grass tufts (nearer = longer)')
    if stop <= 4: return cv

    # ---------------- stones of the wall: rounded, lit top, dark under ------------------------------
    def stone(x, y, w, h):
        m = (((xx - x) / w) ** 2 + ((yy - y) / h) ** 2) < 1
        cv.a[m] = I['s2']
        cv.a[m & (yy < y - 0.2 * h)] = I['s1']
        cv.a[m & (yy > y + 0.35 * h)] = I['s3']
        under = (((xx - x) / w) ** 2 + ((yy - y - h) / (0.5 * h)) ** 2) < 1
        cv.a[under & ~m] = I['s4']
    # along the upper wall (small, far) then the near cross wall (bigger)
    for i, (x, y) in enumerate(wall_top[1:]):
        stone(x, y + 1, 2.4, 1.6)
    for (x, y) in [(46, 34), (52, 38), (57, 44), (60, 50), (61, 57), (58, 63), (54, 67)]:
        stone(x, y, 2.6, 1.8)
    for (x, y, w, h) in [(4, 62, 4, 2.6), (12, 63, 3.6, 2.4), (20, 65, 3.8, 2.6), (28, 67, 4, 2.6), (36, 69, 4, 2.8),
                         (44, 72, 4.2, 3), (50, 77, 4.4, 3), (50, 84, 4.6, 3.2), (51, 91, 4.8, 3.4), (51, 97, 5, 3.4)]:
        stone(x, y, w, h)
    cv.snapshot('5 stones: lit tops, dark undersides')
    if stop <= 5: return cv

    # ---------------- points: the post, sheen on the band, path edge ---------------------------------
    cv.line([(37, 44), (37, 60)], I['post'])
    cv.line([(71, 36), (76, 42), (82, 48), (88, 56), (93, 64)], I['p3'])   # the path, dim, inside the shadow
    cv.snapshot('6 points')
    return cv


if __name__ == '__main__':
    from sheet import zoom, grid, fit
    cv = paint()
    import os; os.makedirs(f'{ROOT}/copies/out', exist_ok=True)
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/copies/out/c0007_copy.png')
    cells = [zoom(cv.pal[a], 2) for _, a in cv.stages]
    grid(cells, 3, [n for n, _ in cv.stages], title='Master copy 2: C-0007, stage by stage (176x99, 2x)').save(f'{ROOT}/sheets/copy2_c0007_stages.png')
    plate = Image.open(f'{ROOT}/plates/lv/C0007_bg_in.png')
    grid([fit(plate, w=704), zoom(REF, 4), zoom(cv.rgb(), 4)], 1,
         ['his C-0007 (scan)', 'his, area-reduced to 176 px, 4x', 'my copy, 4x'], title='Master copy 2: C-0007').save(f'{ROOT}/sheets/copy2_c0007.png')

cd ~/work/pixelart-studies/books/oga && python3 copies/c0007.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image
from okl import *
from scipy.ndimage import gaussian_filter
from sheet import zoom
a=np.asarray(Image.open('copies/c0007_ref_grid_small.png').convert('RGB'),float)/255
lab=rgb_to_oklab(a); lab=np.stack([gaussian_filter(lab[...,k],0.7) for k in range(3)],-1)
L=lab[...,0]; C=np.hypot(lab[...,1],lab[...,2]); h=np.degrees(np.arctan2(lab[...,2],lab[...,1]))%360
cls=np.zeros(L.shape,int)
cls[(h<95)&(C>0.06)]=1   # path ochre
cls[(C<0.075)&(L>0.6)]=2 # stone
cls[L<0.42]=3            # dark
out=np.array([[.5,.8,.3],[.9,.6,.2],[.8,.8,.8],[.1,.2,.1]])[cls]
zoom(out,4).save('(manager scratchpad)/cls.png')
EOF

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/c0007.py').read()
s=s.replace("s1=c(0.90, 0.07, 102), s2=c(0.78, 0.05, 108), s3=c(0.60, 0.035, 115), s4=c(0.40, 0.03, 125),",
            "s1=c(0.91, 0.11, 102), s2=c(0.80, 0.085, 108), s3=c(0.62, 0.06, 115), s4=c(0.38, 0.04, 130),")
a=s.index("    band = poly("); b=s.index("    wall_top = ")
s=s[:a]+'''    # carbon transfer of the dark band and the lit path from his plate (value/hue classes, smoothed)
    labs = np.stack([gaussian_filter(refLab[..., k], 0.7) for k in range(3)], -1)
    Ls0, Cs0 = labs[..., 0], np.hypot(labs[..., 1], labs[..., 2])
    hs0 = np.degrees(np.arctan2(labs[..., 2], labs[..., 1])) % 360
    dark = Ls0 < 0.42
    lab_, n_ = label(dark)
    band = lab_ == lab_[85, 75]
    band &= ~forest | (yy > 40) & (xx < 100)
    ochre = (hs0 < 95) & (Cs0 > 0.06)
'''+s[b:]
s=s.replace("wall_top = [(6, 16), (18, 20), (32, 24), (44, 26), (54, 30), (60, 36), (64, 44), (65, 54), (63, 62), (58, 68)]",
            "wall_top = [(2, 16), (14, 20), (26, 23), (38, 26), (48, 28), (56, 31), (62, 37), (67, 44), (69, 52), (69, 60), (66, 67), (61, 72)]")
s=s.replace("wall = poly(wall_top + [(52, 72), (48, 70), (58, 60), (60, 52), (58, 42), (52, 34), (40, 30), (28, 28), (14, 24), (4, 20)])",
            "wall = poly(wall_top + [(56, 72), (62, 64), (64, 54), (62, 44), (56, 36), (46, 32), (36, 30), (24, 28), (12, 25), (2, 21)])")
s=s.replace("path_lit = poly([(98, 66), (102, 72), (106, 80), (109, 90), (112, 99), (105, 99), (103, 88), (100, 78), (96, 70)])",
            "path_lit = ochre & (yy > 60)")
s=s.replace("    meadowL = ~forest & ~band & ~meadowR & ~wall & ~wall2\n","    meadowR &= ~band & ~path_lit\n    meadowL = ~forest & ~band & ~meadowR & ~wall & ~wall2 & ~path_lit\n")
s=s.replace("cv.a[forest] = I['f4']; cv.a[band] = I['b1']","cv.a[forest] = I['f4']; cv.a[band] = I['b1']\n    forest &= ~band")
# clumps: fewer, larger, never on his darks
s=s.replace("peaks = (Ls == maximum_filter(Ls, 5)) & forest & (Ls > np.quantile(Ls[forest], 0.45))",
            "peaks = (Ls == maximum_filter(Ls, 7)) & forest & (Ls > np.quantile(Ls[forest], 0.55))")
s=s.replace("lobed_clump(cv, x, y, r, lit, I['f3'], I['f5'], seed=int(x * 131 + y), where=forest)",
            "lobed_clump(cv, x, y, r, lit, I['f3'], I['f5'], seed=int(x * 131 + y), where=forest & ~dark)")
s=s.replace("r = 2.2 + 3.0 * (y / H) +","r = 2.8 + 3.5 * (y / H) +")
open('copies/c0007.py','w').write(s)
EOF
python3 copies/c0007.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
import sys; sys.path.insert(0,'src')
from PIL import Image; from sheet import zoom
im=Image.open('copies/c0007_ref_grid_small.png'); c=im.crop((104,18,176,78)); c.save('copies/p1_ref.png'); zoom(c,8).save('(manager scratchpad)/p1.png')
pl=Image.open('plates/lv/C0007_bg_in.png'); s=pl.width/176; pl.crop((int(104*s),int(18*s),int(176*s),int(78*s))).resize((576,480),Image.LANCZOS).save('(manager scratchpad)/p1full.png')"

# output:
(Bash completed with no output)

"""Passage copy P1: broadleaf crowns seen from slightly above (C-0007 right side), 72x60 px.

What his crowns are made of (looked at in plates/lv/C0007_bg_in.png at full size):
  - flat lit PLATES: leafy wedges laid by the flat brush, wider than tall, with a serrated top edge
    (1-px teeth) and a lighter lip along that top edge;
  - each plate sits over a DARK POCKET (the shadow cast by the plate into the crown below);
  - plates stack in tiers, lower ones wider; between trees, big dark holes stay unpainted-dark;
  - one bush is stippled: yellow-green dots on dark (a different species, a point).
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter, maximum_filter
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab
from copykit import Canvas, majority


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(d1=c(0.20, 0.03, 165), d2=c(0.30, 0.05, 150), m1=c(0.42, 0.085, 138), m2=c(0.53, 0.11, 132),
         l1=c(0.63, 0.14, 128), l2=c(0.72, 0.16, 124), l3=c(0.81, 0.17, 118), y1=c(0.78, 0.15, 105),
         mead=c(0.66, 0.14, 125), meadl=c(0.76, 0.15, 118), ochre=c(0.70, 0.10, 85))
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])


def plate(cv, x, y, w, h, body, lip, pocket, seed=0, where=None):
    """a flat lit plate: width w, height h, serrated top, lighter lip, dark pocket below."""
    r = np.random.default_rng(seed)
    H, W = cv.a.shape
    x0, x1 = int(round(x - w / 2)), int(round(x + w / 2))
    # top edge: a shallow arch with 1-px teeth
    for xx in range(x0, x1 + 1):
        if not (0 <= xx < W):
            continue
        t = (xx - x) / (w / 2 + 1e-6)
        top = y - h * 0.5 * (1 - t * t) ** 0.5 + (r.integers(0, 2) if abs(t) < 0.95 else 1)
        bot = y + h * 0.5 * (1 - 0.3 * t * t)
        for yy in range(int(round(top)), int(round(bot)) + 1):
            if 0 <= yy < H and (where is None or where[yy, xx]):
                cv.a[yy, xx] = body
        yl = int(round(top))
        if 0 <= yl < H and (where is None or where[yl, xx]) and r.uniform() < 0.8:
            cv.a[yl, xx] = lip
        # pocket: 1-2 px below the plate, offset left (light from the upper right)
        for k in (1, 2):
            yp, xp = int(round(bot)) + k, xx - 1
            if 0 <= yp < H and 0 <= xp < W and (where is None or where[yp, xp]) and (k == 1 or r.uniform() < 0.5):
                cv.a[yp, xp] = pocket


def paint(ref_path=f'{ROOT}/copies/p1_ref.png', seed=1):
    ref = Image.open(ref_path).convert('RGB'); W, H = ref.size
    lab = rgb_to_oklab(np.asarray(ref, float) / 255); L = lab[..., 0]
    cv = Canvas(W, H, PAL, seed=seed)
    Ls = gaussian_filter(L, 1.2)
    # 1 the ground: three values, his notan, organised (smoothed) -> dark holes, mid crowns, open meadow
    q = np.quantile(Ls, [0.30, 0.62])
    cv.a[:] = np.where(Ls < q[0], I['d1'], np.where(Ls < q[1], I['m1'], I['m2']))
    hue = np.degrees(np.arctan2(lab[..., 2], lab[..., 1])) % 360
    meadow = gaussian_filter((hue < 122).astype(float), 1.5) > 0.5
    cv.a[meadow & (Ls > q[1])] = I['mead']
    cv.a = majority(cv.a, 2)
    cv.snapshot('1 ground: notan, 3 values')
    # 2 the second dark: pockets inside the mid masses where he is darker
    Lf = gaussian_filter(L, 0.6)
    cv.a[(cv.a == I['m1']) & (Lf < np.quantile(L, 0.4))] = I['d2']
    cv.snapshot('2 second dark')
    # 3 plates at his lit maxima, far (top) to near (bottom); size grows downward
    Lp = gaussian_filter(L, 0.8)
    pk = (Lp == maximum_filter(Lp, 5)) & (Lp > np.quantile(Lp, 0.5)) & ~meadow
    ys, xs = np.nonzero(pk)
    for k in np.argsort(ys):
        x, y = xs[k], ys[k]
        v = Lp[y, x]
        w = 5 + 4 * y / H + (2 if v > np.quantile(Lp, 0.85) else 0)
        body = I['l2'] if v > np.quantile(Lp, 0.82) else I['l1']
        lip = I['l3'] if body == I['l2'] else I['l2']
        plate(cv, x, y, w, 2.2 + 1.5 * y / H, body, lip, I['d2'], seed=int(x * 97 + y))
    cv.snapshot('3 lit plates with lips and pockets')
    # 4 the stippled bush: yellow dots where his yellow is
    yel = (hue < 112) & (L > 0.5) & ~meadow & (np.hypot(lab[..., 1], lab[..., 2]) > 0.1)
    ys, xs = np.nonzero(yel)
    for x, y in zip(xs, ys):
        cv.put(x, y, I['y1'])
    cv.snapshot('4 points: yellow stipple')
    return cv, ref


if __name__ == '__main__':
    from sheet import zoom, grid
    cv, ref = paint()
    cells = [zoom(ref, 8)] + [zoom(cv.pal[a], 8) for _, a in cv.stages]
    grid(cells, 3, ['his, reduced'] + [n for n, _ in cv.stages], title='P1 broadleaf crowns (C-0007), 8x').save(f'{ROOT}/sheets/p1_foliage.png')

cd ~/work/pixelart-studies/books/oga && python3 copies/p1_foliage.py

# output:
Exit code 1
~/work/pixelart-studies/books/oga/copies/p1_foliage.py:40: RuntimeWarning: invalid value encountered in scalar power
  top = y - h * 0.5 * (1 - t * t) ** 0.5 + (r.integers(0, 2) if abs(t) < 0.95 else 1)
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/copies/p1_foliage.py", line 95, in <module>
    cv, ref = paint()
              ^^^^^^^
  File "~/work/pixelart-studies/books/oga/copies/p1_foliage.py", line 82, in paint
    plate(cv, x, y, w, 2.2 + 1.5 * y / H, body, lip, I['d2'], seed=int(x * 97 + y))
  File "~/work/pixelart-studies/books/oga/copies/p1_foliage.py", line 42, in plate
    for yy in range(int(round(top)), int(round(bot)) + 1):
                        ^^^^^^^^^^
ValueError: cannot convert float NaN to integer

cd ~/work/pixelart-studies/books/oga && sed -i '' 's/        t = (xx - x) \/ (w \/ 2 + 1e-6)/        t = float(np.clip((xx - x) \/ (w \/ 2 + 1e-6), -1, 1))/' copies/p1_foliage.py && python3 copies/p1_foliage.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p1_foliage.py').read()
a=s.index("    # 3 plates at his lit maxima"); b=s.index("    # 4 the stippled bush")
s=s[:a]+'''    # 3 the lit sheets: his lit shapes, organised, as flat sheets of two lits
    lit = (gaussian_filter(L, 0.9) > np.quantile(L, 0.62)) & ~meadow
    cv.a[lit] = I['l1']
    cv.a[lit & (gaussian_filter(L, 0.9) > np.quantile(L, 0.84))] = I['l2']
    cv.a = majority(cv.a, 1)
    cv.snapshot('3 lit sheets (flat, 2 values)')
    # 4 the leafy edge: where a lit sheet meets a darker pixel below, teeth hang down on alternate
    #   columns (the serrated leaf edge); where it meets dark above-right, a light lip (the sun side)
    a = cv.a.copy()
    islit = np.isin(a, [I['l1'], I['l2']])
    isdark = np.isin(a, [I['d1'], I['d2'], I['m1']])
    r = np.random.default_rng(seed)
    for y in range(H - 1):
        for x in range(W):
            if islit[y, x] and isdark[y + 1, x] and ((x + (y // 2)) % 2 == 0 or r.uniform() < 0.25):
                cv.a[y + 1, x] = a[y, x]                       # tooth
                if y + 2 < H and r.uniform() < 0.3:
                    cv.a[y + 2, x] = a[y, x]
            if y > 0 and x < W - 1 and islit[y, x] and (isdark[y - 1, x] or isdark[y - 1, x + 1]):
                cv.a[y, x] = I['l3'] if a[y, x] == I['l2'] else I['l2']   # lip on the lit top edge
            if islit[y, x] and y > 0 and isdark[y - 1, x] and r.uniform() < 0.18:
                cv.a[y - 1, x] = I['l1']                       # a leaf breaking out above
    cv.snapshot('4 leafy edges: teeth below, lips above')
'''+s[b:]
open('copies/p1_foliage.py','w').write(s)
EOF
python3 copies/p1_foliage.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p1_foliage.py').read()
s=s.replace("l1=c(0.63, 0.14, 128), l2=c(0.72, 0.16, 124), l3=c(0.81, 0.17, 118)","l1=c(0.58, 0.13, 130), l2=c(0.66, 0.145, 126), l3=c(0.75, 0.16, 120)")
s=s.replace("lit = (gaussian_filter(L, 0.9) > np.quantile(L, 0.62)) & ~meadow","lit = (gaussian_filter(L, 0.9) > np.quantile(L, 0.68)) & ~meadow")
s=s.replace("if y > 0 and x < W - 1 and islit[y, x] and (isdark[y - 1, x] or isdark[y - 1, x + 1]):",
            "if y > 0 and x < W - 1 and islit[y, x] and isdark[y - 1, x + 1] and isdark[y, x + 1] and r.uniform() < 0.7:")
s=s.replace("    cv.snapshot('4 leafy edges: teeth below, lips above')","""    # holes: dark leaf gaps inside the lit sheets, more on the side away from the sun
    from scipy.ndimage import distance_transform_edt
    islit2 = np.isin(cv.a, [I['l1'], I['l2']])
    dd = distance_transform_edt(islit2)
    gap = islit2 & (dd >= 2) & (r.uniform(size=(H, W)) < 0.07)
    cv.a[gap] = I['m1']
    cv.snapshot('4 leafy edges: teeth below, sun-side lips, leaf gaps')""")
open('copies/p1_foliage.py','w').write(s)
EOF
python3 copies/p1_foliage.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p1_foliage.py').read()
s=s.replace("    gap = islit2 & (dd >= 2) & (r.uniform(size=(H, W)) < 0.07)\n    cv.a[gap] = I['m1']\n","")
s=s.replace("sun-side lips, leaf gaps","sun-side lips")
s=s.replace("""    cells = [zoom(ref, 8)] + [zoom(cv.pal[a], 8) for _, a in cv.stages]
    grid(cells, 3, ['his, reduced'] + [n for n, _ in cv.stages], title='P1 broadleaf crowns (C-0007), 8x').save(f'{ROOT}/sheets/p1_foliage.png')""",
"""    cells = [zoom(ref, 8)] + [zoom(cv.pal[a], 8) for _, a in cv.stages]
    grid(cells, 3, ['his, reduced'] + [n for n, _ in cv.stages], title='P1 broadleaf crowns (C-0007), 8x').save(f'{ROOT}/sheets/p1_foliage.png')
    grid([zoom(ref, 2), zoom(cv.rgb(), 2), zoom(ref, 1), zoom(cv.rgb(), 1)], 4, ['his 2x', 'mine 2x', '1x', '1x'], title='P1 at viewing size').save(f'{ROOT}/sheets/p1_foliage_2x.png')""")
open('copies/p1_foliage.py','w').write(s)
EOF
python3 copies/p1_foliage.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p1_foliage.py').read()
a=s.index("    # 3 the lit sheets"); b=s.index("    # 4 the stippled bush")
s=s[:a]+'''    # 3 the members: each crown found as a basin of his smoothed brightness (watershed), then painted
    #   as he paints a crown: lit sheet on the sun side (upper right) with a serrated edge where it
    #   turns into the crown's own shadow, the shadow body, a dark pocket where it tucks under.
    from skimage.segmentation import watershed
    from skimage.feature import peak_local_max
    Lw = gaussian_filter(L, 1.3)
    fg = (Lw > np.quantile(Lw, 0.35)) & ~meadow
    pk = peak_local_max(Lw, min_distance=4, labels=fg.astype(int))
    mk = np.zeros((H, W), int)
    for i, (y, x) in enumerate(pk):
        mk[y, x] = i + 1
    seg = watershed(-Lw, mk, mask=fg)
    yy, xx = np.mgrid[0:H, 0:W]
    r = np.random.default_rng(seed)
    order = sorted(range(1, seg.max() + 1), key=lambda i: yy[seg == i].mean() if (seg == i).any() else 0)
    for i in order:
        m = seg == i
        if m.sum() < 6:
            continue
        cy, cx = yy[m].mean(), xx[m].mean()
        ry = max(yy[m].std(), 1.0); rx = max(xx[m].std(), 1.0)
        u = (xx - cx) / rx; v = (yy - cy) / ry
        f = 0.6 * u - 0.8 * v + 0.35 * r.standard_normal((H, W)) * 0.4    # sun from upper right
        vtop = Lw[m].mean()
        bright = vtop > np.quantile(Lw[fg], 0.6)
        cv.a[m] = I['m1'] if not bright else I['m2']
        litm = m & (f > (-0.1 if bright else 0.5))
        # serrated edge: dither the boundary on alternate columns
        edge = litm & ~np.roll(litm, -1, 0)
        cv.a[litm] = I['l2'] if bright else I['l1']
        cv.a[litm & (f > 1.1)] = I['l3'] if bright else I['l2']
        teeth = np.roll(edge, 1, 0) & m & ((xx + yy // 3) % 2 == 0)
        cv.a[teeth] = I['l2'] if bright else I['l1']
        # pocket: lower-left rim of the member
        pocket = m & (f < -1.2)
        cv.a[pocket] = I['d2']
    cv.snapshot('3 members: each crown lit on its sun side, serrated turn, pocket')
'''+s[b:]
# drop old step 4 edges if present
a=s.find("    # 4 the leafy edge"); b=s.find("    # 4 the stippled bush")
if a!=-1: s=s[:a]+s[b:]
open('copies/p1_foliage.py','w').write(s)
EOF
python3 copies/p1_foliage.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p1_foliage.py').read()
s=s.replace("""        m = seg == i
        if m.sum() < 6:
            continue""","""        m0 = seg == i
        if m0.sum() < 6:
            continue
        # round the member (a crown is a rounded mass, not a Voronoi cell), swell it a little so it
        # overlaps the member behind, and break its outline with 1-px leaf notches
        m = (gaussian_filter(m0.astype(float), 1.1) + 0.12 * r.standard_normal((H, W))) > 0.38
        m &= fg | m0""")
open('copies/p1_foliage.py','w').write(s)
EOF
python3 copies/p1_foliage.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
import sys; sys.path.insert(0,'src')
from PIL import Image; from sheet import zoom
im=Image.open('copies/cover_ref_grid_small.png'); c=im.crop((68,40,128,124)); c.save('copies/p2_ref.png'); zoom(c,8).save('(manager scratchpad)/p2.png')"

# output:
(Bash completed with no output)

"""Passage copy P2: the far peak in mist, from the cover (steps 5-6), 60x84 px.

What he does (steps 5-6, p.7-8, and the finished cover):
  - the peak is painted INTO the wet sky with the sky's own colours: its greys are the mist greys,
    one step darker for the shading;
  - two layers (the upper peak, the lower conifer ridge) overlap with a tongue of mist between;
    the upper, farther one is paler and bluer (aerial perspective, p.54);
  - the conifers are made by the flat brush shifted vertically: vertical dashes, staggered,
    tips breaking the ridge line upward;
  - the foot of each layer dissolves into mist: no bottom edge, the value lifts to white in tongues.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab
from copykit import Canvas, majority


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(paper=c(1.0, 0, 0), mist=c(0.955, 0.01, 225), g0=c(0.90, 0.015, 215), g1=c(0.84, 0.02, 210),
         g2=c(0.78, 0.025, 205), g3=c(0.72, 0.03, 195), g4=c(0.65, 0.035, 185),
         v1=c(0.62, 0.06, 160), v2=c(0.52, 0.07, 155), v3=c(0.44, 0.06, 158), rose=c(0.80, 0.03, 40))
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])


def paint(ref_path=f'{ROOT}/copies/p2_ref.png', seed=4):
    ref = Image.open(ref_path).convert('RGB'); W, H = ref.size
    lab = rgb_to_oklab(np.asarray(ref, float) / 255); L = lab[..., 0]
    C = np.hypot(lab[..., 1], lab[..., 2]); hue = np.degrees(np.arctan2(lab[..., 2], lab[..., 1])) % 360
    cv = Canvas(W, H, PAL, bg=I['paper'], seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]
    Ls = gaussian_filter(L, 0.8)
    # 5 sky: white, mist worked in where he is not pure white
    cv.a[Ls < 0.985] = I['mist']
    cv.snapshot('5 sky: white, mist worked in')
    # 6a the two layers as flat masses (his silhouette), mist tongue between (hand line)
    body = Ls < 0.93
    split = (yy - (31 + 0.12 * (xx - 20))) > 0              # the mist tongue line under the upper peak
    upper = body & ~split
    lower = body & split
    cv.a[upper] = I['g1']
    cv.a[lower] = I['g2']
    cv.snapshot('6a two layers, flat: upper paler, lower darker')
    # 6b one step darker for the shading: his value design inside each layer, organised
    for m, a, b in ((upper, 'g1', 'g2'), (lower, 'g2', 'g3')):
        t = np.quantile(Ls[m], 0.45)
        cv.a[m & (Ls < t)] = I[b]
    cv.a[lower & (Ls < np.quantile(Ls[lower], 0.15))] = I['g4']
    # the foot dissolves: toward the mist, lift to g0/mist in ragged tongues (his light areas)
    n = cv.noise(0.9)
    for m in (upper, lower):
        cv.a[m & (Ls + 0.012 * n > 0.885)] = I['g0']
        cv.a[m & (Ls + 0.012 * n > 0.915)] = I['mist']
    cv.a = majority(cv.a, 1)
    cv.snapshot('6b one step darker; feet dissolve into mist')
    # 6c conifers: the flat brush shifted vertically. along the lower ridge top: tips break upward;
    #    inside: rows of short vertical dashes one step darker, staggered
    top = np.array([np.argmax(lower[:, x]) if lower[:, x].any() else -1 for x in range(W)])
    r = np.random.default_rng(seed)
    for x in range(W):
        if top[x] <= 0:
            continue
        if r.uniform() < 0.65:
            for k in range(r.integers(1, 4)):
                cv.put(x, top[x] - k, I['g3'])
    for row in range(0, H, 3):
        for x in range(W):
            y = row + (x % 2) + r.integers(0, 2)
            if 0 <= y < H and lower[y, x] and (r.uniform() < 0.35):
                L0 = r.integers(1, 3)
                dk = I['g4'] if cv.a[y, x] in (I['g3'], I['g4']) else I['g3']
                for k in range(L0):
                    if y + k < H and lower[y + k, x] and cv.a[y + k, x] not in (I['g0'], I['mist']):
                        cv.a[y + k, x] = dk
    # the upper peak: sparser, paler staggers along its ridge (farther away)
    topu = np.array([np.argmax(upper[:, x]) if upper[:, x].any() else -1 for x in range(W)])
    for x in range(0, W, 2):
        if topu[x] > 0 and r.uniform() < 0.5:
            for k in range(r.integers(1, 3)):
                cv.put(x, topu[x] + k, I['g2'])
    cv.snapshot('6c conifers: flat brush staggered, tips break the ridge')
    # the green patch where his colour is green, with its own staggered dark
    green = gaussian_filter(((hue > 140) & (hue < 175) & (C > 0.03)).astype(float), 0.8) > 0.5
    cv.a[green] = I['v1']
    cv.a[green & (Ls < np.quantile(Ls[green], 0.5))] = I['v2']
    for x in range(W):
        for y in range(H):
            if green[y, x] and (x + y * 3) % 5 == 0 and r.uniform() < 0.6:
                cv.put(x, y, I['v3']); cv.put(x, y + 1, I['v3'])
    # the pink rock at the bottom right (his warm accent)
    rose = gaussian_filter(((hue < 80) & (L > 0.7) & (yy > 60)).astype(float), 1.0) > 0.5
    cv.a[rose] = I['rose']
    cv.snapshot('green patch, warm rock')
    return cv, ref


if __name__ == '__main__':
    from sheet import zoom, grid
    cv, ref = paint()
    cells = [zoom(ref, 6)] + [zoom(cv.pal[a], 6) for _, a in cv.stages]
    grid(cells, 4, ['his, reduced'] + [n for n, _ in cv.stages], title='P2 far peak in mist (cover), 6x').save(f'{ROOT}/sheets/p2_peak.png')

cd ~/work/pixelart-studies/books/oga && python3 copies/p2_peak.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p2_peak.py').read()
s=s.replace("body = Ls < 0.93","body = Ls < 0.905")
s=s.replace("split = (yy - (31 + 0.12 * (xx - 20))) > 0","split = (yy - (33 + 0.1 * (xx - 20))) > 0")
s=s.replace("            if 0 <= y < H and lower[y, x] and (r.uniform() < 0.35):","            if 0 <= y < H and lower[y, x] and cv.a[y, x] in (I['g3'], I['g4']) and (r.uniform() < 0.45):")
s=s.replace("            if green[y, x] and (x + y * 3) % 5 == 0 and r.uniform() < 0.6:","            if green[y, x] and r.uniform() < 0.14:")
s=s.replace("rose = gaussian_filter(((hue < 80) & (L > 0.7) & (yy > 60)).astype(float), 1.0) > 0.5","rose = gaussian_filter(((hue < 90) & (L > 0.66) & (yy > 60) & (C > 0.015)).astype(float), 1.5) > 0.4")
open('copies/p2_peak.py','w').write(s)
EOF
python3 copies/p2_peak.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
import sys; sys.path.insert(0,'src'); import numpy as np
from PIL import Image; from okl import *
a=np.asarray(Image.open('copies/p2_ref.png').convert('RGB'),float)/255; l=lab_to_lch(rgb_to_oklab(a))
for (x,y) in [(50,75),(55,70),(45,80),(10,70),(15,60),(20,50),(30,20)]: print((x,y), l[y,x,0].round(2), l[y,x,1].round(3), (np.degrees(l[y,x,2])%360).round(0))"

# output:
(50, 75) 0.74 0.003 49.0
(55, 70) 0.69 0.028 109.0
(45, 80) 0.75 0.014 78.0
(10, 70) 0.9 0.019 222.0
(15, 60) 0.75 0.023 193.0
(20, 50) 0.71 0.025 190.0
(30, 20) 0.78 0.032 235.0

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p2_peak.py').read()
s=s.replace("rose=c(0.80, 0.03, 40))","rose=c(0.80, 0.03, 40), rose2=c(0.70, 0.03, 35), lav1=c(0.86, 0.022, 300), lav2=c(0.79, 0.026, 300))")
s=s.replace("""    rose = gaussian_filter(((hue < 90) & (L > 0.66) & (yy > 60) & (C > 0.015)).astype(float), 1.5) > 0.4
    cv.a[rose] = I['rose']""","""    rose = cv.mask_poly([(40, 84), (41, 73), (45, 67), (52, 63), (60, 61), (60, 84)])
    cv.a[rose] = I['rose']
    cv.split(rose, (40, 70), (60, 84), I['rose2'], wet=0.8)
    # coloured greys: the mist-wrapped lower left goes lavender (his greys are never one hue)
    zone = (xx < 30) & (yy > 44)
    cv.a[zone & (cv.a == I['g1'])] = I['lav1']
    cv.a[zone & (cv.a == I['g2'])] = I['lav2']""")
open('copies/p2_peak.py','w').write(s)
EOF
python3 copies/p2_peak.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p2_peak.py').read()
s=s.replace("    cv.split(rose, (40, 70), (60, 84), I['rose2'], wet=0.8)","""    cv.a[rose & (Ls < np.quantile(Ls[rose], 0.45))] = I['rose2']
    cv.mottle(rose, I['rose2'], share=0.15, scale=0.8)
    cv.line([(46, 70), (49, 75), (48, 80)], I['g4']); cv.line([(53, 66), (55, 72)], I['g4'])""")
s=s.replace("    zone = (xx < 30) & (yy > 44)","    nz = cv.noise(1.5)\n    zone = (xx + 4 * nz < 30) & (yy + 3 * nz > 46)")
open('copies/p2_peak.py','w').write(s)
EOF
python3 copies/p2_peak.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
import sys; sys.path.insert(0,'src')
from PIL import Image; from sheet import zoom
im=Image.open('copies/cover_ref_grid_small.png'); c=im.crop((0,150,72,240)); c.save('copies/p3_ref.png'); zoom(c,7).save('(manager scratchpad)/p3.png')"

# output:
(Bash completed with no output)

"""Passage copy P3: the near rocks of the cover (steps 7, 10, 11), 72x90 px. Painted entirely by hand.

What he does:
  - a rock is two or three PLANES, decided by lines: the top plane takes the sky light (pale lavender,
    pinkish where warm), the faces are in shadow (warm dark olive-brown, never a lowered grey);
  - the shadow face is uneven paint (塗りムラ): greener and browner patches, a few lichen dots;
  - on the edge where the lit top turns into the shadow face on the far side, a hard line of pure
    cobalt: the sky's colour at the edge of the light (際, p.56) — the cover's signature;
  - brush direction on the lit plane follows the plane (streaks along it, step 11 "raise the texture").
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from okl import lch_to_lab, oklab_to_rgb
from copykit import Canvas


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(paper=c(1.0, 0, 0), airy=c(0.86, 0.05, 125), airy2=c(0.76, 0.07, 125),
         top1=c(0.86, 0.025, 330), top2=c(0.77, 0.035, 300), top3=c(0.68, 0.03, 290), warm=c(0.80, 0.04, 50),
         rim=c(0.55, 0.17, 268),
         s1=c(0.45, 0.03, 75), s2=c(0.37, 0.028, 85), s3=c(0.30, 0.025, 95), s4=c(0.23, 0.018, 110), sg=c(0.38, 0.04, 140),
         lich=c(0.72, 0.10, 90), gr1=c(0.55, 0.10, 125), gr2=c(0.70, 0.13, 115), gr3=c(0.84, 0.15, 105), crack=c(0.18, 0.015, 120))
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])
W, H = 72, 90


def rock(cv, outline, top, rim=None, top_idx='top2', lit_first=True, seed=0):
    m = cv.mass(outline, I['s2'], wet=0.3)
    cv.mottle(m, I['s1'], 0.28, 1.6)
    cv.mottle(m, I['s3'], 0.30, 1.3)
    cv.mottle(m, I['sg'], 0.12, 1.2)
    cv.mottle(m, I['s4'], 0.10, 0.9)
    t = cv.mass(top, I[top_idx], wet=0.4, where=m) if top else None
    if t is not None:
        cv.mottle(t, I['top1'], 0.22, 1.0)
        cv.mottle(t, I['top3'], 0.18, 1.0)
    if rim:
        cv.line(rim, I['rim'])
    return m, t


def paint(seed=5):
    cv = Canvas(W, H, PAL, bg=I['paper'], seed=seed)
    # ground: airy shrubs top left against paper, grass band behind the rocks
    cv.mass([(0, 20), (10, 10), (24, 4), (40, 0), (72, 0), (72, 30), (40, 34), (0, 40)], I['airy'], wet=2.5, wet_scale=0.8)
    cv.mottle(cv.a == I['airy'], I['airy2'], 0.4, 1.0)
    cv.mass([(18, 34), (40, 28), (60, 34), (70, 46), (60, 56), (40, 50)], I['gr1'], wet=1.2)
    cv.snapshot('ground: airy shrubs, grass band')
    # the rocks, back to front
    rock(cv, [(22, 24), (30, 16), (40, 12), (46, 14), (44, 22), (34, 28), (24, 30)],
         [(22, 24), (30, 16), (40, 12), (46, 14), (42, 18), (32, 22), (24, 27)], rim=[(40, 12), (46, 14)], top_idx='top1')
    rock(cv, [(54, 6), (64, 3), (72, 4), (72, 22), (60, 23), (53, 16)],
         [(54, 6), (64, 3), (72, 4), (72, 7), (62, 7), (55, 9)], rim=[(58, 6), (64, 5), (72, 7)])
    rock(cv, [(52, 27), (61, 25), (67, 31), (66, 41), (57, 44), (51, 36)],
         [(52, 27), (61, 25), (66, 30), (58, 31), (53, 31)], rim=[(61, 25), (67, 31)])
    rock(cv, [(0, 28), (8, 25), (14, 26), (20, 30), (23, 35), (22, 45), (16, 53), (8, 58), (0, 62)],
         [(0, 28), (8, 25), (14, 26), (9, 30), (2, 33), (0, 35)], rim=[(14, 26), (18, 29), (22, 34)])
    mB, tB = rock(cv, [(0, 72), (10, 62), (22, 52), (32, 41), (38, 34), (46, 34), (53, 40), (59, 48), (65, 56),
                       (67, 70), (63, 90), (0, 90)],
                  [(0, 72), (10, 62), (22, 52), (32, 41), (38, 34), (42, 35), (36, 44), (26, 55), (15, 66), (5, 76), (0, 80)],
                  rim=[(46, 35), (53, 41), (60, 49)])
    cv.snapshot('rocks: planes by drawn lines, mottled shadow faces, cobalt rims')
    # plane texture: streaks along the top plane of B (brush follows the plane)
    for k in range(10):
        x0 = 2 + k * 3.6; y0 = 74 - k * 3.9
        cv.line([(x0, y0), (x0 + 3, y0 - 3)], I['top1'] if k % 2 else I['warm'])
    # crack between A and B, the dark tuck under the top plane
    cv.line([(0, 64), (8, 60), (16, 55), (22, 47)], I['crack'])
    cv.line([(4, 79), (14, 69), (24, 58), (34, 47), (40, 38)], I['s4'])
    cv.scatter_dabs(mB & ~tB, I['lich'], 6, shapes=('dot', 'h2'), seed=seed)
    cv.snapshot('plane streaks, crack, lichen')
    # grass tufts between the rocks: blades with lemon tips
    r = np.random.default_rng(seed)
    for i in range(22):
        x = int(r.uniform(24, 62)); y = int(r.uniform(30, 48))
        cv.blade(x, y, I['gr2'], length=int(r.integers(2, 5)), lean=r.choice([-0.4, 0, 0.4]), tip=I['gr3'])
    cv.snapshot('grass tufts, lemon tips')
    return cv


if __name__ == '__main__':
    from sheet import zoom, grid
    cv = paint()
    ref = Image.open(f'{ROOT}/copies/p3_ref.png')
    cells = [zoom(ref, 5)] + [zoom(cv.pal[a], 5) for _, a in cv.stages] + [zoom(ref, 2), zoom(cv.rgb(), 2)]
    grid(cells, 5, ['his, reduced'] + [n for n, _ in cv.stages] + ['his 2x', 'mine 2x'], title='P3 near rocks (cover), 5x').save(f'{ROOT}/sheets/p3_rocks.png')

cd ~/work/pixelart-studies/books/oga && python3 copies/p3_rocks.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p3_rocks.py').read()
s=s.replace("""    cv.mottle(m, I['s1'], 0.28, 1.6)
    cv.mottle(m, I['s3'], 0.30, 1.3)
    cv.mottle(m, I['sg'], 0.12, 1.2)
    cv.mottle(m, I['s4'], 0.10, 0.9)""","""    # broad uneven paint: a few big soft patches, darker toward the bottom (where it tucks in)
    yy = np.mgrid[0:cv.H, 0:cv.W][0]
    cv.mottle(m, I['s1'], 0.25, 3.0)
    cv.mottle(m, I['sg'], 0.15, 3.5)
    lowm = m & (yy > np.quantile(yy[m], 0.7))
    cv.mottle(lowm, I['s3'], 0.6, 2.5)""")
s=s.replace("""        cv.mottle(t, I['top1'], 0.22, 1.0)
        cv.mottle(t, I['top3'], 0.18, 1.0)""","""        cv.mottle(t, I['top1'], 0.25, 2.0)
        cv.mottle(t, I['top3'], 0.15, 2.0)""")
s=s.replace("""    cv.mass([(18, 34), (40, 28), (60, 34), (70, 46), (60, 56), (40, 50)], I['gr1'], wet=1.2)""",
"""    cv.mass([(0, 44), (18, 34), (40, 28), (60, 30), (72, 34), (72, 90), (0, 90)], I['s3'], wet=1.0)   # dark earth under everything
    cv.mass([(18, 34), (40, 28), (60, 34), (70, 46), (60, 56), (40, 50)], I['gr1'], wet=1.2)""")
s=s.replace("[(0, 72), (10, 62), (22, 52), (32, 41), (38, 34), (42, 35), (36, 44), (26, 55), (15, 66), (5, 76), (0, 80)]",
            "[(0, 70), (10, 60), (22, 50), (32, 39), (38, 34), (44, 36), (38, 47), (28, 59), (17, 71), (7, 82), (0, 88)]")
s=s.replace("mB, tB = rock(cv, [(0, 72), (10, 62), (22, 52), (32, 41),","mB, tB = rock(cv, [(0, 64), (10, 60), (22, 50), (32, 39),")
s=s.replace("""        x0 = 2 + k * 3.6; y0 = 74 - k * 3.9
        cv.line([(x0, y0), (x0 + 3, y0 - 3)], I['top1'] if k % 2 else I['warm'])""","""        x0 = 3 + k * 3.6; y0 = 76 - k * 3.9
        cv.line([(x0, y0), (x0 + 4, y0 - 4)], I['top1'] if k % 2 else I['warm'])""")
s=s.replace("cv.line([(4, 79), (14, 69), (24, 58), (34, 47), (40, 38)], I['s4'])","cv.line([(7, 83), (17, 72), (28, 60), (38, 48), (44, 37)], I['s4'])")
open('copies/p3_rocks.py','w').write(s)
EOF
python3 copies/p3_rocks.py

# output:
(Bash completed with no output)

"""Passage copy P1 (v2): broadleaf crowns seen from slightly above (C-0007 right side), 72x60 px.

Critic's read of v1: "sawtooth scales, one cool green family, dead flat darks: the material is
wrong". His crowns are ROUNDED LEAF-CLUMPS with dark holes between them, lit warm (ochre-yellow)
on top, near-black olive in the holes, and the darks still hold dim clumps one value up.

So the vocabulary here is one mark, the clump, drawn at three light levels:
  lit clump : rounded 3-6 px, convex bumps on its upper-right edge in a warm light, body in a warm
              olive-green, a 1-px dark crescent at lower left where it tucks under the next
  mid clump : the same shape one family down (the crown's turning side)
  dim clump : one value above the hole colour, inside the big darks
Placed where his painting has them (his smoothed brightness picks the level), far to near.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab
from copykit import Canvas, majority


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(hole=c(0.17, 0.03, 125), dim1=c(0.25, 0.04, 130), dim2=c(0.32, 0.055, 130),
         mid1=c(0.40, 0.075, 128), mid2=c(0.48, 0.095, 124),
         lit1=c(0.57, 0.12, 120), lit2=c(0.66, 0.135, 114), lit3=c(0.76, 0.14, 104), ochre=c(0.80, 0.13, 95),
         mead=c(0.66, 0.13, 118), meadl=c(0.75, 0.14, 110), path=c(0.72, 0.10, 80))
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])

LEVELS = {  # (cap, body, crescent)
    'lit': ('lit3', 'lit1', 'mid1'), 'lit+': ('ochre', 'lit2', 'mid1'),
    'mid': ('lit1', 'mid2', 'dim2'), 'dim': ('mid1', 'dim2', 'hole'),
}


def clump(cv, x, y, r, level, seed=0):
    """a rounded leaf-clump. r in px (1.5-3). Light from the upper right."""
    cap, body, cres = (I[k] for k in LEVELS[level])
    rr = np.random.default_rng(seed)
    R = int(np.ceil(r)) + 2
    tilt = rr.uniform(-0.25, 0.25)
    for dy in range(-R, R + 1):
        for dx in range(-R, R + 1):
            # slightly wide ellipse, random tilt, lumpy outline (2-3 px bumps)
            u, v = dx * np.cos(tilt) + dy * np.sin(tilt), -dx * np.sin(tilt) + dy * np.cos(tilt)
            ang = np.arctan2(v, u)
            rad = r * (1 + 0.18 * np.cos(3 * ang + seed) + 0.1 * np.cos(5 * ang + 2 * seed))
            d = np.hypot(u / 1.2, v) / rad
            if d > 1:
                continue
            X, Y = x + dx, y + dy
            s = (dx * 0.6 - dy * 0.8) / (r + 1e-6)          # toward the sun
            idx = body
            if s > 0.35 and d > 0.35:
                idx = cap
            elif s < -0.45 and d > 0.6:
                idx = cres
            cv.put(X, Y, idx)


def paint(ref_path=f'{ROOT}/copies/p1_ref.png', seed=1):
    ref = Image.open(ref_path).convert('RGB'); W, H = ref.size
    lab = rgb_to_oklab(np.asarray(ref, float) / 255); L = lab[..., 0]
    hue = np.degrees(np.arctan2(lab[..., 2], lab[..., 1])) % 360
    cv = Canvas(W, H, PAL, bg=I['hole'], seed=seed)
    Ls = gaussian_filter(L, 1.0)
    # ground: holes and crown masses (his notan, about half dark), open meadow
    q = np.quantile(Ls, [0.45, 0.72])
    cv.a[:] = np.where(Ls < q[0], I['hole'], np.where(Ls < q[1], I['dim2'], I['mid2']))
    meadow = gaussian_filter(((hue < 122) & (L > 0.55)).astype(float), 1.5) > 0.55
    cv.a[meadow] = I['mead']
    cv.a = majority(cv.a, 2)
    cv.snapshot('1 ground: holes (half), crown masses, meadow')
    # the crowd: clumps on a jittered grid, level from his brightness; far (top) to near (bottom)
    r = np.random.default_rng(seed)
    pts = []
    step = 3
    for y in range(0, H + 2, step):
        for x in range(-1, W + 2, step):
            xx = x + r.uniform(-1.2, 1.2) + (step / 2 if (y // step) % 2 else 0)
            yy_ = y + r.uniform(-1.0, 1.0)
            pts.append((xx, yy_))
    pts.sort(key=lambda p: p[1])
    qd, qm, ql, qp = np.quantile(Ls[~meadow], [0.30, 0.52, 0.72, 0.9])
    for (x, y) in pts:
        xi, yi = int(np.clip(round(x), 0, W - 1)), int(np.clip(round(y), 0, H - 1))
        if meadow[yi, xi]:
            continue
        v = Ls[yi, xi]
        if v < qd:
            if r.uniform() < 0.35:
                clump(cv, x, y, 1.6, 'dim', seed=int(x * 13 + y * 7))
            continue
        level = 'dim' if v < qm else ('mid' if v < ql else ('lit' if v < qp else 'lit+'))
        rad = 1.6 + 1.2 * (y / H) + (0.5 if level.startswith('lit') else 0)
        clump(cv, x, y, rad, level, seed=int(x * 13 + y * 7))
    cv.snapshot('2 the crowd: rounded clumps at four light levels')
    # points: sunflecks as 1-2 px dots on lit clump edges only (where his yellow is)
    yel = (hue < 112) & (L > 0.5) & ~meadow & (np.hypot(lab[..., 1], lab[..., 2]) > 0.1)
    ys, xs = np.nonzero(yel)
    for x, y in zip(xs, ys):
        if cv.a[y, x] in (I['lit1'], I['lit2'], I['lit3']):
            cv.put(x, y, I['ochre'])
    cv.snapshot('3 points: sunflecks on lit edges')
    return cv, ref


if __name__ == '__main__':
    from sheet import zoom, grid
    cv, ref = paint()
    cells = [zoom(ref, 8)] + [zoom(cv.pal[a], 8) for _, a in cv.stages]
    grid(cells, 2, ['his, reduced'] + [n for n, _ in cv.stages], title='P1 v2 broadleaf crowns (C-0007), 8x').save(f'{ROOT}/sheets/p1_foliage.png')
    grid([zoom(ref, 2), zoom(cv.rgb(), 2), zoom(ref, 1), zoom(cv.rgb(), 1)], 4, ['his 2x', 'mine 2x', '1x', '1x'], title='P1 at viewing size').save(f'{ROOT}/sheets/p1_foliage_2x.png')

cd ~/work/pixelart-studies/books/oga && cp copies/p1_foliage.py copies/p1_foliage_v1.py && head -3 copies/p1_foliage.py

# output:
"""Passage copy P1: broadleaf crowns seen from slightly above (C-0007 right side), 72x60 px.

What his crowns are made of (looked at in plates/lv/C0007_bg_in.png at full size):

"""Passage copy P1 (v2): broadleaf crowns seen from slightly above (C-0007 right side), 72x60 px.
(v1, with watershed members and sawtooth edges, is kept in p1_foliage_v1.py.)

Critic's read of v1: "sawtooth scales, one cool green family, dead flat darks: the material is
wrong". His crowns are ROUNDED LEAF-CLUMPS with dark holes between them, lit warm (ochre-yellow)
on top, near-black olive in the holes, and the darks still hold dim clumps one value up.

So the vocabulary here is one mark, the clump, drawn at four light levels:
  lit clump : rounded 3-6 px, convex bumps on its upper-right edge in a warm light, body in a warm
              olive-green, a 1-px dark crescent at lower left where it tucks under the next
  mid clump : the same shape one family down (the crown's turning side)
  dim clump : one value above the hole colour, inside the big darks
Placed where his painting has them (his smoothed brightness picks the level), far to near.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab
from copykit import Canvas, majority


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(hole=c(0.17, 0.03, 125), dim1=c(0.25, 0.04, 130), dim2=c(0.32, 0.055, 130),
         mid1=c(0.40, 0.075, 128), mid2=c(0.48, 0.095, 124),
         lit1=c(0.57, 0.12, 120), lit2=c(0.66, 0.135, 114), lit3=c(0.76, 0.14, 104), ochre=c(0.80, 0.13, 95),
         mead=c(0.66, 0.13, 118), meadl=c(0.75, 0.14, 110), path=c(0.72, 0.10, 80))
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])

LEVELS = {  # (cap, body, crescent)
    'lit': ('lit3', 'lit1', 'mid1'), 'lit+': ('ochre', 'lit2', 'mid1'),
    'mid': ('lit1', 'mid2', 'dim2'), 'dim': ('mid1', 'dim2', 'hole'),
}


def clump(cv, x, y, r, level, seed=0, pal_levels=None):
    """a rounded leaf-clump. r in px (1.5-3). Light from the upper right."""
    lv = (pal_levels or LEVELS)[level]
    cap, body, cres = (cv_index(cv, k) for k in lv)
    rr = np.random.default_rng(seed)
    R = int(np.ceil(r)) + 2
    tilt = rr.uniform(-0.25, 0.25)
    for dy in range(-R, R + 1):
        for dx in range(-R, R + 1):
            u, v = dx * np.cos(tilt) + dy * np.sin(tilt), -dx * np.sin(tilt) + dy * np.cos(tilt)
            ang = np.arctan2(v, u)
            rad = r * (1 + 0.18 * np.cos(3 * ang + seed) + 0.1 * np.cos(5 * ang + 2 * seed))
            d = np.hypot(u / 1.2, v) / rad
            if d > 1:
                continue
            s = (dx * 0.6 - dy * 0.8) / (r + 1e-6)
            idx = body
            if s > 0.35 and d > 0.35:
                idx = cap
            elif s < -0.45 and d > 0.6:
                idx = cres
            cv.put(x + dx, y + dy, idx)


def cv_index(cv, k):
    return cv.names[k] if hasattr(cv, 'names') else I[k]


def paint(ref_path=f'{ROOT}/copies/p1_ref.png', seed=1):
    ref = Image.open(ref_path).convert('RGB'); W, H = ref.size
    lab = rgb_to_oklab(np.asarray(ref, float) / 255); L = lab[..., 0]
    hue = np.degrees(np.arctan2(lab[..., 2], lab[..., 1])) % 360
    cv = Canvas(W, H, PAL, bg=I['hole'], seed=seed)
    Ls = gaussian_filter(L, 1.0)
    q = np.quantile(Ls, [0.45, 0.72])
    cv.a[:] = np.where(Ls < q[0], I['hole'], np.where(Ls < q[1], I['dim2'], I['mid2']))
    meadow = gaussian_filter(((hue < 122) & (L > 0.55)).astype(float), 1.5) > 0.55
    cv.a[meadow] = I['mead']
    cv.a = majority(cv.a, 2)
    cv.snapshot('1 ground: holes (half), crown masses, meadow')
    r = np.random.default_rng(seed)
    pts = []
    step = 3
    for y in range(0, H + 2, step):
        for x in range(-1, W + 2, step):
            pts.append((x + r.uniform(-1.2, 1.2) + (step / 2 if (y // step) % 2 else 0), y + r.uniform(-1.0, 1.0)))
    pts.sort(key=lambda p: p[1])
    qd, qm, ql, qp = np.quantile(Ls[~meadow], [0.30, 0.52, 0.72, 0.9])
    for (x, y) in pts:
        xi, yi = int(np.clip(round(x), 0, W - 1)), int(np.clip(round(y), 0, H - 1))
        if meadow[yi, xi]:
            continue
        v = Ls[yi, xi]
        if v < qd:
            if r.uniform() < 0.35:
                clump(cv, x, y, 1.6, 'dim', seed=int(x * 13 + y * 7))
            continue
        level = 'dim' if v < qm else ('mid' if v < ql else ('lit' if v < qp else 'lit+'))
        rad = 1.6 + 1.2 * (y / H) + (0.5 if level.startswith('lit') else 0)
        clump(cv, x, y, rad, level, seed=int(x * 13 + y * 7))
    cv.snapshot('2 the crowd: rounded clumps at four light levels')
    yel = (hue < 112) & (L > 0.5) & ~meadow & (np.hypot(lab[..., 1], lab[..., 2]) > 0.1)
    ys, xs = np.nonzero(yel)
    for x, y in zip(xs, ys):
        if cv.a[y, x] in (I['lit1'], I['lit2'], I['lit3']):
            cv.put(x, y, I['ochre'])
    cv.snapshot('3 points: sunflecks on lit edges')
    return cv, ref


if __name__ == '__main__':
    from sheet import zoom, grid
    cv, ref = paint()
    cells = [zoom(ref, 8)] + [zoom(cv.pal[a], 8) for _, a in cv.stages]
    grid(cells, 2, ['his, reduced'] + [n for n, _ in cv.stages], title='P1 v2 broadleaf crowns (C-0007), 8x').save(f'{ROOT}/sheets/p1_foliage.png')
    grid([zoom(ref, 2), zoom(cv.rgb(), 2), zoom(ref, 1), zoom(cv.rgb(), 1)], 4, ['his 2x', 'mine 2x', '1x', '1x'], title='P1 at viewing size').save(f'{ROOT}/sheets/p1_foliage_2x.png')

cd ~/work/pixelart-studies/books/oga && python3 copies/p1_foliage.py

# output:
Exit code 1
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/copies/p1_foliage.py", line 113, in <module>
    cv, ref = paint()
              ^^^^^^^
  File "~/work/pixelart-studies/books/oga/copies/p1_foliage.py", line 96, in paint
    clump(cv, x, y, 1.6, 'dim', seed=int(x * 13 + y * 7))
  File "~/work/pixelart-studies/books/oga/copies/p1_foliage.py", line 45, in clump
    rr = np.random.default_rng(seed)
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "numpy/random/_generator.pyx", line 4957, in numpy.random._generator.default_rng
  File "_pcg64.pyx", line 123, in numpy.random._pcg64.PCG64.__init__
  File "bit_generator.pyx", line 535, in numpy.random.bit_generator.BitGenerator.__init__
  File "bit_generator.pyx", line 315, in numpy.random.bit_generator.SeedSequence.__init__
  File "bit_generator.pyx", line 389, in numpy.random.bit_generator.SeedSequence.get_assembled_entropy
  File "bit_generator.pyx", line 140, in numpy.random.bit_generator._coerce_to_uint32_array
  File "bit_generator.pyx", line 70, in numpy.random.bit_generator._int_to_uint32_array
ValueError: expected non-negative integer

cd ~/work/pixelart-studies/books/oga && sed -i '' 's/    rr = np.random.default_rng(seed)\n    R = int/X/; s/    rr = np.random.default_rng(seed)$/    rr = np.random.default_rng(abs(int(seed)))/' copies/p1_foliage.py && python3 copies/p1_foliage.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p1_foliage.py').read()
s=s.replace("""    'lit': ('lit3', 'lit1', 'mid1'), 'lit+': ('ochre', 'lit2', 'mid1'),
    'mid': ('lit1', 'mid2', 'dim2'), 'dim': ('mid1', 'dim2', 'hole'),""","""    'lit': ('lit2', 'lit1', 'mid1'), 'lit+': ('lit3', 'lit2', 'mid1'),
    'mid': ('lit1', 'mid2', 'dim2'), 'dim': ('mid1', 'dim2', 'hole'),""")
s=s.replace("            if s > 0.35 and d > 0.35:","            if s > 0.5 and d > 0.45:")
s=s.replace("    step = 3\n","    step = 4\n")
s=s.replace("rad = 1.6 + 1.2 * (y / H) + (0.5 if level.startswith('lit') else 0)","rad = 2.2 + 1.4 * (y / H) + (0.4 if level.startswith('lit') else 0)")
s=s.replace("clump(cv, x, y, 1.6, 'dim',","clump(cv, x, y, 2.0, 'dim',")
s=s.replace("lit3=c(0.76, 0.14, 104), ochre=c(0.80, 0.13, 95)","lit3=c(0.74, 0.14, 108), ochre=c(0.80, 0.13, 95)")
open('copies/p1_foliage.py','w').write(s)
EOF
python3 copies/p1_foliage.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p1_foliage.py').read()
s=s.replace("mid1=c(0.40, 0.075, 128), mid2=c(0.48, 0.095, 124),\n         lit1=c(0.57, 0.12, 120), lit2=c(0.66, 0.135, 114), lit3=c(0.74, 0.14, 108)",
            "mid1=c(0.40, 0.08, 135), mid2=c(0.48, 0.10, 132),\n         lit1=c(0.57, 0.125, 130), lit2=c(0.65, 0.14, 126), lit3=c(0.74, 0.15, 116)")
open('copies/p1_foliage.py','w').write(s)
EOF
python3 copies/p1_foliage.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && sed -n 1,200p copies/p3_rocks.py | grep -n "def rock" -A 25 | head -40

# output:
33:def rock(cv, outline, top, rim=None, top_idx='top2', lit_first=True, seed=0):
34-    m = cv.mass(outline, I['s2'], wet=0.3)
35-    # broad uneven paint: a few big soft patches, darker toward the bottom (where it tucks in)
36-    yy = np.mgrid[0:cv.H, 0:cv.W][0]
37-    cv.mottle(m, I['s1'], 0.25, 3.0)
38-    cv.mottle(m, I['sg'], 0.15, 3.5)
39-    lowm = m & (yy > np.quantile(yy[m], 0.7))
40-    cv.mottle(lowm, I['s3'], 0.6, 2.5)
41-    t = cv.mass(top, I[top_idx], wet=0.4, where=m) if top else None
42-    if t is not None:
43-        cv.mottle(t, I['top1'], 0.25, 2.0)
44-        cv.mottle(t, I['top3'], 0.15, 2.0)
45-    if rim:
46-        cv.line(rim, I['rim'])
47-    return m, t
48-
49-
50-def paint(seed=5):
51-    cv = Canvas(W, H, PAL, bg=I['paper'], seed=seed)
52-    # ground: airy shrubs top left against paper, grass band behind the rocks
53-    cv.mass([(0, 20), (10, 10), (24, 4), (40, 0), (72, 0), (72, 30), (40, 34), (0, 40)], I['airy'], wet=2.5, wet_scale=0.8)
54-    cv.mottle(cv.a == I['airy'], I['airy2'], 0.4, 1.0)
55-    cv.mass([(0, 44), (18, 34), (40, 28), (60, 30), (72, 34), (72, 90), (0, 90)], I['s3'], wet=1.0)   # dark earth under everything
56-    cv.mass([(18, 34), (40, 28), (60, 34), (70, 46), (60, 56), (40, 50)], I['gr1'], wet=1.2)
57-    cv.snapshot('ground: airy shrubs, grass band')
58-    # the rocks, back to front

"""Passage copy P3 (v2): the near rocks of the cover (steps 7, 10, 11), 72x90 px. Painted by hand.

What he does:
  - a rock is two or three PLANES, decided by lines: the top plane takes the sky light (pale lavender-
    pink, warmer and lighter at its upper edge, darker toward its lower end), the faces are in shadow
    (warm dark olive-brown, never a lowered grey);
  - faces turned up take cool green-grey reflected light (p.56: reflected light takes the sky's
    colour, loosened with the object's own colour); faces turned down stay the darkest;
  - on the edge where the lit top turns into the shadow face on the far side, a hard line of pure
    cobalt: the sky's colour at the edge of the light (際) — the cover's signature;
  - brush direction on the lit plane follows the plane.
v1 -> v2 after a cold critique: clean 1:1 slab edges, warm slab ramp, facets instead of camo blobs,
continuous crack, olive shrub masses with sky holes, yellow in two clusters.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from okl import lch_to_lab, oklab_to_rgb
from copykit import Canvas


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(paper=c(1.0, 0, 0), ol1=c(0.50, 0.07, 122), ol2=c(0.62, 0.09, 118), ol3=c(0.74, 0.10, 112), ol0=c(0.40, 0.05, 125),
         top1=c(0.87, 0.035, 25), top2=c(0.77, 0.035, 330), top3=c(0.67, 0.035, 305), warm=c(0.82, 0.05, 55),
         rim=c(0.55, 0.17, 268),
         s1=c(0.44, 0.035, 70), s2=c(0.36, 0.03, 80), s3=c(0.29, 0.025, 95), s4=c(0.22, 0.02, 110),
         refl=c(0.44, 0.035, 170), refl2=c(0.50, 0.03, 190),
         lich=c(0.74, 0.11, 92), gr1=c(0.52, 0.10, 125), gr2=c(0.68, 0.13, 115), yel=c(0.84, 0.15, 102), crack=c(0.16, 0.015, 120))
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])
W, H = 72, 90


def facets(cv, outline, faces, base='s2', seed=0):
    """a rock: outline filled with the base shadow colour, then facet polygons, each one flat."""
    m = cv.mass(outline, I[base], wet=0.0)
    for poly, idx in faces:
        cv.mass(poly, I[idx], wet=0.0, where=m)
    return m


def paint(seed=5):
    cv = Canvas(W, H, PAL, bg=I['paper'], seed=seed)
    # ---- ground: olive shrub masses with sky holes against the paper; dark earth; grass band
    for poly in ([(0, 30), (4, 18), (12, 12), (20, 14), (22, 26), (12, 34)], [(18, 12), (28, 4), (38, 6), (40, 16), (30, 22), (22, 20)],
                 [(36, 4), (46, 0), (56, 2), (58, 10), (48, 14), (40, 12)], [(52, 0), (72, 0), (72, 10), (60, 12)]):
        m = cv.mass(poly, I['ol1'], wet=1.5, wet_scale=0.7)
        cv.mottle(m, I['ol2'], 0.35, 1.2)
        cv.mottle(m, I['ol0'], 0.2, 1.0)
    for (x, y, w, h) in [(8, 22, 3, 2), (26, 10, 2, 3), (44, 6, 3, 2), (16, 18, 2, 2)]:   # sky holes
        cv.a[y:y + h, x:x + w] = I['paper']
    cv.mass([(0, 44), (18, 34), (40, 28), (60, 30), (72, 34), (72, 90), (0, 90)], I['s3'], wet=1.0)
    cv.mass([(18, 34), (40, 27), (60, 33), (70, 46), (60, 56), (40, 50)], I['gr1'], wet=1.2)
    cv.snapshot('1 ground: olive shrubs with sky holes, earth, grass band')

    # ---- rocks, back to front: each an outline plus flat facets
    facets(cv, [(22, 24), (30, 16), (40, 12), (46, 14), (44, 22), (34, 28), (24, 30)],
           [([(22, 24), (30, 16), (40, 12), (46, 14), (42, 18), (32, 22), (24, 27)], 'top1'),
            ([(24, 27), (32, 22), (42, 18), (44, 22), (34, 28), (24, 30)], 's1')])
    cv.line([(40, 12), (46, 14)], I['rim'])
    facets(cv, [(54, 6), (64, 3), (72, 4), (72, 22), (60, 23), (53, 16)],
           [([(54, 6), (64, 3), (72, 4), (72, 7), (62, 7), (55, 9)], 'top2'), ([(60, 12), (72, 12), (72, 22), (60, 23)], 's3')])
    cv.line([(58, 6), (64, 5), (72, 7)], I['rim'])
    facets(cv, [(52, 27), (61, 25), (67, 31), (66, 41), (57, 44), (51, 36)],
           [([(52, 27), (61, 25), (66, 30), (58, 31), (53, 31)], 'top2'), ([(53, 31), (58, 31), (60, 42), (57, 44), (51, 36)], 'refl')])
    cv.line([(61, 25), (67, 31)], I['rim'])
    # rock A (left): lit top sliver, a face turned up (reflected), a face turned down (dark)
    facets(cv, [(0, 28), (8, 25), (14, 26), (20, 30), (23, 35), (22, 45), (16, 53), (8, 58), (0, 62)],
           [([(0, 28), (8, 25), (14, 26), (9, 30), (2, 33), (0, 35)], 'top2'),
            ([(0, 35), (2, 33), (9, 30), (14, 26), (20, 31), (12, 40), (0, 44)], 's1'),
            ([(0, 52), (12, 46), (22, 44), (16, 53), (8, 58), (0, 62)], 's4')])
    cv.line([(14, 26), (18, 29), (22, 34)], I['rim'])
    # rock B: the long slab, edges on clean 1:1 steps
    mB = facets(cv, [(0, 64), (10, 60), (22, 50), (36, 36), (38, 34), (46, 34), (53, 40), (59, 48), (65, 56), (67, 70), (63, 90), (0, 90)],
                [([(0, 70), (36, 34), (40, 34), (46, 36), (0, 82)], 'top2'),                 # the top plane
                 ([(46, 36), (53, 41), (60, 49), (65, 56), (66, 66), (46, 70), (30, 62), (40, 44)], 'refl'),  # face turned up
                 ([(30, 62), (46, 70), (66, 66), (67, 70), (63, 90), (20, 90), (12, 80)], 's3'),   # lower face
                 ([(20, 90), (0, 90), (0, 86), (12, 80)], 's4')])
    cv.snapshot('2 rocks: flat facets decided by lines')

    # ---- 10-11: the slab's ramp (light upper edge, darker lower end), rims, crack, plane streaks
    slab = cv.mask_poly([(0, 70), (36, 34), (40, 34), (46, 36), (0, 82)])
    yy, xx = np.mgrid[0:H, 0:W]
    dist_top = (xx + yy - 70) / np.sqrt(2)             # distance from the 1:1 top edge
    cv.a[slab & (dist_top < 1.6)] = I['top1']
    cv.a[slab & (xx + yy > 82) & (xx < 16)] = I['top3']   # the lower-left end darkens
    for k in range(7):
        x0 = 6 + k * 5
        cv.line([(x0, 70 - x0 + 5), (x0 + 3, 70 - x0 + 2)], I['warm'] if k % 2 else I['top1'])
    cv.line([(46, 35), (53, 41), (60, 49), (65, 56)], I['rim'])
    cv.line([(0, 83), (12, 71), (24, 59), (34, 49), (40, 43), (46, 37)], I['s4'])     # the tuck under the slab
    cv.line([(0, 63), (8, 59), (15, 55), (20, 50), (23, 46)], I['crack'])              # crack between A and B
    cv.line([(40, 76), (52, 74), (60, 78)], I['s4'])                                    # one break in the lower face
    for (x, y) in [(36, 80), (48, 84), (28, 72)]:
        cv.dab(x, y, I['lich'], 'dot')
    cv.snapshot('3 slab ramp, rims, tuck line, crack, lichen')

    # ---- 12: grass tufts, and the yellow in two clusters at right-middle
    r = np.random.default_rng(seed)
    for i in range(14):
        x = int(r.uniform(26, 58)); y = int(r.uniform(32, 48))
        cv.blade(x, y, I['gr2'], length=int(r.integers(2, 5)), lean=r.choice([-0.4, 0, 0.4]))
    for (cx, cy) in [(46, 22), (50, 38)]:
        for k in range(6):
            cv.dab(cx + r.integers(-2, 3), cy + r.integers(-2, 2), I['yel'], r.choice(['dot', 'h2', 'v2']))
    cv.snapshot('4 grass tufts, yellow clusters')
    return cv


if __name__ == '__main__':
    from sheet import zoom, grid
    cv = paint()
    ref = Image.open(f'{ROOT}/copies/p3_ref.png')
    cells = [zoom(ref, 5)] + [zoom(cv.pal[a], 5) for _, a in cv.stages] + [zoom(ref, 2), zoom(cv.rgb(), 2)]
    grid(cells, 5, ['his, reduced'] + [n for n, _ in cv.stages] + ['his 2x', 'mine 2x'], title='P3 v2 near rocks (cover), 5x').save(f'{ROOT}/sheets/p3_rocks.png')

cd ~/work/pixelart-studies/books/oga && python3 copies/p3_rocks.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p3_rocks.py').read()
s=s.replace("refl=c(0.44, 0.035, 170), refl2=c(0.50, 0.03, 190),","refl=c(0.42, 0.025, 160), refl2=c(0.48, 0.022, 185),")
s=s.replace("""    m = cv.mass(outline, I[base], wet=0.0)
    for poly, idx in faces:
        cv.mass(poly, I[idx], wet=0.0, where=m)
    return m""","""    m = cv.mass(outline, I[base], wet=0.0)
    NEXT = {'s1': 's2', 's2': 's1', 's3': 's2', 's4': 's3', 'refl': 'refl2', 'top1': 'top2', 'top2': 'top1'}
    for poly, idx in faces:
        f = cv.mass(poly, I[idx], wet=0.0, where=m)
        # uneven paint inside the facet: broad patches of the adjacent step only (塗りムラ)
        cv.mottle(f, I[NEXT.get(idx, idx)], 0.28, 2.6)
    cv.mottle(m & (cv.a == I[base]), I[NEXT.get(base, base)], 0.28, 2.6)
    return m""")
s=s.replace("([(46, 36), (53, 41), (60, 49), (65, 56), (66, 66), (46, 70), (30, 62), (40, 44)], 'refl'),  # face turned up",
            "([(46, 36), (53, 41), (60, 49), (63, 54), (52, 56), (42, 50), (40, 44)], 'refl'),  # the strip turned up to the sky\n                 ([(42, 50), (52, 56), (63, 54), (66, 66), (46, 70), (30, 62)], 's1'),")
s=s.replace("""    cv.mass([(0, 44), (18, 34), (40, 28), (60, 30), (72, 34), (72, 90), (0, 90)], I['s3'], wet=1.0)""",
"""    m = cv.mass([(0, 40), (10, 30), (22, 22), (40, 14), (56, 10), (72, 8), (72, 36), (40, 34), (0, 46)], I['ol1'], wet=1.5)
    cv.mottle(m, I['ol2'], 0.3, 1.5)
    cv.mass([(0, 44), (18, 34), (40, 28), (60, 30), (72, 34), (72, 90), (0, 90)], I['s3'], wet=1.0)""")
open('copies/p3_rocks.py','w').write(s)
EOF
python3 copies/p3_rocks.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && sed -i '' "s/NEXT = {'s1': 's2', 's2': 's1', 's3': 's2', 's4': 's3'/NEXT = {'s1': 's2', 's2': 's3', 's3': 's4', 's4': 's3'/" copies/p3_rocks.py && python3 copies/p3_rocks.py && python3 - <<'EOF'
s=open('~/work/pixelart-studies/books/oga/copies/p2_peak.py').read()
# mauve upper peak, fall-line strokes, mist lobes across, conifer groups, rock planes, smaller lavender band
s=s.replace("P = dict(paper=c(1.0, 0, 0), mist=c(0.955, 0.01, 225), g0=c(0.90, 0.015, 215), g1=c(0.84, 0.02, 210),",
            "P = dict(paper=c(1.0, 0, 0), mist=c(0.955, 0.01, 225), g0=c(0.90, 0.015, 215), g1=c(0.84, 0.02, 210),\n         u1=c(0.82, 0.02, 320), u2=c(0.75, 0.025, 310), u3=c(0.67, 0.03, 290),")
s=s.replace("    cv.a[upper] = I['g1']","    cv.a[upper] = I['u1']")
s=s.replace("for m, a, b in ((upper, 'g1', 'g2'), (lower, 'g2', 'g3')):","for m, a, b in ((upper, 'u1', 'u2'), (lower, 'g2', 'g3')):")
a=s.index("    # the upper peak: sparser, paler staggers"); b=s.index("    cv.snapshot('6c conifers")
s=s[:a]+'''    # the upper peak: crag striation, 1-px dark strokes falling down the fall line, 2-5 px
    for i in range(26):
        x = int(r.uniform(0, W)); col = np.nonzero(upper[:, x])[0]
        if len(col) < 4:
            continue
        y = int(r.uniform(col[0] + 1, col[-1] - 2)); L0 = int(r.integers(2, 6))
        for k in range(L0):
            if upper[min(y + k, H - 1), x + (k // 3)]:
                cv.put(x + (k // 3), y + k, I['u3'])
    # conifer tips along the upper ridge in irregular groups with gaps
    topu = np.array([np.argmax(upper[:, x]) if upper[:, x].any() else -1 for x in range(W)])
    x = 0
    while x < W:
        gl = int(r.integers(2, 6)); gap = int(r.integers(2, 6))
        for xx_ in range(x, min(W, x + gl)):
            if topu[xx_] > 0:
                for k in range(int(r.integers(1, 3))):
                    cv.put(xx_, topu[xx_] + k, I['u2'])
        x += gl + gap
    # mist lobes cutting ACROSS the mountain: a band under the upper peak and one over the lower left
    for poly in ([(0, 36), (10, 31), (24, 29), (34, 33), (26, 37), (10, 39)], [(0, 58), (8, 52), (18, 54), (22, 62), (12, 68), (0, 70)]):
        lobe = cv.mask_poly(poly)
        cv.mass(lobe, I['g0'], wet=1.4)
        cv.mass(cv.mask_poly([(p[0] + (1 if p[0] > 5 else 0), p[1] + (1 if p[1] > 40 else 0)) for p in poly]), I['mist'], wet=1.2, where=lobe)
'''+s[b:]
# ridge-top conifer ticks: groups
s=s.replace("""        if r.uniform() < 0.65:
            for k in range(r.integers(1, 4)):
                cv.put(x, top[x] - k, I['g3'])""","""        if (x // int(3 + (x * 7) % 4)) % 2 == 0:
            for k in range(r.integers(1, 5)):
                cv.put(x, top[x] - k, I['g3'])""")
# rock planes, no stipple; lavender band thin
s=s.replace("""    cv.a[rose & (Ls < np.quantile(Ls[rose], 0.45))] = I['rose2']
    cv.mottle(rose, I['rose2'], share=0.15, scale=0.8)""","""    cv.split(rose, (41, 72), (60, 66), I['rose2'], wet=0.0)""")
s=s.replace("    zone = (xx + 4 * nz < 30) & (yy + 3 * nz > 46)","    zone = (np.abs(xx + 3 * nz - 26) < 2) & (yy > 46)")
open('~/work/pixelart-studies/books/oga/copies/p2_peak.py','w').write(s)
EOF
cd ~/work/pixelart-studies/books/oga && python3 copies/p2_peak.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && sed -i '' "s/u1=c(0.82, 0.02, 320), u2=c(0.75, 0.025, 310), u3=c(0.67, 0.03, 290)/u1=c(0.83, 0.014, 285), u2=c(0.76, 0.018, 270), u3=c(0.69, 0.022, 250)/" copies/p2_peak.py && python3 copies/p2_peak.py

# output:
(Bash completed with no output)

cd ~/work/voxsim-wt; for d in place-enchant place-olycoast place-sanjuan place-skykomish place-yakima; do echo "== $d"; ls $d/refs 2>/dev/null | head; find $d -maxdepth 3 -iname '*.jp*g' -not -path '*/target/*' | head -5; head -5 $d/SPEC.md 2>/dev/null; done

# output:
== place-enchant
# voxsim — spec

A large small-voxel world where everything that acts is an agent: geological
bodies, water bodies and weather, plants, animals, humans. Every in-game
agent decision is made by TypeSafe's System One model **Jev** choosing one
== place-olycoast
place-olycoast/docs/olycoast/pair_07575_r53.jpg
place-olycoast/docs/olycoast/pair_07575_r42.jpg
place-olycoast/docs/olycoast/pair_07575_r54.jpg
place-olycoast/docs/olycoast/r53_beach_region.jpg
place-olycoast/docs/olycoast/pair_07575_r31.jpg
# voxsim — spec

A large small-voxel world where everything that acts is an agent: geological
bodies, water bodies and weather, plants, animals, humans. Every in-game
agent decision is made by TypeSafe's System One model **Jev** choosing one
== place-sanjuan
place-sanjuan/data-sj/ortho_2km_small.jpg
place-sanjuan/refs-sj/ortho_window.jpg
place-sanjuan/refs-sj/ortho_2km.jpg
place-sanjuan/docs/sanjuan/v44_rock_benches.jpg
place-sanjuan/docs/sanjuan/pair_top_v8.jpg
# voxsim — spec

A large small-voxel world where everything that acts is an agent: geological
bodies, water bodies and weather, plants, animals, humans. Every in-game
agent decision is made by TypeSafe's System One model **Jev** choosing one
== place-skykomish
place-skykomish/renders/sky/pj_i4_region_iso.jpg
place-skykomish/renders/sky/wall_pair_o.jpg
place-skykomish/renders/sky/p_far.jpg
place-skykomish/renders/sky/pl_top.jpg
place-skykomish/renders/sky/wall_pair_i.jpg
# voxsim — spec

A large small-voxel world where everything that acts is an agent: geological
bodies, water bodies and weather, plants, animals, humans. Every in-game
agent decision is made by TypeSafe's System One model **Jev** choosing one
== place-yakima
place-yakima/renders/y/p8_pairs.jpg
place-yakima/renders/y/p46_eve.jpg
place-yakima/renders/y/p15_pairs.jpg
place-yakima/renders/y/p4_pairs_b.jpg
place-yakima/renders/y/p4_pairs_c.jpg
# voxsim — spec

A large small-voxel world where everything that acts is an agent: geological
bodies, water bodies and weather, plants, animals, humans. Every in-game
agent decision is made by TypeSafe's System One model **Jev** choosing one

cd ~/work/voxsim-wt; python3 - <<'EOF'
import sys; sys.path.insert(0,'~/work/pixelart-studies/books/oga/src')
from PIL import Image
from sheet import fit, grid
fs=['place-olycoast/docs/olycoast/pair_07575_r53.jpg','place-sanjuan/docs/sanjuan/pair_top_v8.jpg','place-skykomish/renders/sky/wall_pair_o.jpg','place-yakima/renders/y/p8_pairs.jpg','place-skykomish/renders/sky/p_far.jpg','place-yakima/renders/y/p46_eve.jpg']
cells=[fit(Image.open(f),w=800) for f in fs]
grid(cells,2,fs).save('(manager scratchpad)/lanes.png')
EOF

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && mkdir -p places && python3 - <<'EOF'
from PIL import Image
import os
V='~/work/voxsim-wt/'
for name,f in [('skykomish','place-skykomish/renders/sky/wall_pair_o.jpg'),('olycoast','place-olycoast/docs/olycoast/pair_07575_r53.jpg'),('yakima','place-yakima/renders/y/p46_eve.jpg')]:
    im=Image.open(V+f).convert('RGB'); W,H=im.size; print(name,W,H)
    im.crop((0,0,W//2,H)).save(f'places/{name}_pair_left.png'); im.crop((W//2,0,W,H)).save(f'places/{name}_pair_right.png')
EOF
ls ~/work/voxsim-wt/place-enchant/docs/place-enchant/ ~/work/voxsim-wt/place-skykomish/docs 2>/dev/null | head

# output:
skykomish 1776 556
olycoast 1433 418
yakima 1928 540
~/work/voxsim-wt/place-enchant/docs/place-enchant/:
g3_grove_land.png
g3_grove_scene.png
i3_glacier_land.png
i5_region_iso.png
i7_glacier_low.png
i7_oblique_sw.png
pair_m20_region_iso.png
pair_u2_region_ne.png

find ~/work/voxsim-wt/place-skykomish ~/work/voxsim-wt/place-olycoast ~/work/voxsim-wt/place-yakima ~/work/voxsim-wt/place-enchant ~/work/voxsim-wt/place-sanjuan ~/work/voxsim-data -maxdepth 4 \( -iname '*index*' -o -iname '*07575*' -o -iname '*commons*' -o -iname '*enchant*lake*' \) -not -path '*/target/*' 2>/dev/null | head -20

# output:
~/work/voxsim-wt/place-olycoast/docs/olycoast/pair_07575_r53.jpg
~/work/voxsim-wt/place-olycoast/docs/olycoast/pair_07575_r42.jpg
~/work/voxsim-wt/place-olycoast/docs/olycoast/pair_07575_r54.jpg
~/work/voxsim-wt/place-olycoast/docs/olycoast/pair_07575_r31.jpg
~/work/voxsim-wt/place-olycoast/docs/olycoast/pair_07575_r7.jpg
~/work/voxsim-wt/place-olycoast/docs/olycoast/pair_07575_r28.jpg
~/work/voxsim-wt/place-olycoast/docs/olycoast/pair_07575_r58.jpg
~/work/voxsim-wt/place-olycoast/docs/places/skykomish/index_8km_slope.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Shark_Reef_Lopez_Island/commons_Shark_Reef_Park_Lopez_jpg_5501c693.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Shark_Reef_Lopez_Island/commons_Shark_Reef_Aquarium_Neon_Sign_jpg_6bfa0971.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Shark_Reef_Lopez_Island/commons_Blacktip_reef_shark_Carcharhinus_melanopterus_Mo_78a9e1f4.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Shark_Reef_Lopez_Island/commons_Blacktip_reef_shark_Carcharhinus_melanopterus_Mo_8b2ed5a7.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Shark_Reef_Lopez_Island/commons_Shark_Reef_Aquarium_Touch_Pool_31_jpg_5b36b25c.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Shark_Reef_Lopez_Island/commons_Shark_Reef_Aquarium_Entrance_jpg_eb36584b.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Racomitrium_moss_rock_bald/commons_Racomitrium_fasciculare_244068622_jpg_2fc4fd29.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Racomitrium_moss_rock_bald/commons_Racomitrium_lanuginosum_c_141022_472335_0960_JPG_f981216d.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Racomitrium_moss_rock_bald/commons_Wooly_Hair_Moss_Racomitrium_lanuginosum_39425410_0d53e065.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Racomitrium_moss_rock_bald/commons_Wooly_Hair_Moss_Racomitrium_lanuginosum_39378244_dd574a7d.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Racomitrium_moss_rock_bald/commons_Musgo_Grimmiaceae_6582137031_jpg_2c3de075.jpg
~/work/voxsim-wt/place-sanjuan/refs-sj/Racomitrium_moss_rock_bald/commons_Racomitrium_ellipticum_jpg_205426e0.jpg

ls ~/work/voxsim-wt/place-sanjuan/refs-sj/; ls ~/work/voxsim-wt/place-*/refs* -d 2>/dev/null

# output:
Exit code 1
Agate_Beach_Lopez_Island
Cattle_Point_San_Juan_Island
Douglas_fir_windswept_coast
Garry_oak_Quercus_garryana_meadow_Washin
Garry_oak_bald_San_Juan_Island
Iceberg_Point_Lopez
Iceberg_Point_Lopez_Island
Jones_Island_San_Juan
Lime_Kiln_Point_shoreline_rocks
Lopez_Island_aerial
Lopez_Island_rocky_shore
Pacific_madrone_Arbutus_menziesii_trunk_
Racomitrium_moss_rock_bald
Rocky_Mountain_juniper_San_Juan_Islands
San_Juan_Islands_aerial
San_Juan_Islands_camas_meadow
San_Juan_Islands_kelp_bed
San_Juan_Islands_madrone_shoreline
San_Juan_Islands_tide_pool_rocky_interti
Shark_Reef_Lopez_Island
Stuart_Island_Turn_Point
Turn_Island_San_Juan
Watmough_Bay_Lopez_Island
Yellow_Island_San_Juan
bull_kelp_Nereocystis_surface
ecy
glacial_striations_bedrock_San_Juan_Isla
look
map.js
ortho_2km.jpg
ortho_window.jpg
q1.txt
q2.log
q2.txt
sea_blush_Plectritis_congesta_bald
viewer.html
~/work/voxsim-wt/place-sanjuan/refs-sj:
Agate_Beach_Lopez_Island
Cattle_Point_San_Juan_Island
Douglas_fir_windswept_coast
Garry_oak_Quercus_garryana_meadow_Washin
Garry_oak_bald_San_Juan_Island
Iceberg_Point_Lopez
Iceberg_Point_Lopez_Island
Jones_Island_San_Juan
Lime_Kiln_Point_shoreline_rocks
Lopez_Island_aerial
Lopez_Island_rocky_shore
Pacific_madrone_Arbutus_menziesii_trunk_
Racomitrium_moss_rock_bald
Rocky_Mountain_juniper_San_Juan_Islands
San_Juan_Islands_aerial
San_Juan_Islands_camas_meadow
San_Juan_Islands_kelp_bed
San_Juan_Islands_madrone_shoreline
San_Juan_Islands_tide_pool_rocky_interti
Shark_Reef_Lopez_Island
Stuart_Island_Turn_Point
Turn_Island_San_Juan
Watmough_Bay_Lopez_Island
Yellow_Island_San_Juan
bull_kelp_Nereocystis_surface
ecy
glacial_striations_bedrock_San_Juan_Isla
look
map.js
ortho_2km.jpg
ortho_window.jpg
q1.txt
q2.log
q2.txt
sea_blush_Plectritis_congesta_bald
viewer.html

cd ~/work/pixelart-studies/books/oga && cat > places/queries.txt <<'EOF'
Index Town Walls Washington
Enchantment Lakes larches
Yakima River Canyon
Rialto Beach sea stacks
Skykomish River forest
EOF
(nice -n 10 python3 ~/work/pixelart-studies/tools/imgfetch.py -f places/queries.txt -n 8 -o places/refs --width 1280 > places/fetch.log 2>&1 &) ; ls ~/work/voxsim-wt/place-sanjuan/refs-sj/Iceberg_Point_Lopez_Island ~/work/voxsim-wt/place-sanjuan/refs-sj/Cattle_Point_San_Juan_Island | head

# output:
~/work/voxsim-wt/place-sanjuan/refs-sj/Cattle_Point_San_Juan_Island:
_sheet.jpg
openverse_Cattle_Point_San_Juan_Island_8063d301.jpg
openverse_Cattle_Point_San_Juan_Islands_National_Monument_98b2585e.jpg
openverse_Cattle_Point_San_Juan_Islands_National_Monument_aca19344.jpg
openverse_Stack_of_Rocks_Cattle_Point_San_Juan_Island_57981d52.jpg
sources.tsv

~/work/voxsim-wt/place-sanjuan/refs-sj/Iceberg_Point_Lopez_Island:
_sheet.jpg

cd ~/work/pixelart-studies/books/oga && cat >> LESSONS.md <<'EOF'

## 3. A wrong turn, and the correction

After §2 I started building a procedural test world (a heightfield valley with forest, a voxel-space renderer, cloud shadows, `src/scene.py`, `src/oga.py`) so I could "apply Oga's passes to simulated fields". The coordinator stopped me with a sibling study's lesson: the Genge student read its book, built a renderer, and got generic slabs. The book is not a rule set to feed a renderer; it teaches how to *paint*. Learn to paint the way it teaches first, by copying his paintings in pixels, and check that the copies carry what his carry.

The test world's first render already showed the problem. Oga's passes applied to its fields gave a picture with his colour and none of his construction. I've kept `scene.py` and `oga.py` as an honest record, and `sheets/ex4_gorge.png` (the boulders with the light let in through a gap) as the one piece of it that taught something (§5). From here on the work is copies.

## 4. Master copies

### 4a. Whole-picture copies were too big a bite

- **Cover, first try** (`copies/cover.py`, `sheets/copy1_cover*.png`). I drew the masses as hand polygons read off a gridded reduction and used his own paint list, working in his order (sky, peak, whole colour, ground, finish). It came out worse than a plain area-reduction of his painting: paper-white gaps where my masses didn't meet, blocks where he has gradations, marks in the wrong places.
- **Cover, second try.** I laid the ground from his plate, each pixel taking the nearest of my paints, then added marks. That is only a worse quantiser: muddy, blotchy, orphan pixels everywhere. One good thing came out of it. His cobalt rims, found by hue in his plate and redrawn as 1-px runs, sit exactly where he put them.
- **C-0007** (`copies/c0007.py`, `sheets/copy2_c0007.png`). Masses by hand, the path and dark band taken from his value and hue classes, then clumps, tufts and stones. The composition carries. The materials don't: one stone shape stamped 25 times, dark orphan pixels over the field, a lime cast, forest crowns as blocks.

Like the master-copy student, I went down to **passages**: one small crop of one material, his reduced crop beside mine at 5–8×, iterated until it holds, then looked at 1–2×.

### 4b. P1: broadleaf crowns from above (C-0007) — `copies/p1_foliage.py`, `sheets/p1_foliage*.png`

- **v1** (`copies/p1_foliage_v1.py`):
  - A three-value notan ground from his brightness, smoothed. On its own this is already very Oga: masses readable "by silhouette alone" (p.47).
  - Then flat plates with serrated tops, stamped at his bright points. They read as rows of mushrooms.
  - Then leafy edges: teeth hanging below lit sheets and lips above. I lipped every top edge, so everything got a halo.
  - Then watershed "members", each crown lit on its sun side. At 1× that read as trees for the first time. At 8× the crowns were Voronoi polygons with sawtooth edges.
- **Cold critic on v1:** "sawtooth scales, like feathers or fern fronds … one cool green family, no warm end and no deep end … the dark block is flat, dead fill; his dark still holds dim clumps." And across all four sheets: "the student is still building each picture from tone patches and texture fill. What his painting carries is **shape vocabulary per material**." That is the book's own point: "for a crowd you must know beforehand what shape each brush motion makes" (p.50).
- **v2: one mark, the rounded leaf-clump**, at four light levels:
  - lit: a warm cap on the upper-right bumps, a warm olive body, and a 1-px dark crescent at the lower left where it tucks under;
  - mid;
  - dim: one value above the hole colour, so the darks keep life;
  - lit+: rare.

  Clumps sit on a jittered grid and are painted far to near. His smoothed brightness picks each clump's level, and about half the area is hole. My first palette went ochre-yellow, overdoing the critic's "warm end"; his lights are fresh mid-green with yellow only at the hot spots. At 2× and 1× it now reads as a broadleaf canopy with holes and a dark mass, close to his.
- **Rule:** a broadleaf crown is clumps, not a texture. Lit caps face the sun, the pocket tucks lower-left, darks hold dim clumps, and about half the area is hole.

### 4c. P2: far peak in mist (cover, steps 5–6) — `copies/p2_peak.py`, `sheets/p2_peak.png`

- **Carries:** two layers, the far one paler; one step darker for the shading; the feet dissolving into mist; flat-brush staggers for conifers, with tips breaking the ridge line.
- **The critic's corrections:**
  - the upper peak should be a mauve-grey, not mint;
  - the mist must cut *across* the mountain in bands, not just frame it;
  - the crag needs fall-line striation;
  - conifer ticks must come in irregular groups, not a comb;
  - no hard-edged lavender slab;
  - the warm rock is flat planes, not stipple.
- **v2 does all of that.** My first mauve was far too saturated; the right colour is a low-chroma blue-violet grey (C ≈ 0.015). His greys are the mist's greys. The striation still reads a little like rain.
- **Rule:** the far peak is painted with the sky's colours, one step darker. Mist comes in lobes across the mass. Conifers are staggered vertical dashes in irregular groups, and the crag gets fall-line strokes.

### 4d. P3: near rocks (cover, steps 7, 10, 11) — `copies/p3_rocks.py`, `sheets/p3_rocks.png`

- **v1** carried at 2×: the lit slab and the cobalt rim. But the slab edge was a jagged staircase, the shadow faces were three-brown camouflage, and the upper boulder floated on the sky.
- **v2** is painted entirely by hand:
  - each rock is an outline plus flat facets drawn as polygons;
  - the slab's edges run on clean 1:1 steps;
  - the slab ramp is warm pink at the upper edge, lavender in the body, darker at its lower end;
  - a green-grey reflected strip sits on the face turned up to the sky (p.56);
  - the lower faces are darkest;
  - a continuous crack and a tuck line run under the slab;
  - olive shrubs with 2–3 px sky holes, and the yellow in two clusters.

  Pure flat facets looked like vector art. Oga's uneven paint (塗りムラ) is part of the material, so every facet gets broad patches of its *adjacent* step only.
- **Rule:** decide a rock's planes with lines. The top plane takes the sky light, faces turned up take cool reflected light, faces turned down stay darkest, and the far edge of the lit plane gets a line of the sky's pure colour. Unevenness stays inside a facet and within one step.
EOF
cat places/fetch.log | tail -3

# 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)

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('places/skykomish_pair_left.png'); print(im.size); im=im.crop((0,12,888,545)); im.save('places/skykomish_photo.png')" && python3 work/gridref.py places/skykomish_photo.png 320 3 places/sky_grid.png && ls places/refs 2>/dev/null

# output:
(888, 556)
320 192
Enchantment_Lakes_larches
Index_Town_Walls_Washington
Rialto_Beach_sea_stacks
Skykomish_River_forest
Yakima_River_Canyon

cd ~/work/pixelart-studies/books/oga/places/refs && python3 - <<'EOF'
from PIL import Image, ImageDraw
import glob,os
dirs=sorted(d for d in os.listdir('.') if os.path.isdir(d))
out=Image.new('RGB',(8*200,len(dirs)*164),'white'); dr=ImageDraw.Draw(out)
for r,d in enumerate(dirs):
    fs=sorted(f for f in glob.glob(d+'/*.jpg') if '_sheet' not in f)[:8]
    dr.text((2,r*164),d,fill='black')
    for c,f in enumerate(fs):
        im=Image.open(f).convert('RGB'); im.thumbnail((196,148)); out.paste(im,(c*200,r*164+14)); dr.text((c*200+2,r*164+14),str(c),fill='red')
out.save('(manager scratchpad)/prefs.jpg')
EOF

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga/places && for p in "Index_Town_Walls_Washington 1 skykomish" "Enchantment_Lakes_larches 3 enchant" "Rialto_Beach_sea_stacks 0 olycoast" "Yakima_River_Canyon 0 yakima"; do set -- $p; f=$(ls refs/$1/*.jpg | grep -v _sheet | sed -n "$(($2+1))p"); cp "$f" ${3}_photo.jpg; echo $3 $f; done; python3 -c "
from PIL import Image
for n in ['skykomish','enchant','olycoast','yakima']:
  print(n, Image.open(n+'_photo.jpg').size)"; grep -h "" refs/*/sources.tsv | cut -f1-4 | grep -E "$(ls refs/*/ -d | head -0)" | head -0

# output:
Exit code 1
(eval):1: no matches found: refs/Index_Town_Walls_Washington 1 skykomish/*.jpg
cp: : No such file or directory

(eval):1: no matches found: refs/Enchantment_Lakes_larches 3 enchant/*.jpg
cp: : No such file or directory

(eval):1: no matches found: refs/Rialto_Beach_sea_stacks 0 olycoast/*.jpg
cp: : No such file or directory

(eval):1: no matches found: refs/Yakima_River_Canyon 0 yakima/*.jpg
cp: : No such file or directory

Traceback (most recent call last):
  File "<string>", line 4, in <module>
  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: 'skykomish_photo.jpg'
head: illegal line count -- 0
head: illegal line count -- 0
ls: -d: No such file or directory

cd ~/work/pixelart-studies/books/oga/places && python3 - <<'EOF'
import glob,shutil
from PIL import Image
for d,i,n in [('Index_Town_Walls_Washington',1,'skykomish'),('Enchantment_Lakes_larches',3,'enchant'),('Rialto_Beach_sea_stacks',0,'olycoast'),('Yakima_River_Canyon',0,'yakima')]:
    fs=sorted(f for f in glob.glob(f'refs/{d}/*.jpg') if '_sheet' not in f)
    shutil.copy(fs[i],f'{n}_photo.jpg'); print(n,fs[i],Image.open(fs[i]).size)
EOF
cat refs/*/sources.tsv | grep -E "Index_Town|Enchant|Rialto|Yakima" | cut -f1,3,4 | head -30

# output:
skykomish refs/Index_Town_Walls_Washington/commons_Index_Town_Walls_May_2026_jpg_99c3e722.jpg (1280, 853)
enchant refs/Enchantment_Lakes_larches/openverse_Gnome_tarn_on_ice_2_b6eaec59.jpg (683, 1024)
olycoast refs/Rialto_Beach_sea_stacks/commons_Driftwood_along_Rialto_Beach_2022_jpg_a0c10141.jpg (1280, 686)
yakima refs/Yakima_River_Canyon/commons_Umptanum_Ridge_Water_Gap_IMG_0950A_jpg_f182742a.jpg (912, 608)
commons_Enchantment_Peak_from_Leprechaun_Lake_jpg_2cb413ff.jpg  CC BY-SA 4.0    Ron Clausen
commons_Camping_at_Lake_Olrun_in_the_Enchantments_11_Oct_b3308a46.jpg   CC BY-SA 4.0    Buidhe
commons_Index_Town_Walls_May_2026_jpg_99c3e722.jpg  CC BY-SA 4.0    SounderBruce
openverse_Index_Town_Wall_f4d05d4c.jpg  CC BY-SA 2.0    brewbooks
commons_Index_Town_Wall_304761156_jpg_83df755c.jpg  CC BY-SA 2.0    brewbooks from near Seattle, USA
openverse_Rialto_Beach_Sea_Stacks_1e3aa20d.jpg  CC BY-NC 2.0    jerrygabby1
openverse_Rialto_Beach_Sea_Stacks_9f631617.jpg  CC BY-ND 2.0    osiristhe
commons_Sea_stacks_off_Rialto_Beach_Olympic_National_Par_e59bad24.jpg   CC BY 4.0   Lianguanlun
commons_Quillayute_Needles_or_sea_stacks_seen_from_Rialt_fb529c3f.jpg   CC BY-SA 4.0    Ron Clausen
openverse_Rialto_Beach_Sea_Stack_fa744fff.jpg   CC BY-NC-ND 2.0 wild trees
openverse_Rialto_Beach_Sea_Stacks_f887fc17.jpg  CC BY-ND 2.0    osiristhe
commons_Sea_stacks_north_of_Rialto_Beach_near_Cape_Johns_3f39aacf.jpg   CC BY-SA 4.0    Ron Clausen
commons_Driftwood_along_Rialto_Beach_2022_jpg_a0c10141.jpg  CC BY-SA 4.0    Sea Cow
openverse_Yakima_River_Canyon_ca42eb52.jpg  CC BY-NC-ND 2.0 Pictoscribe -
commons_View_north_from_Umtanum_Ridge_into_Yakima_Canyon_5b6de286.jpg   Public domain   Williamborg (Williamborg 23:21, 16 March 2008 (UTC))
openverse_Yakima_River_Canyon_Scenic_Byway_b438417e.jpg CC BY-NC-ND 2.0 WSDOT
commons_Yakima_River_Canyon_27617932061_jpg_06421dc4.jpg    Public domain   BLM Oregon &amp; Washington
openverse_Yakima_River_Canyon_4767eaa8.jpg  CC BY 2.0   BLM Oregon & Washington
commons_Yakima_River_Canyon_27692690785_jpg_ddfd7bf1.jpg    Public domain   BLM Oregon &amp; Washington
openverse_Debris_flow_deposits_Holocene_Yakima_River_Canyo_95ca6aa1.jpg CC BY 2.0   James St. John

cd ~/work/pixelart-studies/books/oga/places && ls refs/Enchantment_Lakes_larches/ && python3 -c "
from PIL import Image
im=Image.open('enchant_photo.jpg'); im.thumbnail((400,400)); im.save('(manager scratchpad)/en.jpg')"

# output:
commons_Camping_at_Lake_Olrun_in_the_Enchantments_11_Oct_b3308a46.jpg
commons_Enchantment_Peak_from_Leprechaun_Lake_jpg_2cb413ff.jpg
openverse_Colchuck_Lake_67788308.jpg
openverse_Gnome_tarn_on_ice_2_b6eaec59.jpg
openverse_Gnome_tarn_on_ice_3_e1135c60.jpg
openverse_Larch_Reflection_e2ef22a6.jpg
sources.tsv

cd ~/work/pixelart-studies/books/oga && python3 work/gridref.py places/skykomish_photo.jpg 320 3 places/sky_grid.png

# output:
320 213

"""The shape vocabulary, one mark per material, as tested in the passage copies.

Each mark is drawn onto a copykit.Canvas and takes palette indices by name through a dict `ix`.
Nothing here decides where to paint; a scene script places the marks (by hand, or where a plan says).

  sky_bands      celeste ramp, flat bands with ragged 1-px seams, paler toward the horizon (C-0772)
  mist_lobe      a lobe of mist cutting across a mass, broken edge (cover, P2)
  stagger        the flat brush shifted vertically: conifers on a far ridge (cover step 6, P2)
  spire          one conifer at middle distance: 1-px leader, tiers widening down, lit ticks on the sun side
  conifer_mass   a stand of spires, far to near, tips breaking its top edge, dark holes between
  clump          a broadleaf leaf-clump at a light level (P1)
  clump_mass     a broadleaf crown mass as clumps on a jittered grid, level from a light field (P1)
  facet_rock     a rock/wall as flat facets decided by lines, uneven paint inside each facet (P3)
  fall_strokes   1-px dark strokes down the fall line of a rock face (P2)
  rim            a 1-px line of the sky's colour on the far edge of a lit plane (P3, 際)
  tufts          grass strokes, longer when nearer, lit tips (C-0007, C-0095)
"""
import numpy as np
from scipy.ndimage import gaussian_filter, distance_transform_edt


def _rng(seed):
    return np.random.default_rng(abs(int(seed)) % (2 ** 32))


def sky_bands(cv, mask, names, ix, y0, y1, seam=0.8, seed=0):
    """bands from names[0] at y0 (zenith side) to names[-1] at y1 (horizon)."""
    H, W = cv.a.shape
    yy = np.mgrid[0:H, 0:W][0]
    t = np.clip((yy - y0) / max(1, (y1 - y0)), 0, 0.9999) * len(names)
    n = cv.noise(0.8, seed)
    # flat bands: the noise only acts near a seam
    f = t - np.floor(t)
    near = (f < 0.2) | (f > 0.8)
    q = np.floor(t + np.where(near, seam * 0.25 * n, 0)).astype(int)
    q = np.clip(q, 0, len(names) - 1)
    cv.a[mask] = np.array([ix[k] for k in names])[q][mask]


def mist_lobe(cv, poly, inner, outer, ix, wet=1.4):
    lobe = cv.mass(poly, ix[outer], wet=wet)
    er = distance_transform_edt(lobe)
    cv.a[lobe & (er + 0.8 * cv.noise(0.8) > 1.8)] = ix[inner]
    return lobe


def stagger(cv, ridge, name, ix, lens=(1, 4), group=(2, 6), gap=(1, 4), up=True, seed=0):
    """vertical dashes along a ridge polyline, in irregular groups. up=True: tips rise above the line."""
    r = _rng(seed)
    rx = np.array([p[0] for p in ridge], float); ry = np.array([p[1] for p in ridge], float)
    x = int(rx.min())
    while x <= rx.max():
        g = int(r.integers(*group))
        for xx in range(x, min(int(rx.max()) + 1, x + g)):
            y = np.interp(xx, rx, ry)
            L = int(r.integers(lens[0], lens[1] + 1))
            for k in range(L):
                cv.put(xx, y - k if up else y + k, ix[name])
        x += g + int(r.integers(*gap))


def spire(cv, x, yb, h, ix, body='c_mid', dark='c_dark', lit='c_lit', sun=+1, w=None, seed=0, where=None):
    """one conifer: base at (x, yb), height h px. Tiers: every 2-3 rows a slightly wider row; the sun side
    (sun=+1 right, -1 left) gets lit tick pixels at tier ends; the shade side a dark edge."""
    r = _rng(seed)
    w = w if w is not None else max(1.0, h * 0.22)
    top = yb - h
    for y in range(int(top), int(yb) + 1):
        t = (y - top) / max(h, 1)
        half = w * t
        tier = ((y - int(top)) % 3 == 2)
        if tier:
            half += 0.8
        x0, x1 = int(round(x - half)), int(round(x + half))
        for xx in range(x0, x1 + 1):
            if where is not None and not (0 <= y < cv.H and 0 <= xx < cv.W and where[y, xx]):
                continue
            side = (xx - x) * sun
            idx = ix[body]
            if side < -half * 0.3:
                idx = ix[dark]
            if tier and side >= half - 1.0 and half > 0.8:
                idx = ix[lit]
            cv.put(xx, y, idx)
    cv.put(x, top, ix[dark] if sun else ix[body])


def conifer_mass(cv, mask, ix, h_range=(6, 14), spacing=3.5, sun=+1, levels=None, light=None, seed=0,
                 fill='c_hole'):
    """a stand: fill the mask dark, then spires on a jittered grid, far (top) to near (bottom).
    light: optional field 0..1; lit trees use levels['lit'], shaded ones levels['shade'] name triples."""
    r = _rng(seed)
    cv.a[mask] = ix[fill]
    ys, xs = np.nonzero(mask)
    if len(ys) == 0:
        return
    levels = levels or {'lit': ('c_mid', 'c_dark', 'c_lit'), 'shade': ('c_dark', 'c_hole', 'c_mid')}
    pts = []
    for y in np.arange(ys.min(), ys.max() + h_range[1], spacing * 0.8):
        for x in np.arange(xs.min() - 2, xs.max() + 3, spacing):
            pts.append((x + r.uniform(-1.2, 1.2), y + r.uniform(-1, 1)))
    pts.sort(key=lambda p: p[1])
    for (x, y) in pts:
        xi, yi = int(round(x)), int(round(y))
        if not (0 <= xi < cv.W and 0 <= yi < cv.H) or not mask[yi, xi]:
            continue
        t = (yi - ys.min()) / max(1, ys.max() - ys.min())
        h = h_range[0] + (h_range[1] - h_range[0]) * t * r.uniform(0.7, 1.1)
        lv = 'lit' if (light is None or light[yi, xi] > 0.5) else 'shade'
        b, d, l = levels[lv]
        spire(cv, x, y + h * 0.35, h, ix, body=b, dark=d, lit=l, sun=sun, seed=int(x * 31 + y * 17))


def clump(cv, x, y, r, cap, body, cres, ix, seed=0, where=None):
    rr = _rng(seed)
    R = int(np.ceil(r)) + 2
    tilt = rr.uniform(-0.25, 0.25)
    for dy in range(-R, R + 1):
        for dx in range(-R, R + 1):
            u, v = dx * np.cos(tilt) + dy * np.sin(tilt), -dx * np.sin(tilt) + dy * np.cos(tilt)
            ang = np.arctan2(v, u)
            rad = r * (1 + 0.18 * np.cos(3 * ang + seed) + 0.1 * np.cos(5 * ang + 2 * seed))
            if np.hypot(u / 1.2, v) / rad > 1:
                continue
            X, Y = int(round(x + dx)), int(round(y + dy))
            if where is not None and not (0 <= Y < cv.H and 0 <= X < cv.W and where[Y, X]):
                continue
            d = np.hypot(u / 1.2, v) / rad
            s = (dx * 0.6 - dy * 0.8) / (r + 1e-6)
            idx = ix[body]
            if s > 0.5 and d > 0.45:
                idx = ix[cap]
            elif s < -0.45 and d > 0.6:
                idx = ix[cres]
            cv.put(X, Y, idx)


def clump_mass(cv, mask, ix, light, levels, r_range=(2.0, 3.4), step=4, hole='b_hole', dim_share=0.35, seed=0):
    """levels: list of (threshold, (cap, body, cres)) ascending; light field 0..1 picks the level."""
    rr = _rng(seed)
    cv.a[mask] = ix[hole]
    ys, xs = np.nonzero(mask)
    if len(ys) == 0:
        return
    pts = []
    for y in range(ys.min() - 1, ys.max() + 3, step):
        for x in range(xs.min() - 2, xs.max() + 3, step):
            pts.append((x + rr.uniform(-1.2, 1.2) + (step / 2 if (y // step) % 2 else 0), y + rr.uniform(-1, 1)))
    pts.sort(key=lambda p: p[1])
    for (x, y) in pts:
        xi, yi = int(np.clip(round(x), 0, cv.W - 1)), int(np.clip(round(y), 0, cv.H - 1))
        if not mask[yi, xi]:
            continue
        v = light[yi, xi]
        lev = None
        for thr, trip in levels:
            if v >= thr:
                lev = trip
        if lev is None:
            if rr.uniform() < dim_share:
                lev = levels[0][1]
            else:
                continue
        t = (yi - ys.min()) / max(1, ys.max() - ys.min())
        clump(cv, x, y, r_range[0] + (r_range[1] - r_range[0]) * t, *lev, ix, seed=int(x * 13 + y * 7), where=mask)


def facet_rock(cv, outline, faces, ix, base, nxt, share=0.28, scale=2.6):
    """outline filled with base; faces [(poly, name)]; nxt: name -> adjacent step for uneven paint."""
    m = cv.mass(outline, ix[base], wet=0.0)
    for poly, name in faces:
        f = cv.mass(poly, ix[name], wet=0.0, where=m)
        if name in nxt:
            cv.mottle(f, ix[nxt[name]], share, scale)
    if base in nxt:
        cv.mottle(m & (cv.a == ix[base]), ix[nxt[base]], share, scale)
    return m


def fall_strokes(cv, mask, name, ix, n=30, lens=(2, 6), drift=0.2, seed=0):
    r = _rng(seed)
    ys, xs = np.nonzero(mask)
    if len(ys) == 0:
        return
    for i in r.choice(len(ys), size=min(n, len(ys)), replace=False):
        x, y = xs[i], ys[i]
        L = int(r.integers(*lens))
        for k in range(L):
            X, Y = int(round(x + drift * k)), y + k
            if 0 <= Y < cv.H and 0 <= X < cv.W and mask[Y, X]:
                cv.a[Y, X] = ix[name]


def rim(cv, pts, name, ix):
    cv.line(pts, ix[name])


def tufts(cv, mask, light, ix, dark, lit, density=0.05, lens=(1, 4), seed=0):
    """grass: short strokes, longer toward the bottom of the mask (nearer); in light: dark stroke with
    a lit tip beside; in shadow: a slightly lighter stroke (the book: contrast inside the mark)."""
    r = _rng(seed)
    ys, xs = np.nonzero(mask)
    if len(ys) == 0:
        return
    y0, y1 = ys.min(), ys.max()
    for i in r.choice(len(ys), size=int(len(ys) * density), replace=False):
        x, y = xs[i], ys[i]
        t = (y - y0) / max(1, y1 - y0)
        L = int(round(lens[0] + (lens[1] - lens[0]) * t * r.uniform(0.6, 1.2)))
        lean = r.choice([-0.4, 0, 0.3])
        for k in range(max(1, L)):
            X, Y = int(round(x + lean * k)), y - k
            if 0 <= Y < cv.H and 0 <= X < cv.W and mask[Y, X]:
                cv.a[Y, X] = ix[dark]
        if light is not None and light[y, x] > 0.5 and r.uniform() < 0.5:
            cv.put(x + 1, y - max(1, L) + 1, ix[lit])

"""Place study: Skykomish, the Index Town Wall above the river forest, painted the way Oga paints.
Photo: places/skykomish_photo.jpg (Index Town Walls, SounderBruce, CC BY-SA 4.0). 320x180.

Oga's decisions for this picture (MODEL.md sections):
  [0] what it is for: a granite wall, a forest at its foot, a person could walk out of the trees.
  [7] one light, concentrated: morning sun from the upper left. A cloud shadow lies over the left
      third of the wall and the ridge forest, so the lit central wall is the point and shadow is the
      majority. Reflected light in the shadowed granite is cool (sky), loosened with warm grey.
  [6] planes: sky / ridge forest crest / the rising wall / the forest band at the foot / near maples.
      The forest band severs the wall from the foreground (p.52: severing gives depth).
  [11] air: the wall's far right end and the ridge crest are a step paler and bluer.
  [3,5] the crowd: conifers as spires (tips break every edge against the sky or the wall), the
      maples as clumps; granite as vertical facets with fall-line streaks; a sky-coloured rim on the
      far edge of the lit facets (際).
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
from okl import lch_to_lab, oklab_to_rgb
from copykit import Canvas, majority
import vocab as V

W, H, OY = 320, 180, 24


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(
    sk1=c(0.66, 0.11, 252), sk2=c(0.71, 0.10, 250), sk3=c(0.76, 0.085, 248), sk4=c(0.81, 0.065, 244), sk5=c(0.86, 0.045, 238),
    # granite in light (warm pale grey) and its steps
    g1=c(0.90, 0.015, 85), g2=c(0.82, 0.018, 80), g3=c(0.73, 0.02, 70),
    # granite in shadow: cool reflected light, warm-grey loosening, dark streaks
    q1=c(0.64, 0.025, 255), q2=c(0.56, 0.028, 258), q3=c(0.48, 0.025, 255), qw=c(0.58, 0.02, 60), q4=c(0.36, 0.022, 250),
    rim=c(0.74, 0.10, 245),
    # conifers
    c_lit=c(0.56, 0.09, 135), c_mid=c(0.43, 0.07, 145), c_dark=c(0.31, 0.045, 160), c_hole=c(0.21, 0.03, 170),
    # conifers far/in shadow (aerial)
    f_lit=c(0.58, 0.05, 175), f_mid=c(0.49, 0.045, 185), f_dark=c(0.40, 0.04, 195),
    # maples
    m_cap=c(0.80, 0.15, 118), m_lit=c(0.70, 0.145, 124), m_mid=c(0.57, 0.12, 132), m_dark=c(0.42, 0.08, 140), b_hole=c(0.26, 0.045, 150),
)
NAMES = list(P); IX = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])


def S(pts):
    return [(x, y - OY) for x, y in pts]


RIDGE = [(0, 112), (16, 106), (40, 100), (64, 92), (88, 82), (104, 76), (120, 70), (144, 64), (168, 56), (184, 52),
         (200, 46), (216, 40), (232, 34), (248, 30), (264, 28), (280, 26), (300, 24), (320, 22)]
WALLTOP = [(0, 128), (24, 120), (48, 112), (72, 102), (96, 94), (120, 88), (144, 82), (168, 80), (192, 78), (216, 72),
           (240, 64), (264, 62), (288, 66), (304, 74), (320, 80)]
FORESTTOP = [(0, 160), (24, 162), (48, 164), (72, 160), (96, 154), (104, 146), (112, 138), (124, 134), (136, 140),
             (144, 152), (168, 152), (192, 150), (216, 148), (232, 152), (256, 156), (280, 154), (300, 146), (320, 140)]


def paint(seed=7):
    cv = Canvas(W, H, PAL, bg=IX['sk3'], seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]
    below = lambda line: yy >= np.interp(xx, [p[0] for p in S(line)], [p[1] for p in S(line)])
    sky = ~below(RIDGE)
    ridge_forest = below(RIDGE) & ~below(WALLTOP)
    wall = below(WALLTOP) & ~below(FORESTTOP)
    forest = below(FORESTTOP)
    # the cloud shadow: a soft lobe over the left third (world-fixed in a real scene; here designed)
    cloud = (xx + 0.35 * yy + 6 * cv.noise(3.0, seed + 1)) < 118

    # ---------------- ground: masses, flat, and the light decided -----------------------------------
    V.sky_bands(cv, sky, ['sk1', 'sk2', 'sk3', 'sk4', 'sk5'], IX, 0, 60, seed=seed)
    cv.a[ridge_forest] = IX['f_mid']
    cv.a[wall & ~cloud] = IX['g2']
    cv.a[wall & cloud] = IX['q2']
    cv.a[forest] = IX['c_hole']
    cv.snapshot('1 masses and the light: sky, ridge forest, wall (lit | cloud shadow), forest')

    # ---------------- the wall: vertical facets, decided by lines ------------------------------------
    rr = np.random.default_rng(seed)
    # facet boundaries: near-vertical lines leaning slightly (the granite's joints), photo x positions
    joints = [8, 30, 52, 64, 92, 112, 128, 146, 160, 176, 186, 200, 214, 232, 244, 262, 272, 286, 300, 312]
    shades = {}
    for i, (x0, x1) in enumerate(zip(joints[:-1], joints[1:])):
        lean = rr.uniform(-0.12, 0.06)
        f = (xx - x0 - lean * (yy - 60) >= 0) & (xx - x1 - lean * (yy - 60) < 0) & wall
        # each facet faces the light more or less: alternate lit/half with some shadowed recesses
        face = rr.choice(['lit', 'half', 'lit', 'recess'], p=[0.4, 0.3, 0.15, 0.15])
        if (x0 + x1) / 2 > 290:
            face = 'half'                                  # the far end, turning away: air
        shades[i] = face
        inshadow = f & cloud
        lit = f & ~cloud
        cv.a[lit] = IX[{'lit': 'g1', 'half': 'g2', 'recess': 'q1'}[face]]
        cv.a[inshadow] = IX[{'lit': 'q1', 'half': 'q2', 'recess': 'q3'}[face]]
        # uneven paint: the adjacent step in broad patches
        nxt = {'g1': 'g2', 'g2': 'g3', 'q1': 'qw', 'q2': 'q1', 'q3': 'q2'}
        for nm in set(nxt):
            m = f & (cv.a == IX[nm])
            if m.any():
                cv.mottle(m, IX[nxt[nm]], 0.22, 2.2)
        # the rim: the sky's colour down the far (right) edge of a lit facet in the sun
        if face == 'lit':
            ys = np.nonzero(lit.any(1))[0]
            for y in ys[::1]:
                row = np.nonzero(lit[y])[0]
                if len(row) and rr.uniform() < 0.8:
                    cv.put(row[-1], y, IX['rim'])
    cv.snapshot('2 the wall: vertical facets, lit/half/recess, rims on lit facets')
    # dark streaks and the great diagonal cracks (from the photo), fall-line strokes
    for pts in ([(142, 96), (146, 112), (150, 128), (152, 150)], [(176, 100), (178, 124), (180, 150)],
                [(232, 88), (234, 110), (236, 140)], [(274, 84), (278, 100), (282, 124)], [(150, 104), (162, 116), (168, 130)],
                [(40, 130), (44, 150)], [(96, 110), (98, 140)], [(206, 92), (208, 120)]):
        cv.line(S(pts), IX['q4'])
    V.fall_strokes(cv, wall & ~cloud, 'g3', IX, n=60, lens=(2, 7), drift=0.1, seed=seed)
    V.fall_strokes(cv, wall & cloud, 'q3', IX, n=40, lens=(2, 6), drift=0.1, seed=seed + 1)
    # the overhang dark on the right (photo x 272-300, y 84-110)
    cv.mass(S([(272, 90), (290, 86), (300, 96), (292, 112), (278, 108)]), IX['q3'], wet=1.0, where=wall)
    cv.snapshot('3 cracks, streaks, fall-line strokes')

    # ---------------- conifers: ridge crest against the sky (far, aerial), ledge trees, foot forest ---
    light_f = (~cloud).astype(float)
    V.conifer_mass(cv, ridge_forest | (below(RIDGE) & (yy < np.interp(xx, [p[0] for p in S(RIDGE)], [p[1] for p in S(RIDGE)]) + 3)),
                   IX, h_range=(4, 7), spacing=2.6, sun=-1, light=light_f,
                   levels={'lit': ('f_lit', 'f_dark', 'sk5'), 'shade': ('f_mid', 'f_dark', 'f_lit')}, seed=seed, fill='f_dark')
    # trees breaking the skyline: a few taller spires on the crest
    for x in range(4, 320, 7):
        y = np.interp(x, [p[0] for p in S(RIDGE)], [p[1] for p in S(RIDGE)])
        if rr.uniform() < 0.7:
            V.spire(cv, x + rr.integers(-2, 3), y + 2, rr.integers(5, 9), IX, body='f_mid', dark='f_dark', lit='f_lit', sun=-1, seed=x)
    # a few trees on ledges of the wall
    for (x, y, h) in [(60, 124, 6), (116, 116, 7), (190, 98, 5), (252, 92, 6), (300, 110, 5), (22, 140, 6)]:
        V.spire(cv, x, y - OY, h, IX, body='c_mid', dark='c_dark', lit='c_lit', sun=-1, seed=x)
    # the foot forest: big stand, lit tops where the sun reaches (right of the cloud)
    V.conifer_mass(cv, forest, IX, h_range=(8, 22), spacing=4.0, sun=-1, light=light_f, seed=seed + 3)
    cv.snapshot('4 conifers: crest (aerial), ledges, the foot forest (spires, tips break the edge)')

    # ---------------- near maples: clumps, bottom right and bottom left ------------------------------
    mright = cv.mask_poly(S([(236, 204), (244, 186), (256, 176), (272, 170), (292, 168), (312, 172), (320, 176), (320, 204)]))
    mleft = cv.mask_poly(S([(40, 204), (46, 186), (58, 174), (72, 172), (86, 180), (92, 204)]))
    lightm = gaussian_filter((xx + yy * 0.2 > 60).astype(float) * 0.6 + 0.4 * (yy < 175 - OY), 2)
    for m, lf in ((mright, np.clip(1.2 - (yy - (168 - OY)) / 40 + 0.2 * cv.noise(2), 0, 1)),
                  (mleft, np.clip(0.8 - (yy - (172 - OY)) / 40 + 0.2 * cv.noise(2), 0, 1) * 0.8)):
        V.clump_mass(cv, m, IX, lf, [(0.0, ('m_mid', 'm_dark', 'b_hole')), (0.45, ('m_lit', 'm_mid', 'm_dark')),
                                     (0.75, ('m_cap', 'm_lit', 'm_mid'))], r_range=(2.4, 3.6), step=4, seed=seed + 5)
    cv.snapshot('5 near maples: clumps, lit on the sun side')
    return cv


if __name__ == '__main__':
    from sheet import zoom, grid, fit
    cv = paint()
    import os; os.makedirs(f'{ROOT}/places/out', exist_ok=True)
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/places/out/skykomish.png')
    photo = Image.open(f'{ROOT}/places/skykomish_photo.jpg')
    ph = photo.resize((320, 213), Image.LANCZOS).crop((0, OY, 320, OY + 180))
    before = Image.open(f'{ROOT}/places/skykomish_pair_right.png')
    grid([fit(ph, w=640), fit(before, w=640), zoom(cv.rgb(), 2)], 1,
         ['photo (Index Town Walls, SounderBruce, CC BY-SA 4.0)', 'before: the place lane render (place-skykomish)', 'after: painted the Oga way, 320x180, 2x'],
         title='Skykomish: the Index wall').save(f'{ROOT}/sheets/place_skykomish.png')
    grid([zoom(cv.pal[a], 2) for _, a in cv.stages], 2, [n for n, _ in cv.stages], title='Skykomish, stage by stage').save(f'{ROOT}/sheets/place_skykomish_stages.png')

cd ~/work/pixelart-studies/books/oga && time python3 places/skykomish.py

# output:
python3 places/skykomish.py  2.05s user 0.15s system 25% cpu 8.637 total

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/skykomish.py').read()
a=s.index("    # ---------------- the wall: vertical facets"); b=s.index("    # dark streaks and the great diagonal cracks")
s=s[:a]+'''    # ---------------- the wall: its real planes, organised from the photo's values -----------------
    # (observation, p.62: the photo is a hint for the forms; the light is my decision)
    ph = np.asarray(Image.open(f'{ROOT}/places/skykomish_photo.jpg').convert('RGB').resize((320, 213), Image.BOX), float)[OY:OY + H] / 255
    from okl import rgb_to_oklab
    Lp = gaussian_filter(rgb_to_oklab(ph)[..., 0], 1.0)
    q = np.quantile(Lp[wall], [0.22, 0.5, 0.8])
    lev = np.searchsorted(q, Lp)                          # 0 recess, 1 half, 2 lit, 3 top-lit
    lit_names = np.array([IX['q2'], IX['g3'], IX['g2'], IX['g1']])
    sh_names = np.array([IX['q4'], IX['q3'], IX['q2'], IX['q1']])
    cv.a[wall & ~cloud] = lit_names[lev][wall & ~cloud]
    cv.a[wall & cloud] = sh_names[lev][wall & cloud]
    cv.a = majority(cv.a, 2)
    # uneven paint in the shadowed granite: warm grey loosening the cool reflected light (p.56)
    cv.mottle(wall & cloud & (cv.a == IX['q1']), IX['qw'], 0.3, 2.0)
    # the rim of the sky's colour: top edges of sunlit planes that turn under into recess
    litm = wall & ~cloud & np.isin(cv.a, [IX['g1'], IX['g2']])
    dark_below = np.roll(np.isin(cv.a, [IX['q2'], IX['q3'], IX['q4']]), -1, 0)
    rr = np.random.default_rng(seed)
    rimm = litm & dark_below & (rr.uniform(size=(H, W)) < 0.6)
    cv.a[rimm] = IX['rim']
    cv.snapshot('2 the wall: its planes organised from the photo, lit | cloud shadow, rims where lit planes turn under')
'''+s[b:]
# drop hand crack lines that won't align, keep fall strokes
s=s.replace("""    for pts in ([(142, 96), (146, 112), (150, 128), (152, 150)], [(176, 100), (178, 124), (180, 150)],
                [(232, 88), (234, 110), (236, 140)], [(274, 84), (278, 100), (282, 124)], [(150, 104), (162, 116), (168, 130)],
                [(40, 130), (44, 150)], [(96, 110), (98, 140)], [(206, 92), (208, 120)]):
        cv.line(S(pts), IX['q4'])
""","")
s=s.replace("""    cv.mass(S([(272, 90), (290, 86), (300, 96), (292, 112), (278, 108)]), IX['q3'], wet=1.0, where=wall)
""","")
s=s.replace("V.fall_strokes(cv, wall & ~cloud, 'g3', IX, n=60, lens=(2, 7), drift=0.1, seed=seed)","V.fall_strokes(cv, wall & ~cloud & np.isin(cv.a, [IX['g1'], IX['g2']]), 'g3', IX, n=45, lens=(2, 7), drift=0.1, seed=seed)")
s=s.replace("V.fall_strokes(cv, wall & cloud, 'q3', IX, n=40, lens=(2, 6), drift=0.1, seed=seed + 1)","V.fall_strokes(cv, wall & cloud & (cv.a == IX['q1']), 'q2', IX, n=30, lens=(2, 6), drift=0.1, seed=seed + 1)")
s=s.replace("    cv.snapshot('3 cracks, streaks, fall-line strokes')","    cv.snapshot('3 fall-line strokes in the lit granite')")
# forests from photo notan + spires only on top edges
a=s.index("    light_f = (~cloud).astype(float)"); b=s.index("    cv.snapshot('4 conifers")
s=s[:a]+'''    light_f = (~cloud).astype(float)
    Lf = gaussian_filter(rgb_to_oklab(ph)[..., 0], 0.8)
    # ridge forest: a flat far mass, two values from the photo, aerial colours; skyline tips staggered
    qr = np.quantile(Lf[ridge_forest], 0.5)
    cv.a[ridge_forest] = np.where(Lf > qr, IX['f_mid'], IX['f_dark'])[ridge_forest]
    cv.a[ridge_forest & ~cloud & (Lf > np.quantile(Lf[ridge_forest], 0.85))] = IX['f_lit']
    V.stagger(cv, S(RIDGE), 'f_mid', IX, lens=(1, 4), group=(2, 5), gap=(1, 4), up=True, seed=seed)
    for x in range(4, 320, 9):
        y = np.interp(x, [p[0] for p in S(RIDGE)], [p[1] for p in S(RIDGE)])
        if rr.uniform() < 0.5:
            V.spire(cv, x + rr.integers(-3, 4), y + 2, int(rr.integers(4, 8)), IX, body='f_mid', dark='f_dark', lit='f_lit', sun=-1, seed=x)
    # ledge trees
    for (x, y, h) in [(60, 124, 6), (116, 116, 7), (190, 98, 5), (252, 92, 6), (300, 110, 5), (22, 140, 6)]:
        V.spire(cv, x, y - OY, h, IX, body='c_mid', dark='c_dark', lit='c_lit', sun=-1, seed=x)
    # the foot forest: organised notan from the photo (hole / dark / mid), then spires only where a
    # crown top is lit or the stand meets the wall (tips break that edge)
    qf = np.quantile(Lf[forest], [0.4, 0.75])
    cv.a[forest] = np.array([IX['c_hole'], IX['c_dark'], IX['c_mid']])[np.searchsorted(qf, Lf)][forest]
    cv.a = majority(cv.a, 1)
    ft = [int(np.interp(x, [p[0] for p in S(FORESTTOP)], [p[1] for p in S(FORESTTOP)])) for x in range(W)]
    for x in range(0, W, 3):
        h = int(rr.integers(6, 16))
        V.spire(cv, x + rr.uniform(-1, 1), ft[x] + h * 0.6, h, IX, body='c_mid', dark='c_dark',
                lit='c_lit' if not cloud[min(ft[x], H - 1), x] else 'c_mid', sun=-1, seed=x * 3)
    pk = forest & (Lf > np.quantile(Lf[forest], 0.9))
    ys, xs = np.nonzero(pk)
    for i in rr.choice(len(ys), size=min(40, len(ys)), replace=False):
        V.spire(cv, xs[i], ys[i] + 4, int(rr.integers(5, 9)), IX, body='c_mid', dark='c_dark', lit='c_lit', sun=-1, seed=int(i))
'''+s[b:]
open('places/skykomish.py','w').write(s)
EOF
python3 places/skykomish.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/skykomish.py').read()
s=s.replace("q = np.quantile(Lp[wall], [0.22, 0.5, 0.8])","q = np.quantile(Lp[wall], [0.3, 0.55, 0.85])")
s=s.replace("lit_names = np.array([IX['q2'], IX['g3'], IX['g2'], IX['g1']])","lit_names = np.array([IX['q3'], IX['g3'], IX['g2'], IX['g1']])")
s=s.replace("g1=c(0.90, 0.015, 85), g2=c(0.82, 0.018, 80), g3=c(0.73, 0.02, 70),","g1=c(0.88, 0.018, 85), g2=c(0.78, 0.02, 80), g3=c(0.67, 0.022, 70),")
# ridge forest texture: staggered dark dashes inside
s=s.replace("    V.stagger(cv, S(RIDGE), 'f_mid', IX, lens=(1, 4), group=(2, 5), gap=(1, 4), up=True, seed=seed)",
"""    V.stagger(cv, S(RIDGE), 'f_mid', IX, lens=(1, 4), group=(2, 5), gap=(1, 4), up=True, seed=seed)
    for k in range(3, 40, 4):     # rows of staggers inside the ridge forest, following the ridge
        V.stagger(cv, [(x, y + k) for x, y in S(RIDGE)], 'f_dark', IX, lens=(1, 3), group=(1, 4), gap=(2, 5), up=False, seed=seed + k)
    cv.a[~ridge_forest & (cv.a == IX['f_dark']) & ~sky & (yy > 20) & wall] = IX['q3']""")
open('places/skykomish.py','w').write(s)
EOF
python3 places/skykomish.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && for n in enchant olycoast yakima; do python3 work/gridref.py places/${n}_photo.jpg 320 2 places/${n}_grid.png; done; ls ~/work/voxsim-wt/place-sanjuan/refs-sj/Garry_oak_bald_San_Juan_Island ~/work/voxsim-wt/place-sanjuan/refs-sj/Iceberg_Point_Lopez

# output:
320 480
320 172
320 213
~/work/voxsim-wt/place-sanjuan/refs-sj/Garry_oak_bald_San_Juan_Island:
_sheet.jpg
commons_Oregon_white_oak_Quercus_garryana_9394_jpg_761d725a.jpg
commons_Quercus_garryana_1_brewbooks_jpg_f1da547d.jpg
commons_Quercus_garryana_Cowichan_1_jpg_23056651.jpg
commons_Quercus_garryana_Cowichan_2_jpg_fc0e90fa.jpg
commons_Quercus_garryana_var_breweri_jpg_ecbd311c.jpg
openverse_A_Compact_35_mm_Film_Trip_around_Town_Pentax_zoo_62a1f1e2.jpg
openverse_BAEA_2016_12_21_IMG_6145_c4ab66a4.jpg
openverse_Garry_Oak_Meadow_Victoria_BC_d344914c.jpg
openverse_Garry_Oak_Meadow_postcard_caf6084b.jpg
openverse_Garry_Oak_Quercus_garryana_c1996e94.jpg
openverse_Ma_and_Pa_Bald_Eagle_5b632828.jpg
sources.tsv

~/work/voxsim-wt/place-sanjuan/refs-sj/Iceberg_Point_Lopez:
_sheet.jpg
commons_Iceberg_Point_32388919114_jpg_e0dae65e.jpg
commons_Iceberg_Point_Border_Marker_32849967260_jpg_ca54cfc5.jpg
commons_Iceberg_Point_Lopez_Island_Washington_USA_jpeg_6a0fe7e9.jpeg
commons_Iceberg_Point_panoramio_jpg_3abd24af.jpg
commons_San_Juan_Islands_03_6550527747_jpg_3f81e33f.jpg
commons_San_Juan_Islands_13_6550544645_jpg_829ebb18.jpg
openverse_Carol_and_Dave_view_original_size_towards_Iceber_c41a7cf5.jpg
openverse_Iceberg_Point_8566faca.jpg
openverse_Iceberg_Point_Border_Marker_8b30b0d3.jpg
openverse_Iceberg_point_c05f175a.jpg
openverse_Lopez_Island_4_13_12_637d5b38.jpg
openverse_Lopez_Island_4_13_12_8841fb34.jpg
sources.tsv

cd ~/work/pixelart-studies/books/oga && cp ~/work/voxsim-wt/place-sanjuan/refs-sj/Garry_oak_bald_San_Juan_Island/openverse_Garry_Oak_Meadow_Victoria_BC_d344914c.jpg places/sanjuan_photo.jpg && grep Garry_Oak_Meadow_Victoria ~/work/voxsim-wt/place-sanjuan/refs-sj/Garry_oak_bald_San_Juan_Island/sources.tsv | cut -f1,3,4; python3 work/gridref.py places/sanjuan_photo.jpg 320 2 places/sanjuan_grid.png; python3 -c "
import sys; sys.path.insert(0,'src'); from PIL import Image; from sheet import grid,fit
fs=['enchant','olycoast','yakima','sanjuan']
grid([fit(Image.open(f'places/{n}_grid.png'),w=640,h=500) for n in fs],2,fs).save('(manager scratchpad)/pg.png')"

# output:
openverse_Garry_Oak_Meadow_Victoria_BC_d344914c.jpg CC BY-NC-SA 2.0 Nick Kenrick..
320 320

"""Painting a scene the Oga way, from a plan (masses + materials) and a light design.

This is the passage copies (copies/p1-p3) and the Skykomish study generalised: the same marks
(src/vocab.py), the same order, one function per material. Forms come from a *form source*: a photo
(for photo studies) or a sim render (for voxsim), used only for its VALUES inside each mass, organised
(smoothed) so they become shapes. Colour never comes from the source: each material gets a lit family
and a shadow family built by Oga's rules (palette_for).

    scene = Scene(W, H, form_rgb)            # form_rgb: HxWx3 float, the source at output size
    scene.add('sky', 'sky', mask)            # masses in painting order (far to near)
    scene.add('ridge', 'far', mask, key=(L,C,h), air=0.6)
    ...
    scene.light(cast=mask_of_designed_shadow, sun=-1)   # the one light (MODEL 7)
    cv = scene.paint()

Material painters and the book sections they carry:
  sky        banded celeste, paler at the horizon                          (C-0772)
  far        aerial mass: two values, sky-tinted, staggered conifer edge      (cover step 6, p.54 air)
  conifer    stand: organised notan, spires breaking the top edge            (cover step 7, P2)
  broadleaf  crowns as clumps at light levels                                (P1, C-0827)
  rock       planes from organised values; lit | shadow families; rim; fall strokes  (P3, C-0792)
  meadow     one plane with undulations; organised values; tufts that lengthen with nearness;
             top-view near, side-view far                                   (C-0095, p.53)
  water      mirror of what is painted above, one step down, horizontal dash rows of sky colour,
             clear bed in the shallows                                      (C-0792 water, cover)
  gravel     stones as a crowd: dots and 2-px lozenges, lit top / dark under, size grows near
  wood       driftwood: pale facets, lit top, dark underside
  snow       white lit, blue-grey form shadow, celeste cast shadow           (p.96)
"""
import numpy as np
from scipy.ndimage import gaussian_filter, binary_dilation
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab, lab_to_lch
from copykit import Canvas, majority
import vocab as V

D = np.pi / 180


def lch(L, C, h):
    return lch_to_lab(np.array([L, C, h * D]))


def palette_for(key, n_lit=4, n_sh=4, warm_light=True, sky_h=245.0, spread=(0.14, 0.18)):
    """Oga's families from one key colour (L, C, hue deg) = the material's mid-lit colour.
    lit family: L up to key+spread, hue walks toward yellow (h 100) as L rises, chroma rises with L
                (unmuddied, C-0081) for chromatic materials; neutrals stay low-chroma but warm.
    shadow family: L from key-0.12 down, hue pulled toward the sky's hue (reflected light), chroma a
                touch lower; plus a warm shadow variant (the object's own colour in shadow, p.56/62)."""
    L0, C0, h0 = key
    lit = []
    for i, t in enumerate(np.linspace(-0.35, 1.0, n_lit)):
        L = L0 + spread[0] * t
        hh = h0 + ((100 - h0 + 180) % 360 - 180) * 0.35 * max(t, 0) if (warm_light and C0 > 0.03) else h0
        C = C0 * (1 + 0.25 * t) if C0 > 0.03 else C0 * (1 + 0.3 * t)
        lit.append(lch(L, C, hh))
    sh = []
    for t in np.linspace(1.0, 0.0, n_sh):          # darkest first
        L = L0 - 0.10 - spread[1] * t * 1.4
        pull = 0.45 if C0 < 0.04 else 0.25
        hh = h0 + ((sky_h - h0 + 180) % 360 - 180) * pull
        C = max(0.012, C0 * (0.75 - 0.25 * t))
        sh.append(lch(L, C, hh))
    warm = lch(L0 - 0.16, max(0.02, C0 * 0.6), h0 + ((60 - h0 + 180) % 360 - 180) * 0.4)
    return dict(lit=lit, sh=sh, warm=warm)


class Scene:
    def __init__(self, W, H, form_rgb, seed=0):
        self.W, self.H, self.seed = W, H, seed
        self.form = rgb_to_oklab(np.clip(form_rgb, 0, 1))[..., 0]
        self.layers = []
        self.cast = np.zeros((H, W), bool)
        self.sun = -1
        self.sky_names = None

    def add(self, name, material, mask, key=None, **kw):
        self.layers.append(dict(name=name, mat=material, mask=mask, key=key, kw=kw))

    def light(self, cast=None, sun=-1):
        if cast is not None:
            self.cast = cast
        self.sun = sun

    # ------------------------------------------------------------------ palette assembly
    def _build_palette(self):
        cols, names = [], []

        def addc(n, lab):
            names.append(n); cols.append(oklab_to_rgb(lab))
        for ly in self.layers:
            n, m, key, kw = ly['name'], ly['mat'], ly['key'], ly['kw']
            if m == 'sky':
                for i, c in enumerate(kw.get('ramp', [(0.66, 0.11, 252), (0.72, 0.10, 250), (0.78, 0.08, 247), (0.84, 0.06, 242), (0.89, 0.04, 236)])):
                    addc(f'{n}.{i}', lch(*c))
                continue
            if m == 'snow':
                for i, c in enumerate([(0.99, 0.004, 100), (0.95, 0.008, 95), (0.86, 0.02, 270), (0.78, 0.03, 280), (0.70, 0.035, 283), (0.76, 0.045, 245), (0.68, 0.05, 248)]):
                    addc(f'{n}.{i}', lch(*c))
                continue
            fam = palette_for(key, **kw.get('pal', {}))
            if kw.get('air', 0) > 0:          # aerial perspective: families pulled toward the horizon sky
                a = kw['air']; hz = lch(*kw.get('horizon', (0.86, 0.04, 238)))
                fam = {k: ([v * (1 - a) + hz * a for v in fam[k]] if isinstance(fam[k], list) else fam[k] * (1 - a) + hz * a) for k in fam}
            for i, c in enumerate(fam['lit']):
                addc(f'{n}.l{i}', c)
            for i, c in enumerate(fam['sh']):
                addc(f'{n}.s{i}', c)
            addc(f'{n}.w', fam['warm'])
            if m in ('rock', 'wood', 'water'):
                addc(f'{n}.rim', lch(*kw.get('rim', (0.74, 0.10, 245))))
        self.names = {k: i for i, k in enumerate(names)}
        return np.array(cols)

    # ------------------------------------------------------------------ paint
    def paint(self):
        pal = self._build_palette()
        cv = Canvas(self.W, self.H, pal, seed=self.seed)
        cv.names = self.names
        self.cv = cv
        for ly in self.layers:
            getattr(self, '_' + ly['mat'])(cv, ly)
            cv.snapshot(f"{ly['name']} ({ly['mat']})")
        return cv

    # organised values of the form source inside a mask, as quantile levels
    def levels(self, mask, qs, sigma=1.0):
        Ls = gaussian_filter(self.form, sigma)
        if mask.sum() < 4:
            return np.zeros(mask.shape, int)
        t = np.quantile(Ls[mask], qs)
        return np.searchsorted(t, Ls)

    def ix(self, ly):
        n = ly['name']
        return {k.split('.', 1)[1]: v for k, v in self.names.items() if k.startswith(n + '.')}

    # ---- materials ------------------------------------------------------------------------------
    def _sky(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly)
        ys = np.nonzero(m.any(1))[0]
        V.sky_bands(cv, m, [str(i) for i in range(len(ix))], ix, ys.min(), ys.max() * ly['kw'].get('reach', 0.9), seed=self.seed)

    def _lit_mask(self, ly, lev_lit):
        """lit where the organised form says lit AND the designed light reaches (not in cast shadow)."""
        return (lev_lit) & ~self.cast & ~ly['kw'].get('shadow', np.zeros_like(self.cast))

    def _far(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly); kw = ly['kw']
        lev = self.levels(m, [0.5], 1.2)
        lit = self._lit_mask(ly, lev >= 1)
        cv.a[m] = ix['s3']
        cv.a[m & lit] = ix['l1']
        cv.a[m & lit & (self.levels(m, [0.85], 1.0) >= 1)] = ix['l2']
        if kw.get('edge') == 'conifer':
            top = [(x, int(np.argmax(m[:, x]))) for x in range(self.W) if m[:, x].any()]
            V.stagger(cv, top, 's2', ix, lens=(1, 3), group=(2, 5), gap=(1, 3), up=True, seed=self.seed)
            for k in range(3, 60, 4):
                V.stagger(cv, [(x, y + k) for x, y in top], 's2', ix, lens=(1, 2), group=(1, 3), gap=(3, 7), up=False, seed=self.seed + k)
            cv.a[~m & np.isin(cv.a, [ix['s2']]) & (np.mgrid[0:self.H, 0:self.W][0] > max(y for _, y in top) + 60)] = ix['s3']

    def _conifer(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly); kw = ly['kw']
        rr = np.random.default_rng(self.seed + 3)
        lev = self.levels(m, [0.4, 0.75], 0.8)
        cv.a[m] = np.array([ix['s3'], ix['s2'], ix['s1']])[lev][m]
        lit = self._lit_mask(ly, lev >= 2)
        cv.a[m & lit] = ix['l0']
        cv.a = majority(cv.a, 1)
        hr = kw.get('h', (6, 16))
        top = [(x, int(np.argmax(m[:, x]))) for x in range(self.W) if m[:, x].any()]
        topd = dict(top)
        spacing = kw.get('spacing', 3)
        for x in range(min(topd), max(topd) + 1, spacing):
            if x not in topd:
                continue
            h = int(rr.integers(*hr))
            y0 = topd[x]
            litt = not self.cast[min(y0, self.H - 1), x]
            V.spire(cv, x + rr.uniform(-1, 1), y0 + h * 0.6, h, ix, body='s1' if litt else 's2', dark='s3',
                    lit='l1' if litt else 's1', sun=self.sun, seed=x * 3)
        pk = m & lit & (gaussian_filter(self.form, 0.8) > np.quantile(self.form[m], 0.85))
        ys, xs = np.nonzero(pk)
        for i in rr.choice(len(ys), size=min(kw.get('n_inner', 40), len(ys)), replace=False):
            h = int(rr.integers(hr[0], max(hr[0] + 1, hr[1] // 2 + 1)))
            V.spire(cv, xs[i], ys[i] + h * 0.5, h, ix, body='l0', dark='s2', lit='l2', sun=self.sun, seed=int(i), where=m)

    def _broadleaf(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly); kw = ly['kw']
        Ls = gaussian_filter(self.form, 1.0)
        lo, hi = np.quantile(Ls[m], [0.05, 0.95]) if m.any() else (0, 1)
        light = np.clip((Ls - lo) / (hi - lo + 1e-9), 0, 1)
        light = np.where(self.cast, light * 0.45, light)
        V.clump_mass(cv, m, ix, light, [(0.0, ('s2', 's1', 's3')), (0.45, ('l0', 's0', 's2')),
                                        (0.62, ('l1', 'l0', 's1')), (0.8, ('l2', 'l1', 's1'))],
                     r_range=kw.get('r', (2.0, 3.4)), step=kw.get('step', 4), hole='s3', seed=self.seed + 5)

    def _rock(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly); kw = ly['kw']
        lev = self.levels(m, [0.3, 0.55, 0.82], kw.get('sigma', 1.0))
        litz = ~self.cast & ~kw.get('shadow', np.zeros_like(m))
        lit_names = np.array([ix['s2'], ix['l0'], ix['l1'], ix['l2']])
        sh_names = np.array([ix['s0'], ix['s1'], ix['s2'], ix['s3']])
        cv.a[m & litz] = lit_names[lev][m & litz]
        cv.a[m & ~litz] = sh_names[lev][m & ~litz]
        cv.a = majority(cv.a, 1)
        cv.mottle(m & ~litz & (cv.a == ix['s3']), ix['w'], 0.3, 2.0)
        litm = m & litz & np.isin(cv.a, [ix['l1'], ix['l2']])
        dk = np.roll(np.isin(cv.a, [ix['s0'], ix['s1'], ix['s2']]), -1, 0)
        rr = np.random.default_rng(self.seed + 9)
        cv.a[litm & dk & (rr.uniform(size=m.shape) < kw.get('rim_p', 0.5))] = ix['rim']
        V.fall_strokes(cv, litm, 'l0', ix, n=int(m.sum() * 0.004) + 3, lens=(2, 6), drift=kw.get('drift', 0.1), seed=self.seed)

    def _meadow(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly); kw = ly['kw']
        lev = self.levels(m, [0.3, 0.6, 0.85], kw.get('sigma', 1.6))
        litz = ~self.cast & ~kw.get('shadow', np.zeros_like(m))
        cv.a[m & litz] = np.array([ix['s3'], ix['l0'], ix['l1'], ix['l2']])[lev][m & litz]
        cv.a[m & ~litz] = np.array([ix['s0'], ix['s1'], ix['s2'], ix['s3']])[lev][m & ~litz]
        cv.a = majority(cv.a, 2)
        light = (litz & (lev >= 1)).astype(float)
        V.tufts(cv, m & litz, light, ix, 's3', 'l3', density=kw.get('tuft', 0.05), lens=kw.get('lens', (1, 5)), seed=self.seed)
        V.tufts(cv, m & ~litz, None, ix, 's0', 's3', density=kw.get('tuft', 0.05) * 0.6, lens=kw.get('lens', (1, 5)), seed=self.seed + 1)
        for (col, n, where) in kw.get('flowers', []):
            k = self.names[col] if isinstance(col, str) else col
            rr = np.random.default_rng(self.seed + 11)
            ys, xs = np.nonzero(m & where)
            if len(ys):
                for i in rr.choice(len(ys), size=min(n, len(ys)), replace=False):
                    cv.put(xs[i], ys[i], k)

    def _water(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly); kw = ly['kw']
        H, W = self.H, self.W
        line = kw['line']              # waterline row per column (array W)
        src = cv.a.copy()
        rr = np.random.default_rng(self.seed + 13)
        # 1 the water's own colour as base (dark, sky tinted)
        cv.a[m] = ix['s2']
        # 2 the mirror: copy the painted pixel above the waterline, mapped one step down
        down = kw.get('down', {})
        for x in range(W):
            y0 = int(line[x])
            for y in range(y0, H):
                if not m[y, x]:
                    continue
                ys = int(round(y0 - (y - y0) * kw.get('squash', 1.0)))
                if 0 <= ys < H and not m[ys, x]:
                    v = src[ys, x]
                    cv.a[y, x] = down.get(int(v), v)
        # 3 horizontal dash rows: sky-coloured sheen where the surface faces the sky, broken
        n = gaussian_filter(rr.standard_normal((H, W)), (0.3, 2.5))
        n = (n - n.mean()) / n.std()
        dash = m & (n > kw.get('dash_t', 1.1))
        cv.a[dash] = ix['rim']
        dk = m & (n < -1.4)
        cv.a[dk] = ix['s3']
        # 4 shallows: the bed shows through near the shore (a band below the line)
        if kw.get('bed'):
            bed_mask = kw['bed'] & m
            cv.a[bed_mask & (rr.uniform(size=(H, W)) < 0.5)] = ix['w']

    def _gravel(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly); kw = ly['kw']
        lev = self.levels(m, [0.35, 0.7], 1.5)
        litz = ~self.cast
        cv.a[m & litz] = np.array([ix['s3'], ix['l0'], ix['l1']])[lev][m & litz]
        cv.a[m & ~litz] = np.array([ix['s1'], ix['s2'], ix['s3']])[lev][m & ~litz]
        rr = np.random.default_rng(self.seed + 17)
        ys, xs = np.nonzero(m)
        if len(ys) == 0:
            return
        y0, y1 = ys.min(), ys.max()
        for i in rr.choice(len(ys), size=int(len(ys) * kw.get('density', 0.12)), replace=False):
            x, y = xs[i], ys[i]
            t = (y - y0) / max(1, y1 - y0)
            w = 1 + int(t * 2.5 * rr.uniform(0.5, 1.2))          # stones grow nearer
            lit = litz[y, x]
            top = ix['l2'] if lit else ix['s3']
            under = ix['s0']
            for k in range(w):
                cv.put(x + k, y, top if rr.uniform() < 0.8 else ix['l0'])
            if w > 1 or rr.uniform() < 0.5:
                for k in range(w):
                    cv.put(x + k, y + 1, under)

    def _wood(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly)
        lev = self.levels(m, [0.35, 0.7], 0.7)
        litz = ~self.cast
        cv.a[m & litz] = np.array([ix['s2'], ix['l1'], ix['l3']])[lev][m & litz]
        cv.a[m & ~litz] = np.array([ix['s0'], ix['s1'], ix['s3']])[lev][m & ~litz]
        under = m & ~np.roll(m, -1, 0)
        cv.a[under] = ix['s0']
        top = m & ~np.roll(m, 1, 0) & litz
        cv.a[top] = ix['l3']

    def _snow(self, cv, ly):
        m = ly['mask']; ix = self.ix(ly)
        lev = self.levels(m, [0.3, 0.6], 1.0)
        litz = ~self.cast
        cv.a[m & litz] = np.array([ix['2'], ix['1'], ix['0']])[lev][m & litz]
        cv.a[m & ~litz] = np.array([ix['6'], ix['5'], ix['5']])[lev][m & ~litz]

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image
from okl import *
from sheet import zoom
im=Image.open('places/enchant_photo.jpg').convert('RGB').resize((200,300),Image.BOX)
a=np.asarray(im,float)/255; l=lab_to_lch(rgb_to_oklab(a))
L,C,h=l[...,0],l[...,1],np.degrees(l[...,2])%360
cls=np.zeros(L.shape,int)
cls[(h>200)&(h<290)&(C>0.05)&(L>0.5)]=1  # blue sky/water
cls[(h>60)&(h<110)&(C>0.08)]=2           # larch yellow
cls[(L>0.8)&(C<0.05)]=3                  # white rock/snow
out=np.array([[.3,.3,.3],[.4,.6,1],[1,.8,0],[1,1,1]])[cls]
zoom(np.concatenate([a,out],1),2).save('(manager scratchpad)/encls.png')
EOF

# output:
(Bash completed with no output)

"""Place study: the Enchantments, Prusik Peak over a tarn with larches, painted the Oga way. 200x300.
Photo: places/enchant_photo.jpg ('Gnome tarn on ice', openverse; see places/refs/*/sources.tsv).

Oga's decisions:
  [7] one light, concentrated: the sun on the peak's face and the larch band; the whole near shore
      and water lie in the shadow of the ridge behind the viewer (shadow ~ 2/3, C-0792). The left
      shoulder of the peak turns away and is in shadow too.
  [6] planes: sky / peak (rising) / larch and boulder shore (the severing band, p.52) / the tarn
      (lying plane, mirror) / near boulders and tussocks.
  [10] shadow colour: the shaded shore keeps its colours (tussock ochre, granite warm grey) at low
      value; the water in shadow shows the bed (clear water, C-0792).
  [1] the one saturated note: the larch gold, in light. Everything else near-neutral.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from painter import Scene, lch
from copykit import Canvas

W, H = 200, 300


def poly(cv, pts):
    return cv.mask_poly(pts)


def paint(seed=11):
    photo = np.asarray(Image.open(f'{ROOT}/places/enchant_photo.jpg').convert('RGB').resize((W, H), Image.BOX), float) / 255
    tmp = Canvas(W, H, np.zeros((1, 3)))
    yy, xx = np.mgrid[0:H, 0:W]
    peak = poly(tmp, [(0, 90), (10, 78), (24, 72), (40, 74), (48, 64), (60, 56), (72, 44), (80, 34), (88, 22), (92, 24),
                      (98, 40), (108, 46), (116, 62), (126, 70), (140, 70), (152, 72), (168, 78), (184, 84), (200, 94), (200, 128), (0, 128)])
    shoulder = poly(tmp, [(0, 90), (10, 78), (24, 72), (40, 74), (50, 100), (46, 128), (0, 128)])
    larch = poly(tmp, [(0, 104), (16, 98), (30, 96), (40, 104), (60, 112), (76, 118), (100, 112), (130, 108), (150, 104), (170, 108),
                       (190, 112), (200, 110), (200, 132), (0, 132)])
    shore = poly(tmp, [(0, 118), (30, 116), (60, 122), (100, 126), (140, 126), (170, 124), (200, 126), (200, 140), (150, 136),
                       (100, 136), (50, 142), (0, 150)])
    water = (yy >= 132) & ~shore | (yy >= 150)
    line = np.array([np.argmax(water[:, x]) for x in range(W)])
    boulders = [poly(tmp, p) for p in (
        [(0, 196), (8, 194), (18, 198), (20, 214), (10, 220), (0, 218)], [(14, 200), (26, 196), (36, 200), (38, 214), (26, 220), (16, 216)],
        [(70, 206), (84, 200), (98, 196), (112, 194), (122, 204), (118, 218), (96, 222), (78, 218)],
        [(166, 204), (178, 200), (194, 204), (190, 212), (172, 212)], [(88, 240), (100, 238), (116, 244), (112, 252), (92, 250)],
        [(70, 206), (80, 202), (88, 206), (86, 212), (74, 212)], [(0, 150), (20, 148), (40, 150), (34, 158), (10, 160), (0, 158)],
        [(170, 132), (186, 128), (200, 130), (200, 138), (180, 140)])]
    tuss = [poly(tmp, p) for p in ([(0, 190), (16, 186), (40, 190), (52, 200), (40, 206), (18, 204), (0, 206)],
                                   [(30, 244), (48, 238), (66, 242), (70, 256), (60, 272), (40, 276), (30, 264)])]
    sky = ~peak & (yy < 128)
    rock_all = peak & ~larch
    sc = Scene(W, H, photo, seed=seed)
    sc.add('sky', 'sky', sky, ramp=[(0.50, 0.14, 262), (0.57, 0.13, 258), (0.64, 0.11, 254), (0.71, 0.09, 250), (0.78, 0.07, 245), (0.84, 0.05, 240)])
    sc.add('peak', 'rock', rock_all & ~shoulder, key=(0.80, 0.012, 80), shadow=np.zeros((H, W), bool), rim_p=0.35, drift=-0.15)
    sc.add('shoulder', 'rock', rock_all & shoulder, key=(0.66, 0.012, 80), shadow=np.ones((H, W), bool), rim_p=0.0)
    sc.add('larch', 'broadleaf', larch & ~shore, key=(0.74, 0.14, 82), r=(1.4, 2.0), step=3)
    sc.add('shore', 'rock', shore, key=(0.84, 0.01, 90), rim_p=0.2)
    sc.add('tarn', 'water', water & ~np.any(boulders, 0) & ~np.any(tuss, 0), key=(0.40, 0.03, 225), line=line,
           squash=1.15, bed=(yy > 205), dash_t=1.3, rim=(0.66, 0.08, 250))
    for i, b in enumerate(boulders):
        sc.add(f'b{i}', 'rock', b, key=(0.80, 0.012, 80), rim_p=0.4)
    for i, t in enumerate(tuss):
        sc.add(f't{i}', 'meadow', t, key=(0.66, 0.08, 78), tuft=0.25, lens=(1, 4))
    # the designed light: everything below the larch band is in the ridge's shadow; so is the shoulder
    sc.light(cast=(yy > 132) | shoulder, sun=+1)
    cv = sc.paint()
    return cv, sc


if __name__ == '__main__':
    from sheet import zoom, grid, fit
    cv, sc = paint()
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/places/out/enchant.png')
    photo = Image.open(f'{ROOT}/places/enchant_photo.jpg').resize((W, H), Image.LANCZOS)
    grid([zoom(photo, 2), zoom(cv.rgb(), 2)], 2, ['photo', 'painted the Oga way, 200x300, 2x'], title='Enchantments: Prusik Peak and a tarn').save(f'{ROOT}/sheets/place_enchant.png')

mkdir -p ~/work/pixelart-studies/books/oga/places/out; cd ~/work/pixelart-studies/books/oga && python3 places/enchant.py

# output:
Exit code 1
Traceback (most recent call last):
  File "~/work/pixelart-studies/books/oga/places/enchant.py", line 72, in <module>
    cv, sc = paint()
             ^^^^^^^
  File "~/work/pixelart-studies/books/oga/places/enchant.py", line 66, in paint
    cv = sc.paint()
         ^^^^^^^^^^
  File "~/work/pixelart-studies/books/oga/src/painter.py", line 121, in paint
    getattr(self, '_' + ly['mat'])(cv, ly)
  File "~/work/pixelart-studies/books/oga/src/painter.py", line 258, in _water
    if kw.get('bed'):
       ^^^^^^^^^^^^^
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

cd ~/work/pixelart-studies/books/oga && sed -i '' "s/        if kw.get('bed'):/        if kw.get('bed') is not None:/" src/painter.py && python3 places/enchant.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/painter.py').read()
s=s.replace("        L = L0 - 0.10 - spread[1] * t * 1.4","        L = L0 - 0.16 - spread[1] * t * 1.6")
a=s.index("    def _water(self, cv, ly):"); b=s.index("    def _gravel(self, cv, ly):")
s=s[:a]+'''    def _down_map(self, cv, dl=0.09):
        """index -> the palette entry nearest to 'one step down' (L - dl, slightly less chroma)."""
        lab = rgb_to_oklab(cv.pal)
        tgt = lab * np.array([1, 0.85, 0.85]) - np.array([dl, 0, 0])
        d = ((tgt[:, None] - lab[None]) ** 2 * np.array([2, 1, 1])).sum(-1)
        return np.argmin(d, 1)

    def _water(self, cv, ly):
        """the mirror near the waterline, the clear bed further down (you look INTO the water near your
        feet), horizontal breaks between them; sky-coloured dash rows only in the mirror part."""
        m = ly['mask']; ix = self.ix(ly); kw = ly['kw']
        H, W = self.H, self.W
        line = kw['line']
        src = cv.a.copy()
        down = self._down_map(cv, kw.get('dl', 0.09))
        rr = np.random.default_rng(self.seed + 13)
        n = gaussian_filter(rr.standard_normal((H, W)), (0.35, 3.0)); n = (n - n.mean()) / n.std()
        refl_len = kw.get('refl_len', 60)
        # bed: organised values of the form source, in the water's shadow/warm family
        lev = self.levels(m, [0.35, 0.7], 1.2)
        bed = np.array([ix['s0'], ix['s1'], ix['w']])[lev]
        for x in range(W):
            y0 = int(line[x])
            for y in range(y0, H):
                if not m[y, x]:
                    continue
                d = y - y0
                p = np.exp(-d / refl_len)                 # chance the surface shows the mirror
                ys = int(round(y0 - 1 - d * kw.get('squash', 1.0)))
                if n[y, x] * 0.5 + (p - 0.5) * 3 > 0 and 0 <= ys < H and not m[ys, x]:
                    cv.a[y, x] = down[src[ys, x]]
                else:
                    cv.a[y, x] = bed[y, x]
        dash = m & (n > kw.get('dash_t', 1.5)) & (rr.uniform(size=(H, W)) < 0.7)
        cv.a[dash & (np.arange(H)[:, None] < line[None, :] + refl_len)] = ix['rim']
        # 1-px dark line where the water meets the shore (contact)
        for x in range(W):
            y0 = int(line[x])
            if 0 <= y0 < H and m[y0, x]:
                cv.a[y0, x] = ix['s0']

'''+s[b:]
open('src/painter.py','w').write(s)
s=open('places/enchant.py').read()
s=s.replace("squash=1.15, bed=(yy > 205), dash_t=1.3, rim=(0.66, 0.08, 250))","squash=1.15, refl_len=70, dash_t=1.6, rim=(0.66, 0.08, 250))")
s=s.replace("key=(0.40, 0.03, 225), line=line,","key=(0.46, 0.04, 70), line=line,")
open('places/enchant.py','w').write(s)
EOF
python3 places/enchant.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/painter.py').read()
s=s.replace("        bed = np.array([ix['s0'], ix['s1'], ix['w']])[lev]","        bed = np.array([ix['s2'], ix['w'], ix['l0']])[lev]")
s=s.replace("""        lev = self.levels(m, [0.3, 0.55, 0.82], kw.get('sigma', 1.0))
        litz = ~self.cast & ~kw.get('shadow', np.zeros_like(m))
        lit_names = np.array([ix['s2'], ix['l0'], ix['l1'], ix['l2']])
        sh_names = np.array([ix['s0'], ix['s1'], ix['s2'], ix['s3']])""","""        lev = self.levels(m, [0.18, 0.4, 0.62, 0.85], kw.get('sigma', 1.0))
        litz = ~self.cast & ~kw.get('shadow', np.zeros_like(m))
        lit_names = np.array([ix['s1'], ix['s3'], ix['l0'], ix['l1'], ix['l2']])
        sh_names = np.array([ix['s0'], ix['s0'], ix['s1'], ix['s2'], ix['s3']])""")
open('src/painter.py','w').write(s)
EOF
python3 places/enchant.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/painter.py').read()
s=s.replace("""        cv.mottle(m & ~litz & (cv.a == ix['s3']), ix['w'], 0.3, 2.0)""","""        cv.mottle(m & ~litz & (cv.a == ix['s3']), ix['w'], 0.3, 2.0)
        # in shadow, the planes that face up take the sky (reflected light, p.56): the top 2 px of each
        # mass a light shadow step, its top edge a 1-px line of sky colour
        if kw.get('skylight', True):
            top1 = m & ~np.roll(m, 1, 0) & ~litz
            top2 = m & ~np.roll(m, 2, 0) & ~litz & ~top1
            top3 = m & ~np.roll(m, 3, 0) & ~litz & ~top1 & ~top2
            cv.a[top2 | top3] = ix['s3']
            cv.a[top1] = ix['rim']""")
open('src/painter.py','w').write(s)
EOF
python3 places/enchant.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
from PIL import Image
from sheet import zoom
for n,w in [('olycoast',320),('yakima',320),('sanjuan',320)]:
    im=Image.open(f'places/{n}_photo.jpg').convert('RGB'); h=round(im.height*w/im.width); im=im.resize((w,h),Image.BOX)
    print(n,w,h)
EOF

# output:
olycoast 320 172
yakima 320 213
sanjuan 320 320

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
import numpy as np
from PIL import Image
from okl import *
from sheet import zoom
from scipy.ndimage import gaussian_filter
for n,H in [('olycoast',172),('yakima',213),('sanjuan',320)]:
    a=np.asarray(Image.open(f'places/{n}_photo.jpg').convert('RGB').resize((320,H),Image.BOX),float)/255
    L=gaussian_filter(rgb_to_oklab(a)[...,0],1)
    q=np.digitize(L,np.quantile(L,[.25,.5,.75]))
    out=np.array([[0,0,0],[.35,.35,.35],[.65,.65,.65],[1,1,1]])[q]
    zoom(np.concatenate([a,out],1),2).save(f'(manager scratchpad)/n_{n}.png')
EOF

# output:
(Bash completed with no output)

"""Place study: the Olympic coast, driftwood on the gravel at Rialto Beach under a coastal forest. 320x172.
Photo: places/olycoast_photo.jpg ('Driftwood along Rialto Beach 2022', Sea Cow, CC BY-SA 4.0).

Oga's decisions:
  [4] an overcast sea-coast day: the tone range is narrow, so the range lives in coloured greys
      (C39-5, p.103): violet-grey sky, green-grey forest, warm brown-grey gravel.
  [7] light concentrated anyway: a break in the cloud lets one pale beam onto the driftwood root and
      the gravel around it (C-0022: 'one thin ray gives awe'). Forest and far beach stay in shadow.
  [6] planes: sky / the forest wall (tips break the sky) / the beach-grass band (severing band) /
      the gravel plane (stones grow toward us) / the driftwood (the point).
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter, binary_opening
from okl import rgb_to_oklab
from painter import Scene
from copykit import Canvas

W, H = 320, 172


def paint(seed=21):
    photo = np.asarray(Image.open(f'{ROOT}/places/olycoast_photo.jpg').convert('RGB').resize((W, H), Image.BOX), float) / 255
    L = gaussian_filter(rgb_to_oklab(photo)[..., 0], 0.8)
    yy, xx = np.mgrid[0:H, 0:W]
    t = Canvas(W, H, np.zeros((1, 3)))
    sky = (L > 0.74) & (yy < 75)
    sky = binary_opening(sky, iterations=1)
    wood = np.zeros((H, W), bool)
    for p in ([(112, 140), (118, 132), (150, 126), (180, 120), (206, 114), (212, 122), (184, 130), (150, 136), (120, 144)],
              [(206, 100), (224, 96), (246, 100), (264, 106), (270, 120), (266, 146), (252, 156), (230, 152), (212, 140), (204, 120)],
              [(186, 112), (196, 100), (206, 88), (212, 90), (204, 104), (196, 114)], [(216, 92), (222, 78), (226, 80), (222, 96)],
              [(54, 150), (70, 144), (88, 140), (90, 144), (72, 150), (58, 154)], [(160, 106), (200, 102), (240, 104), (300, 104), (318, 108), (300, 110), (240, 110), (170, 112)],
              [(0, 116), (20, 114), (40, 116), (20, 118), (0, 119)]):
        wood |= t.mask_poly(p)
    grassband = (yy >= 84) & (yy < 104) & ~sky
    forest = (yy < 96) & ~sky & ~grassband
    gravel = (yy >= 96) & ~wood & ~grassband | ((yy >= 104) & ~wood)
    grassband &= ~wood
    sc = Scene(W, H, photo, seed=seed)
    sc.add('sky', 'sky', sky, ramp=[(0.72, 0.012, 300), (0.77, 0.012, 295), (0.82, 0.01, 285), (0.87, 0.008, 270), (0.91, 0.006, 250)], reach=1.4)
    sc.add('forest', 'conifer', forest, key=(0.46, 0.04, 165), h=(8, 22), spacing=4, n_inner=20)
    sc.add('grass', 'meadow', grassband, key=(0.62, 0.07, 125), tuft=0.12, lens=(1, 4))
    sc.add('gravel', 'gravel', gravel, key=(0.58, 0.012, 60), density=0.16)
    sc.add('wood', 'wood', wood, key=(0.80, 0.02, 75))
    # the beam: an oval of light on the driftwood and gravel around it
    beam = (((xx - 200) / 95.0) ** 2 + ((yy - 128) / 34.0) ** 2) < 1
    beam = beam | (((xx - 200) / 60.0) ** 2 + ((yy - 110) / 30.0) ** 2 < 1) & wood
    sc.light(cast=~beam, sun=+1)
    return sc.paint(), sc


if __name__ == '__main__':
    from sheet import zoom, grid, fit
    cv, sc = paint()
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/places/out/olycoast.png')
    photo = Image.open(f'{ROOT}/places/olycoast_photo.jpg').resize((W, H), Image.LANCZOS)
    before = Image.open(f'{ROOT}/places/olycoast_pair_right.png')
    grid([zoom(photo, 2), fit(before, w=640), zoom(cv.rgb(), 2)], 1,
         ['photo (Rialto Beach driftwood, Sea Cow, CC BY-SA 4.0)', 'a place-olycoast lane render (different view, for the current look)', 'painted the Oga way, 320x172, 2x'],
         title='Olympic coast: driftwood at Rialto').save(f'{ROOT}/sheets/place_olycoast.png')

cd ~/work/pixelart-studies/books/oga && python3 places/olycoast.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/olycoast.py').read()
s=s.replace("sc.add('gravel', 'gravel', gravel, key=(0.58, 0.012, 60), density=0.16)","sc.add('gravel', 'gravel', gravel, key=(0.56, 0.014, 60), density=0.10, pal=dict(spread=(0.05, 0.14)))")
s=s.replace("""    beam = (((xx - 200) / 95.0) ** 2 + ((yy - 128) / 34.0) ** 2) < 1""","""    nz = gaussian_filter(np.random.default_rng(3).standard_normal((H, W)), 2.0); nz /= nz.std()
    beam = (((xx - 200) / 95.0) ** 2 + ((yy - 128) / 30.0) ** 2) + 0.12 * nz < 1""")
open('places/olycoast.py','w').write(s)
s=open('src/painter.py').read()
# gravel: far grain -> near stones; stones horizontal; fewer
s=s.replace("""            w = 1 + int(t * 2.5 * rr.uniform(0.5, 1.2))          # stones grow nearer""","""            if rr.uniform() > 0.25 + 0.75 * t:                   # far: fewer marks, finer grain
                continue
            w = 1 + int(t * 3.0 * rr.uniform(0.4, 1.2))          # stones grow nearer""")
open('src/painter.py','w').write(s)
EOF
python3 places/olycoast.py

# output:
(Bash completed with no output)

"""Place study: the Yakima River canyon, dry hills over a willow-lined river. 320x180.
Photo: places/yakima_photo.jpg ('Umptanum Ridge water gap', Wikimedia Commons; sources.tsv).

Oga's decisions:
  [11] dry interior air, low humidity: good nuke; the far ridge is crisp, only a step bluer.
  [7] the sun from the left and behind: the big grass ramp is the lit plane; the near-left slope and
      the right shoulder (under a cloud shadow) are in shadow. Light concentrated on the ramp.
  [6] planes: sky / far ridge / the lit ramp and dark slopes / the terrace (flat, lying) / the willow
      band (severs the river from the hills) / the river (mirror) / near dry grass.
  [4][10] shadows full of colour: the shaded slope is violet-brown, not grey; the willows are
      red-brown in winter; the river mirrors them one step down.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter, binary_opening
from okl import rgb_to_oklab, lab_to_lch
from painter import Scene
from copykit import Canvas

W, H, OY = 320, 180, 16


def paint(seed=31):
    photo = np.asarray(Image.open(f'{ROOT}/places/yakima_photo.jpg').convert('RGB').resize((W, 213), Image.BOX), float)[OY:OY + H] / 255
    lab = rgb_to_oklab(photo); L = gaussian_filter(lab[..., 0], 0.8)
    yy, xx = np.mgrid[0:H, 0:W]
    t = Canvas(W, H, np.zeros((1, 3)))
    S = lambda pts: [(x, y - OY) for x, y in pts]
    hill_line = t.mask_poly(S([(0, 16), (0, 50), (40, 44), (100, 32), (160, 18), (200, 6), (224, 0 + 16), (224, 16)]))
    sky = (yy < 60) & ~(yy >= np.interp(xx, [0, 40, 100, 160, 200, 222, 320], np.array([50, 44, 32, 18, 6, 0, -10]) - OY))
    far = t.mask_poly(S([(0, 50), (40, 44), (100, 32), (150, 22), (140, 34), (90, 44), (40, 56), (0, 64)])) & ~sky
    bank = np.interp(xx, [0, 320], [110 - OY, 125 - OY])
    hills = ~sky & ~far & (yy < 78 - OY)
    terrace = (yy >= 78 - OY) & (yy < 96 - OY)
    willow = (yy >= 92 - OY) & (yy < bank) & ~terrace | ((yy >= 96 - OY) & (yy < bank))
    near = t.mask_poly(S([(0, 170), (60, 168), (120, 172), (200, 176), (250, 190), (262, 213), (0, 213)]))
    river = (yy >= bank) & ~near
    line = np.array([int(np.argmax(river[:, x])) if river[:, x].any() else H for x in range(W)])
    sc = Scene(W, H, photo, seed=seed)
    sc.add('sky', 'sky', sky, ramp=[(0.72, 0.08, 250), (0.78, 0.065, 247), (0.84, 0.05, 244), (0.90, 0.03, 240)], reach=1.6)
    sc.add('far', 'far', far, key=(0.62, 0.03, 60), air=0.35, horizon=(0.84, 0.04, 245))
    sc.add('hills', 'meadow', hills, key=(0.72, 0.06, 80), tuft=0.03, lens=(1, 2), sigma=2.0,
           pal=dict(sky_h=300))                           # shadowed slopes go violet-brown
    sc.add('terrace', 'meadow', terrace, key=(0.70, 0.05, 85), tuft=0.06, lens=(1, 2))
    sc.add('willow', 'broadleaf', willow, key=(0.55, 0.07, 40), r=(1.6, 2.4), step=3)
    sc.add('river', 'water', river, key=(0.42, 0.03, 200), line=line, refl_len=400, squash=1.0, dash_t=1.4,
           rim=(0.80, 0.05, 240))
    sc.add('near', 'meadow', near, key=(0.74, 0.07, 78), tuft=0.35, lens=(2, 7), sigma=1.2)
    cloud = (xx > 236) & (yy < 70 - OY) | (xx < 70) & (yy < 80 - OY)
    sc.light(cast=cloud, sun=-1)
    return sc.paint(), sc


if __name__ == '__main__':
    from sheet import zoom, grid, fit
    cv, sc = paint()
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/places/out/yakima.png')
    photo = Image.open(f'{ROOT}/places/yakima_photo.jpg').resize((W, 213), Image.LANCZOS).crop((0, OY, W, OY + H))
    before = Image.open(f'{ROOT}/places/yakima_pair_right.png')
    grid([zoom(photo, 2), fit(before, w=640), zoom(cv.rgb(), 2)], 1,
         ['photo (Umptanum Ridge water gap, Yakima River, Wikimedia Commons)', 'a place-yakima lane render (evening)', 'painted the Oga way, 320x180, 2x'],
         title='Yakima canyon').save(f'{ROOT}/sheets/place_yakima.png')

cd ~/work/pixelart-studies/books/oga && python3 places/yakima.py

# output:
(Bash completed with no output)

"""Place study: the Yakima River canyon, dry hills over a willow-lined river. 320x180. Hand-designed.
Photo: places/yakima_photo.jpg (Umptanum Ridge water gap, Wikimedia Commons; see places/refs sources.tsv)

(The first version ran this through the generic painter, src/painter.py: rectangular cloud boxes, the
hills mirrored in a river 30 m wide, willow noise. Kept as a lesson in LESSONS.md.)

Oga's decisions, plane by plane (MODEL sections):
  sky        3 flat bands of pale celeste, a flat white cloud lobe (low humidity, clear: [11])
  far ridge  a crisp far range, sky-tinted violet with snow patches, 2 values ([11] air, p.54)
  left slope turned from the sun: in shadow, violet-brown, a few gully lines ([7] shadow colour)
  the ramp   the lit plane, warm straw, graded by a hake from the lit crest down ([5] hake);
             the rimrock band: a row of dark basalt facets with lit tops (the 'clearly shaped thing'
             that lets the vague grass read as a huge slope, C-0064 p.52)
  shoulder   under a cloud shadow whose edge follows the slope's fall line, violet ([7], p.56)
  terrace    a flat lying plane, pale; a fence line and one pine for scale
  willows    the severing band ([6], p.52): red-brown winter stems as vertical strokes, lit tips,
             a gold fringe of dry grass at the cut bank
  river      short mirror of the band, one step down; then the water's own green-grey; the sky's
             light sheen on the left; horizontal dash rows; the drift boat as the one point
  near grass dry straw tufts, long blades lit, dark gaps (top view near, p.53)
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab
from copykit import Canvas, majority
import vocab as V

W, H = 320, 180


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(
    sk0=c(0.76, 0.07, 250), sk1=c(0.82, 0.055, 246), sk2=c(0.88, 0.035, 240), cl=c(0.96, 0.008, 230), cl2=c(0.90, 0.012, 250),
    fr1=c(0.72, 0.03, 290), fr2=c(0.64, 0.035, 295), sn=c(0.93, 0.01, 250),
    ls1=c(0.42, 0.035, 330), ls2=c(0.50, 0.035, 340), ls3=c(0.35, 0.03, 320),          # the shaded slope
    ra1=c(0.86, 0.06, 88), ra2=c(0.80, 0.065, 82), ra3=c(0.74, 0.065, 76), ra4=c(0.67, 0.06, 70),  # the lit ramp
    rk1=c(0.30, 0.025, 50), rk2=c(0.62, 0.05, 70),                                      # basalt, lit top
    sb=c(0.55, 0.045, 110),                                                              # sage dots
    sh1=c(0.56, 0.04, 320), sh2=c(0.50, 0.04, 315),                                      # cloud shadow on the ramp
    te1=c(0.80, 0.05, 90), te2=c(0.72, 0.05, 88), fence=c(0.45, 0.03, 70),
    pn1=c(0.38, 0.05, 150), pn2=c(0.26, 0.035, 160),
    wi1=c(0.62, 0.07, 30), wi2=c(0.52, 0.07, 25), wi3=c(0.42, 0.06, 20), wi4=c(0.33, 0.04, 20), wit=c(0.74, 0.06, 40),
    go1=c(0.80, 0.11, 78), go2=c(0.68, 0.10, 70), bank=c(0.40, 0.04, 60),
    wa1=c(0.46, 0.035, 190), wa2=c(0.40, 0.035, 195), wa3=c(0.34, 0.03, 200), wsky=c(0.72, 0.03, 230), wsky2=c(0.62, 0.03, 220),
    wdash=c(0.80, 0.03, 235),
    boat=c(0.35, 0.03, 200), red=c(0.55, 0.14, 25), blu=c(0.45, 0.10, 255),
    ng1=c(0.86, 0.06, 85), ng2=c(0.76, 0.07, 80), ng3=c(0.62, 0.06, 70), ng4=c(0.42, 0.04, 60),
)
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])


def line_y(pts, xx):
    return np.interp(xx, [p[0] for p in pts], [p[1] for p in pts])


def paint(seed=31):
    cv = Canvas(W, H, PAL, bg=I['sk1'], seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]
    r = np.random.default_rng(seed)
    SKYLINE = [(0, 34), (40, 28), (100, 16), (160, 4), (200, -6), (320, -20)]
    FAR_BASE = [(0, 50), (40, 44), (80, 38), (120, 30), (150, 22), (165, 16)]
    RAMP_TOP = [(60, 60), (100, 44), (140, 28), (180, 12), (210, 0), (320, -10)]
    TERRACE = [(0, 64), (60, 64), (120, 62), (200, 60), (260, 58), (320, 58)]
    BAND_TOP = [(0, 76), (60, 78), (120, 80), (200, 80), (260, 80), (320, 82)]
    BANK = [(0, 94), (80, 98), (160, 101), (240, 104), (320, 108)]
    sky = yy < line_y(SKYLINE, xx)
    # ---- sky: bands and a flat cloud lobe
    V.sky_bands(cv, sky, ['sk0', 'sk1', 'sk2'], I, 0, 40, seed=seed)
    cv.mass([(0, 0), (60, 0), (110, 4), (90, 10), (40, 14), (0, 18)], I['cl'], wet=1.5, where=sky)
    cv.mass([(0, 12), (40, 12), (70, 8), (50, 16), (10, 22)], I['cl2'], wet=1.0, where=sky)
    # ---- far ridge
    far = ~sky & (yy < line_y(FAR_BASE, xx)) & (xx < 170)
    cv.a[far] = I['fr1']
    cv.a[far & (yy > line_y(SKYLINE, xx) + 6)] = I['fr2']
    for (x, y) in [(60, 26), (72, 24), (90, 20), (104, 18), (118, 16), (130, 14)]:
        cv.mass([(x, y), (x + 5, y - 1), (x + 3, y + 1)], I['sn'], where=far)
    # ---- left slope (shadow) and the lit ramp
    slope = ~sky & ~far & (yy < line_y(TERRACE, xx))
    ramp = slope & (yy < line_y(RAMP_TOP, xx) + (xx - 60) * 0.0) & False
    lit_ramp = slope & ((yy - line_y(RAMP_TOP, xx)) > 0) & (xx > 70)
    shaded = slope & ~lit_ramp
    cv.a[shaded] = I['ls1']
    cv.mottle(shaded, I['ls2'], 0.25, 3.0)
    for pts in ([(20, 44), (30, 56), (36, 62)], [(48, 40), (52, 52), (58, 62)], [(8, 50), (12, 62)]):
        cv.line(pts, I['ls3'])
    # the ramp: a hake gradation from the lit crest (upper left) down and right
    V_ = ((xx - 90) * 0.5 + (yy - 20) * 1.0)
    t = np.clip(V_ / 120, 0, 0.999) * 4
    q = np.clip(np.floor(t + 0.6 * cv.noise(1.2) * ((t % 1 < 0.25) | (t % 1 > 0.75))), 0, 3).astype(int)
    cv.a[lit_ramp] = np.array([I['ra1'], I['ra2'], I['ra3'], I['ra4']])[q][lit_ramp]
    # the rimrock: a row of dark basalt facets with a lit top line, following the slope contour
    for x0 in range(176, 320, 7):
        y0 = 30 + (x0 - 176) * 0.02 + r.integers(-1, 2)
        w = int(r.integers(4, 7)); h = int(r.integers(3, 6))
        cv.mass([(x0, y0), (x0 + w, y0 + 1), (x0 + w - 1, y0 + h), (x0 + 1, y0 + h - 1)], I['rk1'], where=slope)
        cv.line([(x0, y0), (x0 + w, y0 + 1)], I['rk2'])
    cv.line([(176, 36), (320, 40)], I['rk1'])
    # sage dots scattered on the lit ramp, sparser uphill (far)
    ys, xs = np.nonzero(lit_ramp)
    for i in r.choice(len(ys), size=110, replace=False):
        if r.uniform() < (ys[i] / 60):
            cv.dab(xs[i], ys[i], I['sb'], 'dot' if ys[i] < 40 else 'h2')
    # the shoulder in a cloud shadow whose edge follows the fall line (diagonal, soft)
    cloud = lit_ramp & ((xx - 250) - (yy - 10) * 0.9 + 5 * cv.noise(2.5) > 0)
    cv.a[cloud & np.isin(cv.a, [I['ra1'], I['ra2']])] = I['sh1']
    cv.a[cloud & np.isin(cv.a, [I['ra3'], I['ra4'], I['sb']])] = I['sh2']
    cv.snapshot('1 sky, far ridge, the shaded slope, the lit ramp (hake), rimrock, cloud shadow')
    # ---- terrace: flat, pale; fence line; one pine
    terr = ~sky & (yy >= line_y(TERRACE, xx)) & (yy < line_y(BAND_TOP, xx))
    cv.a[terr] = I['te1']
    cv.mottle(terr, I['te2'], 0.35, 2.5)
    cv.line([(0, 69), (120, 67), (320, 64)], I['fence'])
    for x in range(4, 320, 9):
        cv.put(x, int(round(69 - x * 0.0156)) - 1, I['fence'])
    V.spire(cv, 30, 86, 26, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=4)
    V.spire(cv, 44, 80, 12, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=3)
    cv.snapshot('2 terrace, fence, pines')
    # ---- the willow band: vertical strokes, lit tips, gold fringe at the bank
    band = (yy >= line_y(BAND_TOP, xx)) & (yy < line_y(BANK, xx))
    cv.a[band] = I['wi3']
    for x in range(W):
        top = int(np.ceil(line_y(BAND_TOP, x))) + int(2 * np.sin(x * 0.7) + r.integers(-1, 2))
        bot = int(line_y(BANK, x))
        for y in range(max(0, top), bot):
            k = (y - top) / max(1, bot - top)
            v = r.uniform()
            idx = I['wi1'] if v < 0.3 - 0.2 * k else (I['wi2'] if v < 0.65 else (I['wi3'] if v < 0.9 else I['wi4']))
            if (x + y // 2) % 3 == 0:
                idx = I['wi4'] if k > 0.3 else I['wi2']        # vertical stem gaps
            cv.a[y, x] = idx
        if top >= 0 and r.uniform() < 0.6:
            cv.put(x, top - 1, I['wit'])                         # stem tips breaking the top edge
            if r.uniform() < 0.4:
                cv.put(x, top - 2, I['wit'])
        # gold fringe: the last 4-6 rows above the bank
        gl = int(r.integers(3, 7))
        for y in range(bot - gl, bot):
            cv.put(x, y, I['go1'] if (y - (bot - gl)) < gl // 2 or r.uniform() < 0.3 else I['go2'])
        cv.put(x, bot, I['bank'])
    cv.snapshot('3 willow band: vertical stems, lit tips, gold fringe, dark cut bank')
    # ---- river
    river = (yy > line_y(BANK, xx))
    near = cv.mask_poly([(0, 150), (60, 148), (120, 152), (200, 156), (250, 168), (262, 180), (0, 180)])
    river &= ~near
    src = cv.a.copy()
    down = {I['go1']: I['go2'], I['go2']: I['bank'], I['wi1']: I['wi2'], I['wi2']: I['wi3'], I['wi3']: I['wi4'],
            I['wi4']: I['wa3'], I['wit']: I['wi2'], I['bank']: I['wa3'], I['te1']: I['wa1'], I['te2']: I['wa1']}
    for x in range(W):
        b = int(line_y(BANK, x))
        for y in range(b + 1, H):
            if not river[y, x]:
                continue
            d = y - b
            ys = b - d                                            # mirror about the bank line
            if d < 20 and ys > line_y(BAND_TOP, x) - 2:
                cv.a[y, x] = down.get(int(src[ys, x]), I['wa2'])
            else:
                cv.a[y, x] = I['wa2']
    # the water's own depth: lighter where the sky is reflected (left, far), darker near/right
    wz = river & (np.arange(H)[:, None] > line_y(BANK, xx) + 18)
    zone = (xx * 0.7 + (yy - 100) * 1.6 + 25 * cv.noise(4.0))
    cv.a[wz & (zone < 60)] = I['wsky']
    cv.a[wz & (zone >= 60) & (zone < 90)] = I['wsky2']
    cv.a[wz & (zone >= 90) & (zone < 200)] = I['wa1']
    cv.a[wz & (zone >= 260)] = I['wa3']
    # horizontal dash rows (ripples), more toward us
    n = gaussian_filter(r.standard_normal((H, W)), (0.3, 3.0)); n /= n.std()
    cv.a[wz & (n > 1.5)] = I['wdash']
    cv.a[wz & (n < -1.6)] = I['wa3']
    # the boat: the one point that gives the scale (C-0773)
    cv.mass([(194, 142), (208, 142), (206, 144), (196, 144)], I['boat'])
    cv.put(198, 140, I['red']); cv.put(198, 141, I['red']); cv.put(202, 140, I['blu']); cv.put(202, 141, I['blu'])
    cv.line([(190, 145), (212, 145)], I['wdash'])
    cv.snapshot('4 river: short mirror of the band, the sky sheen, dash rows, the boat')
    # ---- near dry grass: tufts
    cv.a[near] = I['ng3']
    cv.mottle(near, I['ng4'], 0.3, 2.0)
    ys, xs = np.nonzero(near)
    order = np.argsort(ys)
    for i in order[::6]:
        x, y = xs[i], ys[i]
        L = int(3 + (y - 148) * 0.25 + r.integers(0, 4))
        lean = r.choice([-0.5, -0.25, 0, 0.25, 0.5])
        col = I['ng1'] if r.uniform() < 0.45 else I['ng2']
        for k in range(L):
            X, Y = int(round(x + lean * k)), y - k
            if 0 <= Y < H and 0 <= X < W:
                cv.a[Y, X] = col if k > 0 else I['ng4']
    cv.snapshot('5 near dry grass: tufts, long lit blades')
    return cv


if __name__ == '__main__':
    from sheet import zoom, grid, fit
    cv = paint()
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/places/out/yakima.png')
    photo = Image.open(f'{ROOT}/places/yakima_photo.jpg').resize((W, 213), Image.LANCZOS).crop((0, 16, W, 16 + H))
    before = Image.open(f'{ROOT}/places/yakima_pair_right.png')
    grid([zoom(photo, 2), fit(before, w=640), zoom(cv.rgb(), 2)], 1,
         ['photo (Umptanum Ridge water gap, Yakima River, Wikimedia Commons)', 'a place-yakima lane render (evening)', 'painted the Oga way, by hand, 320x180, 2x'],
         title='Yakima canyon').save(f'{ROOT}/sheets/place_yakima.png')
    grid([zoom(cv.pal[a], 2) for _, a in cv.stages], 2, [n for n, _ in cv.stages], title='Yakima, stage by stage').save(f'{ROOT}/sheets/place_yakima_stages.png')

cd ~/work/pixelart-studies/books/oga && python3 places/yakima.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('plates/lv/C0064_bg.png'); print(im.size)
im.crop((0,200,500,454)).resize((1000,508),Image.LANCZOS).save('(manager scratchpad)/c64g.png')"

# output:
(1168, 454)

cd ~/work/pixelart-studies/books/oga && python3 -c "
import sys; sys.path.insert(0,'src')
from PIL import Image; from sheet import zoom
im=Image.open('plates/lv/C0064_bg.png').crop((10,200,500,440)).resize((122,60),Image.BOX); im.save('copies/p4_ref.png'); zoom(im,8).save('(manager scratchpad)/p4.png')"

# output:
(Bash completed with no output)

"""Passage copy P4: the grass slope of C-0064 (p.52), 122x60 px.

What he does (looked at in plates/lv/C0064_bg.png, full size):
  - the slope is ONE PLANE with an undulation (C-0095, p.53): the crest facing the sun is a broad
    lemon/yellow-green band; the slope turns away below it through mid green into a dark base band.
    The value turn is the whole form; the grass rides on it.
  - strokes follow the slope's flow: tapered wedges leaning along the fall of the slope, not vertical.
  - contrast lives inside the mark: in the lit band, strokes one step DARKER; in the dark band,
    long blades one step LIGHTER, and a few big dark blade silhouettes near the bottom.
  - the boundaries between bands are not lines: blade tips of the lower band break upward into
    the band above, and lit strokes hang down into the band below.
  - points: blue bellflowers as 1-2 px dots on thin dark stems, a few yellow dots at the right.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab
from copykit import Canvas, majority


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(paper=c(0.97, 0.01, 280), lem=c(0.90, 0.17, 108), y1=c(0.83, 0.17, 114), y2=c(0.75, 0.16, 120),
         g1=c(0.64, 0.13, 125), g2=c(0.53, 0.10, 128), g3=c(0.42, 0.075, 125), g4=c(0.32, 0.05, 115), g5=c(0.23, 0.03, 100),
         blue=c(0.58, 0.17, 262), yel=c(0.90, 0.16, 100), trees=c(0.36, 0.07, 130), trees2=c(0.55, 0.12, 122), trees3=c(0.22, 0.03, 140))
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])


def wedge(cv, x, y, L, ang, idx, where=None):
    """a tapered stroke: 2 px wide at its base (x,y), 1 px for the rest, length L, angle (deg, 0=up)."""
    a = np.radians(ang)
    for k in range(L):
        X = int(round(x + np.sin(a) * k)); Y = int(round(y - np.cos(a) * k))
        for w in ([0, 1] if k < L // 3 else [0]):
            if 0 <= Y < cv.H and 0 <= X + w < cv.W and (where is None or where[Y, X + w]):
                cv.a[Y, X + w] = idx


def paint(seed=4):
    ref = Image.open(f'{ROOT}/copies/p4_ref.png').convert('RGB'); W, H = ref.size
    L = gaussian_filter(rgb_to_oklab(np.asarray(ref, float) / 255)[..., 0], 1.0)
    cv = Canvas(W, H, PAL, bg=I['paper'], seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]
    r = np.random.default_rng(seed)
    # masses by hand: the trees behind, the slope, the paper below
    slope_top = lambda x: np.interp(x, [0, 16, 40, 70, 96, 122], [4, 3, 8, 16, 26, 30])
    slope_bot = lambda x: np.interp(x, [0, 10, 60, 122], [46, 54, 56, 58])
    slope = (yy >= slope_top(xx)) & (yy < slope_bot(xx)) & (xx >= 1)
    trees = (yy < slope_top(xx))
    cv.a[trees] = I['trees']
    cv.mottle(trees, I['trees2'], 0.3, 1.2); cv.mottle(trees, I['trees3'], 0.3, 1.5)
    # 1 the plane's value turn: distance below the crest, organised; crest lit band ~ 10-16 px
    d = yy - slope_top(xx)
    depth = slope_bot(xx) - slope_top(xx)
    u = d / depth                                  # 0 at crest, 1 at base
    # his value design modulates the turn a little (organised), e.g. the lit swell at upper left
    Lm = (L - L[slope].mean()) / (L[slope].std() + 1e-6)
    f = u - 0.12 * Lm
    names = ['lem', 'y1', 'y2', 'g1', 'g2', 'g3', 'g4', 'g5']
    t = np.clip(f * 1.15, 0, 0.999) * len(names)
    q = np.clip(np.floor(t), 0, len(names) - 1).astype(int)
    cv.a[slope] = np.array([I[n] for n in names])[q][slope]
    cv.a = majority(cv.a, 2)
    cv.snapshot('1 the plane: crest lit, turning through mid to a dark base (value = form)')
    # 2 strokes along the slope's flow; the slope falls to the left-down, so strokes lean right (up-slope)
    base_ang = 28
    ys, xs = np.nonzero(slope)
    for i in r.choice(len(ys), size=int(len(ys) * 0.16), replace=False):
        x, y = xs[i], ys[i]
        cur = int(cv.a[y, x]); k = [I[n] for n in names].index(cur) if cur in [I[n] for n in names] else 3
        if k <= 2:
            idx = I[names[min(k + 1, 7)]]          # lit band: a darker stroke
            Ls = int(r.integers(2, 4))
        elif k >= 5:
            idx = I[names[max(k - 2, 0)]]          # dark band: a lighter blade
            Ls = int(r.integers(3, 7))
        else:
            idx = I[names[k + (1 if r.uniform() < 0.5 else -1)]]
            Ls = int(r.integers(2, 5))
        wedge(cv, x, y, Ls, base_ang + r.normal(0, 10), idx, where=slope | trees)
    cv.snapshot('2 strokes along the flow, contrast inside the mark')
    # 3 boundary: blade tips of lower bands break upward over the crest line into the trees
    for x in range(1, W):
        y0 = int(slope_top(x))
        if r.uniform() < 0.5:
            wedge(cv, x, y0 + 1, int(r.integers(2, 4)), base_ang - 10 + r.normal(0, 8), I['y1'])
    # 4 big dark blade silhouettes near the base, and stems
    for i in range(14):
        x = int(r.uniform(4, 110)); y = int(slope_bot(x)) - int(r.integers(1, 4))
        wedge(cv, x, y, int(r.integers(8, 16)), r.normal(15, 18), I['g5'])
    for i in range(7):
        x = int(r.uniform(20, 70)); y = int(slope_bot(x)) - 6
        wedge(cv, x, y, int(r.integers(14, 22)), r.normal(10, 10), I['g4'])
    cv.snapshot('3 tips break the crest; dark blade silhouettes at the base')
    # 5 the points: blue bellflowers on stems where his blues are; yellow dots at right
    lab = rgb_to_oklab(np.asarray(ref, float) / 255)
    hue = np.degrees(np.arctan2(lab[..., 2], lab[..., 1])) % 360
    blue = (hue > 240) & (hue < 290) & (np.hypot(lab[..., 1], lab[..., 2]) > 0.08)
    for y, x in zip(*np.nonzero(blue)):
        cv.put(x, y, I['blue'])
    for (x, y) in [(116, 32), (119, 34), (112, 36), (118, 38)]:
        cv.put(x, y, I['yel'])
    cv.snapshot('4 points: bellflowers, yellow dots')
    return cv, ref


if __name__ == '__main__':
    from sheet import zoom, grid
    cv, ref = paint()
    cells = [zoom(ref, 6)] + [zoom(cv.pal[a], 6) for _, a in cv.stages] + [zoom(ref, 2), zoom(cv.rgb(), 2)]
    grid(cells, 2, ['his, reduced'] + [n for n, _ in cv.stages] + ['his 2x', 'mine 2x'], title='P4 grass slope (C-0064), 6x').save(f'{ROOT}/sheets/p4_meadow.png')

cd ~/work/pixelart-studies/books/oga && python3 copies/p4_meadow.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p4_meadow.py').read()
s=s.replace("""        if k <= 2:
            idx = I[names[min(k + 1, 7)]]          # lit band: a darker stroke""","""        if k <= 2:
            if r.uniform() < 0.55:                 # the lit crest stays calm: few strokes (density at points)
                continue
            idx = I[names[min(k + 1, 7)]]          # lit band: a darker stroke""")
open('copies/p4_meadow.py','w').write(s)
EOF
python3 copies/p4_meadow.py; python3 -c "
from PIL import Image
im=Image.open('~/work/pixelart-studies/books/oga/places/sanjuan_photo.jpg'); print(im.size)"

# output:
(1024, 1024)

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('places/sanjuan_photo.jpg').convert('RGB').resize((320,320),Image.BOX).crop((0,40,320,220)); im.save('places/sanjuan_crop.png')" && python3 work/gridref.py places/sanjuan_crop.png 320 3 places/sanjuan_grid.png

# output:
320 180

"""Place study: the San Juan Islands, a camas meadow under Garry oaks at sunset. 320x180. Hand-designed.
Photo: places/sanjuan_photo.jpg ('Garry Oak Meadow, Victoria BC', Nick Kenrick, CC BY-NC-SA 2.0) -- the
same prairie community as the San Juan balds.

Oga's decisions:
  [7] backlight (C2-2: 'backlight is easier: shapes as silhouettes, the light easy to place'): the sun
      low behind the oaks; everything facing us is in shadow; the light lives only at edges facing
      the sun, in the light's COLOUR (際, C-0772), and in the sky seen through the crowns.
  [7] dusk (C58-1A): warm light, cool shadow, purple between blue and pink; harmonious or it muddies.
  [3] the crowd: oaks as crown masses with sky holes and clumpy edges; the meadow as a plane with the
      camas as a crowd of one mark (a violet spike), small and dense far, big and sparse near.
  [14] the kigo: camas in bloom says 'late April on a bald' by itself; no other detail needed.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
from okl import lch_to_lab, oklab_to_rgb, rgb_to_oklab
from copykit import Canvas, majority
import vocab as V

W, H = 320, 180
SUN = (124, 10)


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(
    s0=c(0.99, 0.03, 100), s1=c(0.95, 0.07, 90), s2=c(0.90, 0.09, 75), s3=c(0.84, 0.09, 60), s4=c(0.78, 0.07, 40),
    s5=c(0.73, 0.05, 350), s6=c(0.68, 0.05, 310),
    k1=c(0.24, 0.03, 330), k2=c(0.30, 0.04, 320), k3=c(0.37, 0.045, 340), kw=c(0.46, 0.06, 20),   # crowns: violet darks
    rim1=c(0.80, 0.13, 65), rim2=c(0.70, 0.13, 45),                                               # the light's colour at edges
    tr=c(0.20, 0.02, 330),
    far1=c(0.86, 0.04, 320), far2=c(0.94, 0.05, 80),
    m1=c(0.52, 0.09, 115), m2=c(0.44, 0.08, 125), m3=c(0.36, 0.06, 135), m4=c(0.28, 0.045, 145), mg=c(0.66, 0.11, 105),
    mt=c(0.80, 0.13, 100), mglow=c(0.62, 0.09, 80),
    v1=c(0.72, 0.11, 290), v2=c(0.60, 0.14, 285), v3=c(0.48, 0.14, 280), v4=c(0.40, 0.11, 285), vfar=c(0.60, 0.08, 300),
)
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])


def paint(seed=41):
    cv = Canvas(W, H, PAL, seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]
    r = np.random.default_rng(seed)
    # ---- 1 the sky: radial bands of the glow around the sun, flat, ragged seams
    d = np.hypot((xx - SUN[0]) * 0.8, (yy - SUN[1]) * 1.3)
    t = np.clip(d / 150, 0, 0.999) * 7
    n = cv.noise(1.0)
    q = np.clip(np.floor(t + 0.35 * n * ((t % 1 < 0.2) | (t % 1 > 0.8))), 0, 6).astype(int)
    cv.a[:] = np.array([I[f's{i}'] for i in range(7)])[q]
    cv.snapshot('1 sky: radial glow bands around the low sun')
    # ---- 2 the oak crowns: masses with sky holes; clumpy lower edges; the light's colour on edges
    crowns = np.zeros((H, W), bool)
    for pts in ([(0, 0), (86, 0), (90, 10), (84, 24), (92, 34), (84, 46), (60, 52), (30, 50), (0, 54)],
                [(140, 0), (250, 0), (246, 18), (256, 34), (240, 44), (210, 48), (180, 46), (156, 42), (146, 30), (150, 16)],
                [(296, 20), (310, 12), (320, 10), (320, 50), (300, 50), (290, 40)],
                [(84, 24), (100, 28), (110, 36), (104, 46), (86, 48)],
                [(236, 30), (256, 28), (270, 34), (286, 40), (296, 46), (280, 52), (250, 50)]):
        crowns |= cv.mask_poly(pts)
    # clumpy edges: clumps along the boundary
    edge = crowns & ~np.roll(crowns, 3, 0) | crowns & ~np.roll(crowns, -3, 0) | crowns & ~np.roll(crowns, 3, 1) | crowns & ~np.roll(crowns, -3, 1)
    ys, xs = np.nonzero(edge)
    for i in r.choice(len(ys), size=len(ys) // 5, replace=False):
        rr_ = r.uniform(1.5, 3.2)
        crowns |= (np.hypot((xx - xs[i]) / 1.2, yy - ys[i]) < rr_)
    cv.a[crowns] = I['k2']
    cv.mottle(crowns, I['k1'], 0.4, 2.5)
    cv.mottle(crowns, I['k3'], 0.2, 2.0)
    # sky holes through the crowns, more toward the sun and the crown edges
    near_sun = np.exp(-d / 90)
    holes = crowns & (cv.noise(0.7) > 1.6 - 1.2 * near_sun)
    cv.a[holes] = q[holes] + I['s0']
    # the light's colour where the crown's edge faces the sun (際): 1-px rim, and warm inner glow
    sky = ~crowns
    to_sun_x = np.sign(SUN[0] - xx); to_sun_y = np.sign(SUN[1] - yy)
    nb = np.roll(np.roll(sky, -to_sun_y.astype(int)[0, 0], 0), 0, 1)
    rim = crowns & (np.roll(sky, 1, 0) | np.roll(sky, -1, 1) * (xx < SUN[0]) | np.roll(sky, 1, 1) * (xx > SUN[0])) & (d < 130)
    cv.a[rim & (d < 70)] = I['rim1']
    cv.a[rim & (d >= 70)] = I['rim2']
    cv.a[crowns & ~rim & (d < 60) & (cv.noise(1.5) > 0.8)] = I['kw']
    cv.snapshot('2 oak crowns: violet masses, sky holes, rims of the light at edges facing the sun')
    # ---- 3 trunks: dark verticals, a warm edge on the sun side
    for (x, y0, y1, lean) in [(18, 50, 64, 0.0), (40, 48, 64, 0.02), (62, 48, 64, -0.02), (74, 46, 63, 0.0), (96, 44, 63, 0.05),
                              (160, 40, 62, 0.0), (172, 42, 62, -0.03), (190, 44, 62, 0.02), (214, 44, 62, 0.0), (232, 44, 62, 0.03),
                              (262, 48, 62, 0.0), (300, 46, 62, 0.0)]:
        for y in range(y0, y1):
            X = int(round(x + lean * (y - y0)))
            cv.put(X, y, I['tr']); cv.put(X + 1, y, I['tr'])
            side = X - 1 if X > SUN[0] else X + 2
            if r.uniform() < 0.6:
                cv.put(side, y, I['rim2'])
    cv.snapshot('3 trunks, warm edge on the sun side')
    # ---- 4 the far strip: the bright field/water beyond, the brightest thing under the sun
    strip = (yy >= 55) & (yy < 63) & ~crowns
    cv.a[strip] = I['far1']
    cv.a[strip & (np.abs(xx - SUN[0]) < 60) & (yy >= 57) & (yy < 60)] = I['far2']
    # ---- 5 the meadow: one plane, backlit: the far meadow glows toward the sun; nearer it darkens
    meadow = yy >= 62
    u = (yy - 62) / (H - 62)
    glow = np.exp(-np.abs(xx - SUN[0]) / 90) * (1 - u) ** 2
    f = u * 3.2 - glow * 1.6 + 0.25 * cv.noise(2.0)
    mq = np.clip(np.floor(f + 1), 0, 4).astype(int)
    cv.a[meadow] = np.array([I['mglow'], I['m1'], I['m2'], I['m3'], I['m4']])[mq][meadow]
    cv.a = majority(cv.a, 1)
    cv.snapshot('4 far strip; meadow plane: glow far toward the sun, darkening near')
    # grass blades: backlit, lit tips (the light's colour inside the mark), longer near
    ys, xs = np.nonzero(meadow)
    for i in r.choice(len(ys), size=int(len(ys) * 0.09), replace=False):
        x, y = xs[i], ys[i]
        uu = (y - 62) / (H - 62)
        L = 1 + int(uu * 9 * r.uniform(0.5, 1.2))
        lean = r.choice([-0.3, -0.15, 0, 0.15, 0.3])
        body = I['m3'] if uu > 0.4 else I['m1']
        for k in range(L):
            cv.put(x + lean * k, y - k, body)
        cv.put(x + lean * (L - 1), y - L + 1, I['mt'] if r.uniform() < 0.6 else I['mg'])
    cv.snapshot('5 grass: backlit blades, lit tips')
    # ---- 6 the camas: the crowd of one mark, dense+tiny far, big+sparse near; sun-side top lit
    for band_y0, band_y1, n_, size in [(62, 72, 900, 0), (72, 90, 420, 1), (90, 120, 200, 2), (120, 150, 90, 3), (150, 180, 45, 4)]:
        for k in range(n_):
            x = r.uniform(0, W); y = r.uniform(band_y0, band_y1)
            if size == 0:
                cv.put(x, y, I['vfar'] if r.uniform() < 0.7 else I['v1']); continue
            h_ = size + 1 + r.integers(0, 2)
            cv.line([(x, y + h_ + size), (x, y)], I['m3'])                    # stem
            for j in range(h_):
                for w_ in range(-(size // 2), size // 2 + 1):
                    cv.put(x + w_, y + j, I['v3'] if j > h_ // 2 else I['v2'])
            cv.put(x, y - 1, I['v1'])                                          # lit top toward the sun
            if size >= 3:
                cv.put(x + (1 if x < SUN[0] else -1), y, I['v1'])
                cv.put(x - (size // 2), y + h_ - 1, I['v4'])
    cv.snapshot('6 camas: one mark, tiny and dense far, big and sparse near, lit tops')
    return cv


if __name__ == '__main__':
    from sheet import zoom, grid, fit
    cv = paint()
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/places/out/sanjuan.png')
    photo = Image.open(f'{ROOT}/places/sanjuan_crop.png')
    grid([zoom(photo, 2), zoom(cv.rgb(), 2)], 1,
         ['photo (Garry oak meadow, Nick Kenrick, CC BY-NC-SA 2.0)', 'painted the Oga way, by hand, 320x180, 2x'],
         title='San Juan: camas under Garry oaks at sunset').save(f'{ROOT}/sheets/place_sanjuan.png')
    grid([zoom(cv.pal[a], 2) for _, a in cv.stages], 2, [n for n, _ in cv.stages], title='San Juan, stage by stage').save(f'{ROOT}/sheets/place_sanjuan_stages.png')

cd ~/work/pixelart-studies/books/oga && python3 places/sanjuan.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/sanjuan.py').read()
a=s.index("    # ---- 6 the camas"); b=s.index("    cv.snapshot('6 camas")
s=s[:a]+'''    # ---- 6 the camas: organised into drifts (grasp the crowd, p.48), one mark, small far, big near
    # a drift field in ground coordinates: long horizontal patches, compressed with distance
    gz = 1.0 / np.maximum((yy - 58) / (H - 58), 0.02)           # ~ distance
    gx = (xx - W / 2) * gz / 12
    rr2 = np.random.default_rng(seed + 7)
    ph = rr2.uniform(0, 6.28, 6)
    drift = (np.sin(gx * 0.9 + ph[0]) + 0.6 * np.sin(gz * 1.7 + ph[1]) + 0.5 * np.sin(gx * 0.37 + gz * 0.8 + ph[2])
             + 0.35 * cv.noise(3.0))
    far_patch = meadow & (yy < 76) & (drift > 0.3)
    cv.a[far_patch & (cv.noise(0.8) > -0.3)] = I['vfar']                 # far: drifts read as violet tone
    for band_y0, band_y1, n_, size in [(70, 90, 700, 1), (90, 120, 320, 2), (120, 150, 130, 3), (150, 184, 60, 4)]:
        for k in range(n_):
            x = r.uniform(0, W); y = r.uniform(band_y0, band_y1)
            xi, yi = int(min(x, W - 1)), int(min(y, H - 1))
            if drift[yi, xi] < 0.1 + 0.4 * r.uniform():
                continue
            if size == 1:
                cv.put(x, y, I['v2']); cv.put(x, y + 1, I['v3']); continue
            h_ = size + 1 + int(r.integers(0, 3))
            cv.line([(x, y + h_ + size), (x, y + h_ // 2)], I['m4'])        # stem
            for j in range(h_):                                              # florets: offset left/right
                off = (1 if (j + int(x)) % 2 else -1) * (size // 3)
                wv = max(1, size // 2 - (1 if j in (0, h_ - 1) else 0))
                for w_ in range(-wv // 2, wv // 2 + 1):
                    cv.put(x + w_ + off, y + j, I['v3'] if j > h_ // 2 else I['v2'])
            cv.put(x, y - 1, I['v1'])                                          # lit top toward the sun
            if size >= 3:
                cv.put(x + (1 if x < SUN[0] else -1), y, I['v1'])
                cv.put(x - 1, y + h_ - 1, I['v4'])
'''+s[b:]
s=s.replace("    for i in r.choice(len(ys), size=int(len(ys) * 0.09), replace=False):","    for i in r.choice(len(ys), size=int(len(ys) * 0.06), replace=False):")
s=s.replace("        cv.put(x + lean * (L - 1), y - L + 1, I['mt'] if r.uniform() < 0.6 else I['mg'])",
            "        if L > 2 or r.uniform() < 0.3:\n            cv.put(x + lean * (L - 1), y - L + 1, I['mt'] if (r.uniform() < 0.5 and abs(x - SUN[0]) < 120) else I['mg'])")
s=s.replace("f = u * 3.2 - glow * 1.6 + 0.25 * cv.noise(2.0)","f = u * 3.4 - glow * 2.4 + 0.25 * cv.noise(2.0)")
s=s.replace("""    strip = (yy >= 55) & (yy < 63) & ~crowns""","""    strip = (yy >= 56 + (cv.noise(2.0) * 0.8).astype(int)) & (yy < 63) & ~crowns""")
open('places/sanjuan.py','w').write(s)
EOF
python3 places/sanjuan.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/sanjuan.py').read()
s=s.replace("[(70, 90, 700, 1), (90, 120, 320, 2), (120, 150, 130, 3), (150, 184, 60, 4)]","[(70, 90, 2600, 1), (90, 120, 1300, 2), (120, 150, 500, 3), (150, 184, 220, 4)]")
s=s.replace("            if drift[yi, xi] < 0.1 + 0.4 * r.uniform():","            if drift[yi, xi] < -0.3 + 0.6 * r.uniform():")
s=s.replace("far_patch = meadow & (yy < 76) & (drift > 0.3)","far_patch = meadow & (yy < 78) & (drift > -0.2)")
s=s.replace("f = u * 3.4 - glow * 2.4 + 0.25 * cv.noise(2.0)","f = u * 3.4 - glow * 1.6 + 0.25 * cv.noise(2.0)")
s=s.replace("if L > 2 or r.uniform() < 0.3:","if L > 3 and r.uniform() < 0.5:")
open('places/sanjuan.py','w').write(s)
EOF
python3 places/sanjuan.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/sanjuan.py').read()
s=s.replace("""    drift = (np.sin(gx * 0.9 + ph[0]) + 0.6 * np.sin(gz * 1.7 + ph[1]) + 0.5 * np.sin(gx * 0.37 + gz * 0.8 + ph[2])
             + 0.35 * cv.noise(3.0))""","""    # smooth 2-D noise sampled at ground coordinates (patches are round on the ground, flattened on screen)
    Ng = gaussian_filter(rr2.standard_normal((256, 256)), 6, mode='wrap'); Ng /= Ng.std()
    from scipy.ndimage import map_coordinates
    drift = map_coordinates(Ng, [(gz * 9) % 256, (gx * 9 + 128) % 256], order=1, mode='wrap') + 0.3 * cv.noise(2.0)""")
open('places/sanjuan.py','w').write(s)
EOF
python3 places/sanjuan.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
import sys; sys.path.insert(0,'src')
from PIL import Image; from sheet import zoom
im=Image.open('plates/lv/C0792_boulders.png'); print(im.size)
c=im.resize((142,77),Image.BOX); c.save('copies/p5_ref.png')" && python3 work/gridref.py copies/p5_ref.png 142 6 copies/p5_grid.png

# output:
(710, 386)
142 77

"""Passage copy P5: C-0792 (p.56), light cut into a gorge of boulders, 142x77. Painted by hand.

The book's point for this plate: shadow is about 2/3 of the picture, which makes the light dazzle;
light falls only on certain planes; don't spread light around, concentrate it. Three light levels:
direct sun (brightest), soft light, reflected light in shadow (dim but important). By day the
reflected light takes the sky's colour (cool); loosen it with the object's own colour (moss greens,
rock browns).

Carbon transfer: the boulder outlines are my polygons read off copies/p5_grid.png (his layout);
every plane's light is my decision following the book's text; no pixel is sampled from the plate.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from okl import lch_to_lab, oklab_to_rgb
from copykit import Canvas
import vocab as V


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(
    void=c(0.14, 0.015, 220), v2=c(0.19, 0.02, 230), v3=c(0.24, 0.03, 240),          # the chasm: blue-black
    sh1=c(0.26, 0.025, 250), sh2=c(0.32, 0.03, 255), sh3=c(0.38, 0.035, 258),        # rock in shadow
    ms1=c(0.30, 0.04, 150), ms2=c(0.37, 0.05, 140),                                   # moss in shadow (object colour)
    rf1=c(0.46, 0.10, 268), rf2=c(0.56, 0.12, 265),                                   # reflected sky light: violet-blue
    so1=c(0.58, 0.03, 200), so2=c(0.66, 0.025, 210),                                  # soft light
    li1=c(0.74, 0.03, 85), li2=c(0.83, 0.03, 80), li3=c(0.93, 0.02, 90),              # direct sun
    edge=c(0.80, 0.08, 95),                                                           # the light's colour at its edge
    leaf=c(0.62, 0.12, 150), leaf2=c(0.48, 0.09, 155), wat=c(0.30, 0.03, 200),
)
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])
NXT = {'sh1': 'sh2', 'sh2': 'sh1', 'sh3': 'sh2', 'li1': 'li2', 'li2': 'li1', 'li3': 'li2', 'so1': 'so2', 'ms1': 'ms2', 'so2': 'so1'}


def paint(seed=5):
    W, H = 142, 77
    cv = Canvas(W, H, PAL, bg=I['void'], seed=seed)
    # ground: the chasm, blue-black, uneven; far lit leaves top-left; a water glimpse
    cv.mottle(np.ones((H, W), bool), I['v2'], 0.35, 3.0)
    cv.mottle(np.ones((H, W), bool), I['v3'], 0.12, 2.5)
    lv = cv.mass([(24, 0), (50, 0), (48, 14), (40, 20), (28, 18)], I['leaf2'], wet=1.5)
    cv.mottle(lv, I['leaf'], 0.45, 1.2)
    cv.mass([(56, 58), (76, 56), (80, 62), (60, 64)], I['wat'], wet=0.8)
    cv.snapshot('1 the chasm: blue-black, uneven; far lit leaves; a water glimpse')
    ix = I
    # shadowed boulders first (the majority), each: shadow body, moss patch, sky-light rim on top
    shadowed = [
        ([(0, 0), (30, 0), (26, 24), (12, 28), (0, 30)], [([(0, 0), (30, 0), (28, 6), (0, 8)], 'sh2')]),
        ([(84, 42), (100, 34), (118, 32), (126, 40), (120, 54), (100, 58), (86, 54)], [([(84, 42), (100, 34), (118, 32), (122, 36), (100, 40), (86, 46)], 'sh3'),
                                                                                    ([(92, 48), (112, 44), (118, 52), (100, 56)], 'ms1')]),
        ([(112, 12), (124, 10), (134, 14), (138, 28), (128, 38), (116, 36), (110, 24)], [([(112, 12), (124, 10), (134, 14), (126, 16), (114, 18)], 'sh3')]),
        ([(60, 20), (74, 16), (84, 20), (86, 30), (74, 34), (62, 30)], [([(66, 22), (80, 20), (82, 26), (70, 28)], 'ms1')]),
        ([(126, 44), (142, 40), (142, 66), (128, 62)], []),
        ([(118, 58), (132, 56), (142, 60), (142, 77), (116, 77)], [([(118, 58), (132, 56), (142, 60), (142, 63), (120, 62)], 'sh3')]),
    ]
    for outline, faces in shadowed:
        m = V.facet_rock(cv, outline, faces, ix, 'sh1', NXT)
        # reflected light: the up-facing top edge takes the sky's colour (violet-blue), 1-2 px
        top = m & ~np.roll(m, 1, 0)
        cv.a[top] = I['rf2']
        cv.a[m & ~np.roll(m, 2, 0) & ~top] = I['rf1']
    cv.snapshot('2 boulders in shadow: blue-grey, moss patches, the sky-coloured reflected light on tops')
    # lit boulders: direct sun on their top planes only; faces in shadow; the edge of the light
    lit = [
        ([(0, 34), (10, 28), (20, 28), (30, 36), (38, 50), (42, 62), (38, 66), (24, 58), (10, 48), (0, 44)],
         [([(0, 34), (10, 28), (20, 28), (30, 36), (38, 50), (40, 58), (30, 50), (16, 38), (4, 38)], 'li2'),
          ([(8, 30), (18, 30), (26, 38), (18, 36)], 'li3')]),
        ([(34, 24), (44, 22), (54, 28), (56, 34), (46, 36), (36, 32)], [([(34, 24), (44, 22), (54, 28), (48, 30), (38, 28)], 'li2')]),
        ([(40, 44), (52, 42), (62, 44), (64, 50), (60, 56), (46, 56), (40, 52)], [([(40, 44), (52, 42), (62, 44), (63, 48), (50, 48), (42, 49)], 'li3'),
                                                                                 ([(44, 49), (60, 48), (62, 51), (48, 53)], 'li1')]),
        ([(76, 64), (94, 60), (110, 62), (114, 72), (110, 77), (74, 77)], [([(76, 64), (94, 60), (110, 62), (104, 66), (84, 68)], 'li1')]),
        ([(0, 50), (14, 52), (26, 62), (32, 72), (30, 77), (0, 77)], [([(0, 50), (14, 52), (26, 62), (28, 68), (14, 62), (0, 58)], 'so2'),
                                                                     ([(0, 58), (14, 62), (28, 68), (30, 77), (0, 77)], 'so1')]),
    ]
    for outline, faces in lit:
        m = V.facet_rock(cv, outline, faces, ix, 'sh2', NXT)
        # the edge of the light: lit-plane pixels bordering the shadow face take the light's colour
        litp = m & np.isin(cv.a, [I['li1'], I['li2'], I['li3']])
        shp = m & ~litp
        border = litp & (np.roll(shp, -1, 0) | np.roll(shp, 1, 1) | np.roll(shp, -1, 1))
        cv.a[border] = I['edge']
    cv.snapshot('3 light only on certain planes: sun on the tops, the light-colour edge; the rest in shadow')
    # detail lives in the light: a few crack marks on the lit planes; lichen dots
    for pts in ([(10, 34), (18, 40), (24, 46)], [(46, 45), (52, 46)], [(84, 64), (92, 63)], [(4, 38), (8, 42)]):
        cv.line(pts, I['li1'])
    cv.snapshot('4 detail in the light only')
    return cv


if __name__ == '__main__':
    from sheet import zoom, grid
    cv = paint()
    ref = Image.open(f'{ROOT}/copies/p5_ref.png')
    lit_share = np.isin(cv.a, [I['li1'], I['li2'], I['li3'], I['edge'], I['so1'], I['so2']]).mean()
    cells = [zoom(ref, 5)] + [zoom(cv.pal[a], 5) for _, a in cv.stages] + [zoom(ref, 2), zoom(cv.rgb(), 2)]
    grid(cells, 2, ['his C-0792, reduced'] + [n for n, _ in cv.stages] + ['his 2x', f'mine 2x (lit share {100 * lit_share:.0f}%)'],
         title='P5 light cut into a gorge (C-0792), 5x').save(f'{ROOT}/sheets/p5_gorge.png')
    print('lit share', lit_share)

cd ~/work/pixelart-studies/books/oga && python3 copies/p5_gorge.py

# output:
lit share 0.13672946771538322

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('copies/p5_gorge.py').read()
s=s.replace("""        ([(118, 58), (132, 56), (142, 60), (142, 77), (116, 77)], [([(118, 58), (132, 56), (142, 60), (142, 63), (120, 62)], 'sh3')]),
    ]""","""        ([(118, 58), (132, 56), (142, 60), (142, 77), (116, 77)], [([(118, 58), (132, 56), (142, 60), (142, 63), (120, 62)], 'sh3')]),
        ([(56, 30), (70, 34), (84, 40), (84, 56), (70, 60), (60, 56), (58, 44)], [([(62, 44), (78, 46), (80, 54), (66, 56)], 'ms2')]),
        ([(86, 8), (100, 4), (112, 10), (110, 24), (96, 30), (86, 22)], []),
        ([(30, 58), (46, 58), (62, 62), (76, 66), (74, 77), (32, 77)], [([(40, 64), (60, 64), (70, 70), (50, 72)], 'ms1')]),
        ([(98, 22), (112, 26), (114, 34), (100, 36), (90, 32)], []),
        ([(126, 26), (142, 20), (142, 42), (130, 42)], []),
    ]""")
s=s.replace("""        # reflected light: the up-facing top edge takes the sky's colour (violet-blue), 1-2 px
        top = m & ~np.roll(m, 1, 0)
        cv.a[top] = I['rf2']
        cv.a[m & ~np.roll(m, 2, 0) & ~top] = I['rf1']""","""        # reflected light: the up-facing upper part of the boulder takes the sky's colour as a PLANE
        # (violet-blue), broken by the rock's own colour; the very top edge one step lighter
        ys = np.nonzero(m.any(1))[0]
        yy = np.mgrid[0:H, 0:W][0]
        upper = m & (yy < ys.min() + 0.35 * (ys.max() - ys.min()) + 1.2 * cv.noise(1.5))
        cv.a[upper] = I['rf1']
        cv.mottle(upper, I['sh3'], 0.3, 1.4)
        top = m & ~np.roll(m, 1, 0)
        cv.a[top & (cv.noise(1.0) > -0.3)] = I['rf2']""")
open('copies/p5_gorge.py','w').write(s)
EOF
python3 copies/p5_gorge.py

# output:
lit share 0.13672946771538322

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/vocab.py').read()
s=s.replace("""    t = np.clip((yy - y0) / max(1, (y1 - y0)), 0, 0.9999) * len(names)
    n = cv.noise(0.8, seed)
    # flat bands: the noise only acts near a seam
    f = t - np.floor(t)
    near = (f < 0.2) | (f > 0.8)
    q = np.floor(t + np.where(near, seam * 0.25 * n, 0)).astype(int)""","""    t = np.clip((yy - y0) / max(1, (y1 - y0)), 0, 0.9999) * len(names)
    # flat bands; each seam is a long soft wave (a wet hake edge), not per-row dither
    r = _rng(seed)
    n = gaussian_filter(r.standard_normal((H, W)), (1.5, 6.0)); n /= n.std() + 1e-9
    q = np.floor(t + seam * 0.35 * n).astype(int)""")
open('src/vocab.py','w').write(s)
EOF
echo ok

# output:
ok

cd ~/work/pixelart-studies/books/oga && grep -n "cloud = \|ledge\|clump_mass\|fall_strokes\|(0.45, ('m_lit'\|q1=c\|lev = np.search" places/skykomish.py

# output:
38:    q1=c(0.64, 0.025, 255), q2=c(0.56, 0.028, 258), q3=c(0.48, 0.025, 255), qw=c(0.58, 0.02, 60), q4=c(0.36, 0.022, 250),
71:    cloud = (xx + 0.35 * yy + 6 * cv.noise(3.0, seed + 1)) < 118
87:    lev = np.searchsorted(q, Lp)                          # 0 recess, 1 half, 2 lit, 3 top-lit
103:    V.fall_strokes(cv, wall & ~cloud & np.isin(cv.a, [IX['g1'], IX['g2']]), 'g3', IX, n=45, lens=(2, 7), drift=0.1, seed=seed)
104:    V.fall_strokes(cv, wall & cloud & (cv.a == IX['q1']), 'q2', IX, n=30, lens=(2, 6), drift=0.1, seed=seed + 1)
108:    # ---------------- conifers: ridge crest against the sky (far, aerial), ledge trees, foot forest ---
123:    # ledge trees
140:    cv.snapshot('4 conifers: crest (aerial), ledges, the foot forest (spires, tips break the edge)')
148:        V.clump_mass(cv, m, IX, lf, [(0.0, ('m_mid', 'm_dark', 'b_hole')), (0.45, ('m_lit', 'm_mid', 'm_dark')),

cd ~/work/pixelart-studies/books/oga && sed -n 84,100p places/skykomish.py; sed -n 120,152p places/skykomish.py

# output:
from okl import rgb_to_oklab
    Lp = gaussian_filter(rgb_to_oklab(ph)[..., 0], 1.0)
    q = np.quantile(Lp[wall], [0.3, 0.55, 0.85])
    lev = np.searchsorted(q, Lp)                          # 0 recess, 1 half, 2 lit, 3 top-lit
    lit_names = np.array([IX['q3'], IX['g3'], IX['g2'], IX['g1']])
    sh_names = np.array([IX['q4'], IX['q3'], IX['q2'], IX['q1']])
    cv.a[wall & ~cloud] = lit_names[lev][wall & ~cloud]
    cv.a[wall & cloud] = sh_names[lev][wall & cloud]
    cv.a = majority(cv.a, 2)
    # uneven paint in the shadowed granite: warm grey loosening the cool reflected light (p.56)
    cv.mottle(wall & cloud & (cv.a == IX['q1']), IX['qw'], 0.3, 2.0)
    # the rim of the sky's colour: top edges of sunlit planes that turn under into recess
    litm = wall & ~cloud & np.isin(cv.a, [IX['g1'], IX['g2']])
    dark_below = np.roll(np.isin(cv.a, [IX['q2'], IX['q3'], IX['q4']]), -1, 0)
    rr = np.random.default_rng(seed)
    rimm = litm & dark_below & (rr.uniform(size=(H, W)) < 0.6)
    cv.a[rimm] = IX['rim']
        y = np.interp(x, [p[0] for p in S(RIDGE)], [p[1] for p in S(RIDGE)])
        if rr.uniform() < 0.5:
            V.spire(cv, x + rr.integers(-3, 4), y + 2, int(rr.integers(4, 8)), IX, body='f_mid', dark='f_dark', lit='f_lit', sun=-1, seed=x)
    # ledge trees
    for (x, y, h) in [(60, 124, 6), (116, 116, 7), (190, 98, 5), (252, 92, 6), (300, 110, 5), (22, 140, 6)]:
        V.spire(cv, x, y - OY, h, IX, body='c_mid', dark='c_dark', lit='c_lit', sun=-1, seed=x)
    # the foot forest: organised notan from the photo (hole / dark / mid), then spires only where a
    # crown top is lit or the stand meets the wall (tips break that edge)
    qf = np.quantile(Lf[forest], [0.4, 0.75])
    cv.a[forest] = np.array([IX['c_hole'], IX['c_dark'], IX['c_mid']])[np.searchsorted(qf, Lf)][forest]
    cv.a = majority(cv.a, 1)
    ft = [int(np.interp(x, [p[0] for p in S(FORESTTOP)], [p[1] for p in S(FORESTTOP)])) for x in range(W)]
    for x in range(0, W, 3):
        h = int(rr.integers(6, 16))
        V.spire(cv, x + rr.uniform(-1, 1), ft[x] + h * 0.6, h, IX, body='c_mid', dark='c_dark',
                lit='c_lit' if not cloud[min(ft[x], H - 1), x] else 'c_mid', sun=-1, seed=x * 3)
    pk = forest & (Lf > np.quantile(Lf[forest], 0.9))
    ys, xs = np.nonzero(pk)
    for i in rr.choice(len(ys), size=min(40, len(ys)), replace=False):
        V.spire(cv, xs[i], ys[i] + 4, int(rr.integers(5, 9)), IX, body='c_mid', dark='c_dark', lit='c_lit', sun=-1, seed=int(i))
    cv.snapshot('4 conifers: crest (aerial), ledges, the foot forest (spires, tips break the edge)')

    # ---------------- near maples: clumps, bottom right and bottom left ------------------------------
    mright = cv.mask_poly(S([(236, 204), (244, 186), (256, 176), (272, 170), (292, 168), (312, 172), (320, 176), (320, 204)]))
    mleft = cv.mask_poly(S([(40, 204), (46, 186), (58, 174), (72, 172), (86, 180), (92, 204)]))
    lightm = gaussian_filter((xx + yy * 0.2 > 60).astype(float) * 0.6 + 0.4

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/skykomish.py').read()
# 60% in shadow: the cloud covers everything left of x~190, with a soft edge that follows the wall's fall line
s=s.replace("    cloud = (xx + 0.35 * yy + 6 * cv.noise(3.0, seed + 1)) < 118","    cloud = (xx - 0.25 * yy + 6 * cv.noise(3.0, seed + 1)) < 176")
# shadow simple: 3 steps only, no q4 recess speckle in shadow; warm loosening
s=s.replace("    sh_names = np.array([IX['q4'], IX['q3'], IX['q2'], IX['q1']])","    sh_names = np.array([IX['q3'], IX['q2'], IX['q2'], IX['q1']])")
s=s.replace("    cv.a = majority(cv.a, 2)\n    # uneven paint in the shadowed granite","    cv.a = majority(cv.a, 3)\n    # uneven paint in the shadowed granite")
# the edge of the light where the cloud shadow meets lit granite: light's colour
s=s.replace("    cv.a[rimm] = IX['rim']","""    cv.a[rimm] = IX['rim']
    from scipy.ndimage import binary_dilation
    cedge = wall & ~cloud & binary_dilation(cloud & wall, iterations=1) & np.isin(cv.a, [IX['g1'], IX['g2'], IX['g3']])
    cv.a[cedge] = IX['g1']""")
s=s.replace("    V.fall_strokes(cv, wall & cloud & (cv.a == IX['q1']), 'q2', IX, n=30, lens=(2, 6), drift=0.1, seed=seed + 1)\n","")
# remove ledge trees
s=s.replace("""    for (x, y, h) in [(60, 124, 6), (116, 116, 7), (190, 98, 5), (252, 92, 6), (300, 110, 5), (22, 140, 6)]:
        V.spire(cv, x, y - OY, h, IX, body='c_mid', dark='c_dark', lit='c_lit', sun=-1, seed=x)""","""    for (x, y, h) in [(252, 92, 6), (300, 110, 5)]:
        V.spire(cv, x, y - OY, h, IX, body='c_mid', dark='c_dark', lit='c_lit', sun=-1, seed=x)""")
# maples: in the forest's shadow, lit only at their crest top-left rims; asymmetric: drop the left one
s=s.replace("""    for m, lf in ((mright, np.clip(1.2 - (yy - (168 - OY)) / 40 + 0.2 * cv.noise(2), 0, 1)),
                  (mleft, np.clip(0.8 - (yy - (172 - OY)) / 40 + 0.2 * cv.noise(2), 0, 1) * 0.8)):""","""    for m, lf in ((mright, np.clip(0.75 - (yy - (168 - OY)) / 30 + 0.15 * cv.noise(2), 0, 1)),):""")
s=s.replace("    cv.snapshot('5 near maples: clumps, lit on the sun side')","    cv.snapshot('5 one near maple, mostly in shadow, lit only along its crest')")
open('places/skykomish.py','w').write(s)
EOF
python3 places/skykomish.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/skykomish.py').read()
s=s.replace("[(0.0, ('m_mid', 'm_dark', 'b_hole')), (0.45, ('m_lit', 'm_mid', 'm_dark')),\n                                     (0.75, ('m_cap', 'm_lit', 'm_mid'))]",
            "[(0.0, ('m_mid', 'm_dark', 'b_hole')), (0.6, ('m_lit', 'm_mid', 'm_dark')),\n                                     (0.9, ('m_cap', 'm_lit', 'm_mid'))]")
open('places/skykomish.py','w').write(s)
s=open('src/painter.py').read()
s=s.replace("        bed = np.array([ix['s2'], ix['w'], ix['l0']])[lev]","        bed = np.array([ix['s3'], ix['w'], ix['l0']])[lev]")
s=s.replace("""                cv.a[y0, x] = ix['s0']""","""                cv.a[y0, x] = ix['rim']""")
s=s.replace("""        dash = m & (n > kw.get('dash_t', 1.5)) & (rr.uniform(size=(H, W)) < 0.7)
        cv.a[dash & (np.arange(H)[:, None] < line[None, :] + refl_len)] = ix['rim']""","""        dash = m & (n > kw.get('dash_t', 1.5)) & (rr.uniform(size=(H, W)) < 0.7)
        cv.a[dash & (np.arange(H)[:, None] < line[None, :] + refl_len * 0.5)] = ix['rim']""")
s=s.replace("                if n[y, x] * 0.5 + (p - 0.5) * 3 > 0 and 0 <= ys < H and not m[ys, x]:","                if n[y, x] * 0.3 + (p - 0.5) * 4 > 0 and 0 <= ys < H and not m[ys, x]:")
open('src/painter.py','w').write(s)
s=open('places/enchant.py').read()
s=s.replace("key=(0.46, 0.04, 70), line=line,","key=(0.56, 0.035, 110), line=line,")
s=s.replace("squash=1.15, refl_len=70, dash_t=1.6,","squash=1.15, refl_len=90, dash_t=1.9,")
open('places/enchant.py','w').write(s)
EOF
python3 places/skykomish.py; python3 places/enchant.py

# output:
(Bash completed with no output)

"""Place study: the Olympic coast, driftwood on the gravel at Rialto Beach under a coastal forest. 320x172.
Hand-designed. Photo: places/olycoast_photo.jpg ('Driftwood along Rialto Beach 2022', Sea Cow, CC BY-SA 4.0).
(v1 used the generic painter: a pale blob for the root, uniform gravel, a flat forest wall. See LESSONS.)

Oga's decisions:
  [4] overcast: the light comes from the whole sky, i.e. from ABOVE. So every form is lit on its top
      planes and dark underneath: cream tops on the driftwood, cool grey-green undersides, a soft cool
      cast shadow on the gravel right under each log. Coloured greys everywhere (C39-5, p.103).
  [7] the point is the root mass: the only near-white and the only strong dark-light contact.
  [6] planes: sky (two values) / the forest wall with spruce spires and bleached snags breaking it /
      the salal band + the back log line (the severing band) / the gravel plane / the driftwood.
  [3] gravel as a crowd: flat far, dots mid, 2-px stones near, each stone lit on top (overcast).
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
from okl import lch_to_lab, oklab_to_rgb
from copykit import Canvas, majority
import vocab as V

W, H = 320, 172


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(
    sk1=c(0.80, 0.012, 300), sk2=c(0.88, 0.01, 280),
    f1=c(0.26, 0.03, 175), f2=c(0.33, 0.035, 165), f3=c(0.41, 0.04, 155), f4=c(0.50, 0.04, 150), fa=c(0.58, 0.025, 200),
    sn1=c(0.74, 0.012, 60), sn2=c(0.62, 0.015, 60),
    sa1=c(0.44, 0.07, 130), sa2=c(0.56, 0.09, 125), sa3=c(0.34, 0.05, 135),
    g0=c(0.66, 0.012, 70), g1=c(0.58, 0.014, 65), g2=c(0.50, 0.015, 60), g3=c(0.42, 0.015, 280), g4=c(0.34, 0.015, 270),
    gl=c(0.74, 0.012, 75), gw=c(0.55, 0.03, 50),
    w1=c(0.92, 0.02, 80), w2=c(0.84, 0.025, 75), w3=c(0.72, 0.025, 65), w4=c(0.58, 0.02, 180), w5=c(0.44, 0.02, 200), w6=c(0.32, 0.02, 220),
    cs=c(0.36, 0.02, 250),
)
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])


def log(cv, pts, r0, r1, seed=0):
    """a driftwood log along a polyline: radius r0 -> r1. Overcast: top 1/3 cream, middle grey-warm,
    underside cool dark; a soft cool cast shadow on the ground under it."""
    rr = np.random.default_rng(seed)
    pts = np.array(pts, float)
    segs = []
    for (a, b) in zip(pts[:-1], pts[1:]):
        n = int(np.hypot(*(b - a))) + 1
        for t in np.linspace(0, 1, n):
            segs.append(a + (b - a) * t)
    segs = np.array(segs)
    rad = np.linspace(r0, r1, len(segs))
    # cast shadow first (below, shifted down 1-2 px)
    for (x, y), r in zip(segs, rad):
        for dx in range(-1, 2):
            for dy in range(int(r), int(r) + 3):
                cv.put(x + dx, y + dy, I['cs'])
    for (x, y), r in zip(segs, rad):
        for dy in range(-int(round(r)), int(round(r)) + 1):
            f = dy / max(r, 0.5)                 # -1 top .. +1 bottom
            idx = I['w1'] if f < -0.45 else (I['w2'] if f < -0.1 else (I['w3'] if f < 0.35 else (I['w4'] if f < 0.7 else I['w5'])))
            cv.put(x, y + dy, idx)
    # grain: a few long 1-px lines of the next darker step along the log
    for k in range(int(len(segs) / 12)):
        i = rr.integers(0, max(1, len(segs) - 8))
        for j in range(int(rr.integers(4, 9))):
            x, y = segs[min(i + j, len(segs) - 1)]
            cv.put(x, y + rr.integers(-1, 1), I['w3'])


def paint(seed=21):
    cv = Canvas(W, H, PAL, bg=I['sk1'], seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]
    r = np.random.default_rng(seed)
    # ---- sky: two values
    cv.a[yy > 30 + 4 * cv.noise(4.0)] = I['sk2']
    # ---- the forest wall: a mass; top edge = spires of varying height; snags; overcast top-lit tiers
    FOREST_TOP = lambda x: 50 + 6 * np.sin(x / 23.0) + 4 * np.sin(x / 7.0 + 1)
    fb = 92
    forest = (yy >= FOREST_TOP(xx)) & (yy < fb)
    cv.a[forest] = I['f2']
    cv.mottle(forest, I['f1'], 0.35, 2.2)
    # far pale trees at the right end (haze toward the sea)
    haze = forest & (xx > 290)
    cv.a[haze] = I['fa']
    # spires breaking the sky; tall ones where the photo has the big spruces
    tall = {78: 60, 96: 44, 120: 40, 238: 56, 252: 46, 30: 36, 180: 34, 300: 30}
    for x in range(0, W, 5):
        x_ = x + r.integers(-2, 3)
        h = tall.get(min(tall, key=lambda k: abs(k - x_)), 16) if min(abs(k - x_) for k in tall) < 4 else int(r.integers(10, 24))
        base = FOREST_TOP(x_) + h * 0.5
        V.spire(cv, x_, base, h, {'b': I['f2'], 'd': I['f1'], 'l': I['f3']}, body='b', dark='d', lit='l', sun=0 or 1, w=max(1.5, h * 0.16), seed=x_)
    # overcast: the top of each tier catches the sky -> a light fleck on tier tops inside the forest
    ys, xs = np.nonzero(forest)
    for i in r.choice(len(ys), size=len(ys) // 30, replace=False):
        cv.put(xs[i], ys[i], I['f3']); cv.put(xs[i] + 1, ys[i], I['f3'])
    # bleached snags at the left
    for (x, y0, y1) in [(24, 30, 90), (30, 40, 90), (36, 48, 90), (44, 36, 90), (52, 54, 90), (12, 50, 90)]:
        cv.line([(x, y0), (x + 1, y1)], I['sn1'])
        for k in range(y0, y1, 5):
            cv.line([(x, k), (x + (2 if k % 10 else -2), k - 2)], I['sn2'])
    cv.snapshot('1 sky (two values), forest wall: spires breaking the sky, snags, overcast tier tops')
    # ---- the salal band: clumps lit on top; the back driftwood line along the forest foot
    band = (yy >= 84) & (yy < 100 + 2 * cv.noise(3.0))
    cv.a[band] = I['sa3']
    for x in range(0, W, 4):
        y = 88 + r.integers(-2, 5)
        V.clump(cv, x + r.uniform(-1, 1), y, r.uniform(2.0, 3.2), 'sa2', 'sa1', 'sa3', I, seed=x)
    for pts in ([(0, 99), (40, 98), (70, 100)], [(150, 101), (210, 99), (260, 100)], [(270, 97), (320, 96)], [(80, 102), (130, 101)]):
        log(cv, pts, 1.0, 0.8, seed=pts[0][0])
    cv.snapshot('2 salal band (clumps lit on top), the back log line')
    # ---- the gravel plane: flat far, dots mid, stones near; overcast: stones lit on top
    gravel = (yy >= 100 + 2 * cv.noise(3.0)) & ~band
    gravel |= yy >= 104
    t = np.clip((yy - 100) / (H - 100), 0, 1)
    cv.a[gravel] = I['g1']
    cv.a[gravel & (t < 0.25)] = I['g0']
    cv.mottle(gravel & (t > 0.2), I['g2'], 0.35, 3.0)
    cv.a[gravel & (xx < 70) & (t < 0.3) & (cv.noise(2.0) > 0.3)] = I['gw']     # the wet brown patch at left
    ys, xs = np.nonzero(gravel & (t > 0.18))
    for i in r.choice(len(ys), size=int(len(ys) * 0.22), replace=False):
        x, y = xs[i], ys[i]
        tt = t[y, x]
        w = 1 + int(tt * 2.6 * r.uniform(0.5, 1.2))
        if tt < 0.45:
            cv.put(x, y, I['g3'] if r.uniform() < 0.5 else I['gl']); continue
        for k in range(w):
            cv.put(x + k, y, I['gl'] if r.uniform() < 0.8 else I['g0'])
            cv.put(x + k, y + 1, I['g4'])
    cv.snapshot('3 gravel: flat far, dots mid, 2-3 px stones near, lit tops')
    # ---- the driftwood: the log, the root mass (the point), a small log
    log(cv, [(112, 140), (140, 132), (170, 126), (204, 118)], 4.2, 3.2, seed=1)
    log(cv, [(56, 152), (72, 146), (90, 141)], 2.2, 1.8, seed=2)
    root = cv.mask_poly([(204, 104), (222, 98), (244, 100), (262, 106), (270, 122), (266, 146), (252, 156), (230, 152), (212, 140), (204, 122)])
    # cast shadow of the root on the gravel (cool, soft, right under it)
    cs = cv.mask_poly([(206, 142), (232, 154), (254, 158), (272, 150), (276, 160), (230, 164), (204, 152)])
    cv.a[cs & ~root] = I['cs']
    # the root mass as facets: overcast = cream top planes, grey-warm faces, cool dark underside pockets
    cv.a[root] = I['w3']
    cv.mottle(root, I['w4'], 0.35, 1.8)
    top = root & (yy < 112 + 0.25 * (xx - 204))
    cv.a[top] = I['w2']; cv.mottle(top, I['w1'], 0.4, 1.4)
    under = root & (yy > 136 + 0.1 * (xx - 204))
    cv.a[under] = I['w5']; cv.mottle(under, I['w6'], 0.35, 1.2)
    for pts in ([(214, 116), (224, 128), (230, 140)], [(236, 110), (242, 126), (246, 146)], [(252, 112), (258, 130)]):
        cv.line(pts, I['w6'])                                   # crevices between the root folds
    # root spikes fanning up and left from the mass, lit on top
    for (x0, y0, x1, y1) in [(206, 106, 188, 88), (212, 102, 204, 80), (220, 100, 218, 78), (226, 99, 232, 84),
                             (206, 112, 180, 104), (208, 108, 190, 96)]:
        cv.line([(x0, y0), (x1, y1)], I['w2'])
        cv.line([(x0 + 1, y0 + 1), (x1 + 1, y1 + 1)], I['w4'])
    cv.snapshot('4 driftwood: logs (cream tops, cool undersides, cast shadow), the root mass as the point')
    return cv


if __name__ == '__main__':
    from sheet import zoom, grid, fit
    cv = paint()
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/places/out/olycoast.png')
    photo = Image.open(f'{ROOT}/places/olycoast_photo.jpg').resize((W, H), Image.LANCZOS)
    before = Image.open(f'{ROOT}/places/olycoast_pair_right.png')
    grid([zoom(photo, 2), fit(before, w=640), zoom(cv.rgb(), 2)], 1,
         ['photo (Rialto Beach driftwood, Sea Cow, CC BY-SA 4.0)', 'a place-olycoast lane render (different view, for the current look)', 'painted the Oga way, by hand, 320x172, 2x'],
         title='Olympic coast: driftwood at Rialto').save(f'{ROOT}/sheets/place_olycoast.png')
    grid([zoom(cv.pal[a], 2) for _, a in cv.stages], 2, [n for n, _ in cv.stages], title='Olympic coast, stage by stage').save(f'{ROOT}/sheets/place_olycoast_stages.png')

cd ~/work/pixelart-studies/books/oga && python3 places/olycoast.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('src/vocab.py').read()
a=s.index("def spire("); b=s.index("def conifer_mass(")
s=s[:a]+'''def spire(cv, x, yb, h, ix, body='c_mid', dark='c_dark', lit='c_lit', sun=+1, w=None, seed=0, where=None):
    """one conifer: base at (x, yb), height h px. Built as the book's staggered flat-brush dabs: a 1-px
    leader, then branch tiers at irregular 2-4 row intervals, each tier a short drooping dash whose
    length varies left/right; the sun side (sun=+1 right, -1 left, 0 overcast = tops) gets lit ends."""
    r = _rng(seed)
    w = w if w is not None else max(1.0, h * 0.22)
    top = int(round(yb - h))
    x = float(x)
    y = top
    cv_put = lambda X, Y, idx: (where is None or (0 <= Y < cv.H and 0 <= X < cv.W and where[int(Y), int(round(X))])) and cv.put(X, Y, idx)
    # leader
    for yy in range(top, int(yb) + 1):
        cv_put(x, yy, ix[body])
    cv_put(x, top, ix[dark])
    y = top + int(r.integers(1, 3))
    while y <= yb:
        t = (y - top) / max(h, 1)
        for side in (-1, 1):
            L = w * t * r.uniform(0.6, 1.35) + 0.5
            n = int(round(L))
            for k in range(1, n + 1):
                droop = 1 if k > 0.6 * n and n >= 3 else 0
                X = x + side * k
                idx = ix[body]
                if side * (sun if sun else 1) < 0 and sun != 0:
                    idx = ix[dark]
                if k == n and (side == sun or (sun == 0)):
                    idx = ix[lit]
                cv_put(X, y + droop, idx)
                if k < n * 0.5:
                    cv_put(X, y + 1, ix[dark] if side * (sun or 1) < 0 else ix[body])
        y += int(r.integers(2, 4))
    # fill the body between tiers near the trunk so the tree reads as a mass, not a ladder
    for yy in range(top + 2, int(yb)):
        t = (yy - top) / max(h, 1)
        for k in range(1, int(w * t * 0.55) + 1):
            for side in (-1, 1):
                cv_put(x + side * k, yy, ix[dark] if (side * (sun or 1) < 0 and sun != 0) else ix[body])


'''+s[b:]
open('src/vocab.py','w').write(s)
EOF
python3 places/olycoast.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
import sys; sys.path.insert(0,'src')
from PIL import Image; from sheet import zoom
im=Image.open('places/out/olycoast.png'); zoom(im.crop((0,20,200,110)),4).save('(manager scratchpad)/oc.png')"

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/olycoast.py').read()
a=s.index("    # the root mass as facets"); b=s.index("    # root spikes fanning")
s=s[:a]+'''    # the root mass: a tangle of lumps, each lit on top (overcast), cool dark pockets between;
    # its lower part is a dark cave of root ends (the strongest dark in the picture, next to the whitest)
    cv.a[root] = I['w5']
    cv.mottle(root, I['w6'], 0.4, 1.3)
    lumps = [(214, 110, 6), (228, 104, 7), (246, 106, 7), (258, 114, 6), (222, 122, 6), (240, 120, 7), (256, 128, 6),
             (216, 132, 5), (234, 134, 6), (250, 140, 5), (210, 120, 4), (262, 136, 4)]
    for k, (x, y, rad) in enumerate(lumps):
        cap, body, cres = ('w1', 'w2', 'w4') if y < 125 else ('w2', 'w3', 'w5')
        V.clump(cv, x, y, rad * 0.8, cap, body, cres, I, seed=k * 7 + 3, where=root)
    for pts in ([(212, 128), (226, 138), (238, 150)], [(232, 116), (244, 132), (248, 150)], [(250, 118), (262, 140)],
                [(220, 116), (230, 126)]):
        cv.line(pts, I['w6'])                                   # crevices between the root folds
'''+s[b:]
open('places/olycoast.py','w').write(s)
EOF
python3 places/olycoast.py; python3 -c "
import sys; sys.path.insert(0,'~/work/pixelart-studies/books/oga/src')
from PIL import Image; from sheet import zoom
im=Image.open('~/work/pixelart-studies/books/oga/places/out/olycoast.png'); zoom(im.crop((100,80,290,172)),4).save('(manager scratchpad)/oc2.png')"

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/olycoast.py').read()
s=s.replace("    w1=c(0.92, 0.02, 80), w2=c(0.84, 0.025, 75), w3=c(0.72, 0.025, 65), w4=c(0.58, 0.02, 180), w5=c(0.44, 0.02, 200), w6=c(0.32, 0.02, 220),",
            "    w1=c(0.92, 0.02, 80), w2=c(0.84, 0.025, 75), w3=c(0.72, 0.025, 65), w4=c(0.58, 0.02, 180), w5=c(0.44, 0.02, 200), w6=c(0.32, 0.02, 220),\n    br1=c(0.50, 0.05, 55), br2=c(0.40, 0.045, 50), br3=c(0.30, 0.035, 45),")
a=s.index("    root = cv.mask_poly("); b=s.index("    cv.snapshot('4 driftwood")
s=s[:a]+'''    # the root plate, designed by planes (hand polygons): the silhouette reaches out in arms
    root = cv.mask_poly([(202, 108), (210, 100), (222, 96), (232, 90), (240, 94), (252, 96), (262, 102), (270, 112),
                         (272, 126), (268, 142), (258, 154), (240, 154), (224, 148), (212, 138), (204, 124)])
    cs = cv.mask_poly([(210, 140), (232, 154), (258, 158), (276, 150), (280, 160), (240, 166), (206, 154)])
    cv.a[cs & ~root] = I['cs']
    # 1 the dark root plate (warm brown, the object's colour in shadow), uneven
    cv.a[root] = I['br2']
    cv.mottle(root, I['br3'], 0.35, 1.6)
    cv.mottle(root, I['br1'], 0.25, 1.6)
    # 2 the lit upper planes: the weathered top of the trunk end and two big folds, cream
    for poly, (a_, b_) in (([(202, 108), (210, 100), (222, 96), (232, 90), (240, 94), (236, 104), (222, 110), (208, 116)], ('w1', 'w2')),
                           ([(240, 94), (252, 96), (262, 102), (266, 110), (254, 112), (242, 106)], ('w2', 'w3')),
                           ([(214, 118), (228, 112), (240, 116), (236, 124), (222, 126)], ('w2', 'w3'))):
        m = cv.mass(poly, I[a_], where=root)
        cv.mottle(m, I[b_], 0.3, 1.2)
        low = m & ~np.roll(m, -1, 0)
        cv.a[low] = I['w4']                                     # the fold's lower edge turns into shadow
    # 3 root ends in the dark cave: short 1-2 px pale stubs pointing out at us
    for (x, y) in [(232, 136), (244, 140), (252, 132), (226, 128), (258, 144), (238, 146), (248, 124), (262, 126)]:
        cv.put(x, y, I['w3']); cv.put(x + 1, y + 1, I['w4'])
'''+s[b:]
s=s.replace("""    for (x0, y0, x1, y1) in [(206, 106, 188, 88), (212, 102, 204, 80), (220, 100, 218, 78), (226, 99, 232, 84),
                             (206, 112, 180, 104), (208, 108, 190, 96)]:""","""    for (x0, y0, x1, y1) in [(212, 100, 196, 84), (222, 96, 216, 76), (232, 91, 234, 74), (240, 94, 248, 80),
                             (204, 108, 186, 102)]:""")
s=s.replace("    for i in r.choice(len(ys), size=int(len(ys) * 0.22), replace=False):","    for i in r.choice(len(ys), size=int(len(ys) * 0.12), replace=False):")
open('places/olycoast.py','w').write(s)
EOF
python3 places/olycoast.py; python3 -c "
import sys; sys.path.insert(0,'~/work/pixelart-studies/books/oga/src')
from PIL import Image; from sheet import zoom
im=Image.open('~/work/pixelart-studies/books/oga/places/out/olycoast.png'); zoom(im.crop((100,70,290,172)),4).save('(manager scratchpad)/oc2.png')"

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/olycoast.py').read()
s=s.replace("""    # 3 root ends in the dark cave""","""    # 3 the roots radiate from the trunk's end: strokes from the centre to the rim, lit (cream) on the
    #   upper half where they face the sky, dark below; they break the silhouette as spikes
    cx, cy = 238, 124
    for k, ang in enumerate(np.linspace(-170, 10, 12)):
        a = np.radians(ang + (k % 3) * 4)
        L = 20 + (k * 7) % 12
        col = I['w2'] if np.sin(a) < -0.3 else (I['w3'] if np.sin(a) < 0.2 else I['br1'])
        pts = [(cx + np.cos(a) * 6, cy + np.sin(a) * 6), (cx + np.cos(a) * L, cy + np.sin(a) * L)]
        cv.line(pts, col)
    for k, ang in enumerate(np.linspace(20, 160, 7)):
        a = np.radians(ang)
        cv.line([(cx + np.cos(a) * 5, cy + np.sin(a) * 5), (cx + np.cos(a) * 18, cy + np.sin(a) * 16)], I['br3'])
    # 4 root ends in the dark cave""")
open('places/olycoast.py','w').write(s)
EOF
python3 places/olycoast.py; python3 -c "
import sys; sys.path.insert(0,'~/work/pixelart-studies/books/oga/src')
from PIL import Image; from sheet import zoom
im=Image.open('~/work/pixelart-studies/books/oga/places/out/olycoast.png'); zoom(im.crop((100,70,290,172)),4).save('(manager scratchpad)/oc2.png')"

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/yakima.py').read()
s=s.replace("""    lit_ramp = slope & ((yy - line_y(RAMP_TOP, xx)) > 0) & (xx > 70)""","""    # the lit/shadow split of the hills: the photo's own light shape, organised (smoothed 3 px)
    ph = np.asarray(Image.open(f'{ROOT}/places/yakima_photo.jpg').convert('RGB').resize((W, 213), Image.BOX), float)[16:16 + H] / 255
    Lp = gaussian_filter(rgb_to_oklab(ph)[..., 0], 3.0)
    lit_ramp = slope & (Lp > np.quantile(Lp[slope], 0.42))""")
s=s.replace("""    cv.line([(176, 36), (320, 40)], I['rk1'])\n""","")
s=s.replace("""    cv.line([(0, 69), (120, 67), (320, 64)], I['fence'])
    for x in range(4, 320, 9):
        cv.put(x, int(round(69 - x * 0.0156)) - 1, I['fence'])""","""    for x in range(90, 300, 9):                                  # fence posts only, no ruled line
        cv.put(x, int(round(69 - x * 0.0156)) - 1, I['fence']); cv.put(x, int(round(69 - x * 0.0156)), I['fence'])""")
# willows as clumps in groups with gaps, over a lower gold/grass band
a=s.index("    # ---- the willow band"); b=s.index("    cv.snapshot('3 willow band")
s=s[:a]+'''    # ---- the willow band: groups of stem clumps (3-4 masses with gaps), lit tops, gold grass between
    band = (yy >= line_y(BAND_TOP, xx)) & (yy < line_y(BANK, xx))
    cv.a[band] = I['go2']
    cv.mottle(band, I['go1'], 0.4, 2.0)
    groups = [(0, 70), (86, 150), (170, 228), (246, 320)]
    for (g0, g1) in groups:
        for x0 in range(g0, g1, 3):
            top = int(line_y(BAND_TOP, x0)) - int(r.integers(0, 4)) - (3 if (x0 - g0) > 6 and (g1 - x0) > 6 else 0)
            bot = int(line_y(BANK, x0)) - int(r.integers(3, 6))
            for x in range(x0, x0 + 3):
                for y in range(top, bot):
                    k = (y - top) / max(1, bot - top)
                    v = r.uniform()
                    idx = I['wi1'] if (k < 0.25 and v < 0.6) else (I['wi2'] if v < 0.55 else I['wi3'])
                    if (x + y // 3) % 4 == 0:
                        idx = I['wi4']
                    cv.put(x, y, idx)
                if r.uniform() < 0.7:
                    cv.put(x, top - 1, I['wit'])
    for x in range(W):
        bot = int(line_y(BANK, x))
        cv.put(x, bot, I['bank'])
'''+s[b:]
s=s.replace("            if d < 20 and ys > line_y(BAND_TOP, x) - 2:","            if d < 26 and ys > line_y(BAND_TOP, x) - 6:")
s=s.replace("    cv.a[wz & (n > 1.5)] = I['wdash']","    cv.a[wz & (n > 2.0) & (xx < 200)] = I['wdash']")
open('places/yakima.py','w').write(s)
EOF
python3 places/yakima.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('places/yakima_photo.jpg').convert('RGB').resize((320,213),Image.BOX).crop((0,16,320,196)); im.save('places/yakima_crop.png')" && python3 work/gridref.py places/yakima_crop.png 320 3 places/yakima_grid.png

# output:
320 180

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/yakima.py').read()
s=s.replace("SKYLINE = [(0, 34), (40, 28), (100, 16), (160, 4), (200, -6), (320, -20)]","SKYLINE = [(0, 30), (40, 22), (90, 10), (130, 0), (320, -20)]")
s=s.replace("FAR_BASE = [(0, 50), (40, 44), (80, 38), (120, 30), (150, 22), (165, 16)]","FAR_BASE = [(0, 40), (40, 34), (80, 24), (120, 12), (150, 2), (165, 0)]")
s=s.replace("TERRACE = [(0, 64), (60, 64), (120, 62), (200, 60), (260, 58), (320, 58)]","TERRACE = [(0, 72), (60, 64), (120, 58), (200, 56), (260, 55), (320, 55)]")
s=s.replace("BAND_TOP = [(0, 76), (60, 78), (120, 80), (200, 80), (260, 80), (320, 82)]","BAND_TOP = [(0, 66), (60, 70), (120, 72), (200, 70), (260, 70), (320, 68)]")
s=s.replace("BANK = [(0, 94), (80, 98), (160, 101), (240, 104), (320, 108)]","BANK = [(0, 92), (80, 94), (160, 98), (240, 104), (320, 110)]")
s=s.replace("near = cv.mask_poly([(0, 150), (60, 148), (120, 152), (200, 156), (250, 168), (262, 180), (0, 180)])","near = cv.mask_poly([(0, 158), (40, 156), (100, 160), (150, 162), (180, 170), (192, 180), (0, 180)])")
s=s.replace("""    V.spire(cv, 30, 86, 26, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=4)
    V.spire(cv, 44, 80, 12, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=3)""","""    V.spire(cv, 18, 86, 34, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=4, seed=3)
    V.spire(cv, 30, 80, 14, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=3, seed=4)""")
s=s.replace("""    cv.mass([(194, 142), (208, 142), (206, 144), (196, 144)], I['boat'])
    cv.put(198, 140, I['red']); cv.put(198, 141, I['red']); cv.put(202, 140, I['blu']); cv.put(202, 141, I['blu'])
    cv.line([(190, 145), (212, 145)], I['wdash'])""","""    cv.mass([(194, 124), (212, 124), (210, 127), (196, 127)], I['boat'])
    cv.put(197, 120, I['red']); cv.put(197, 121, I['red']); cv.put(197, 122, I['red']); cv.put(203, 121, I['blu']); cv.put(203, 122, I['blu'])
    cv.line([(190, 128), (216, 128)], I['wdash'])""")
# reflection of the pine: dark vertical in the water at x 14-22
s=s.replace("    # the water's own depth:","    for y in range(95, 140):\n        for x in range(15, 21):\n            if river[y, x] and (x - 18) ** 2 < 9 * (1 - (y - 95) / 45):\n                cv.a[y, x] = I['pn2']\n    # the water's own depth:")
# willow groups follow photo gaps less; widen groups
s=s.replace("groups = [(0, 70), (86, 150), (170, 228), (246, 320)]","groups = [(0, 96), (104, 176), (184, 250), (256, 320)]")
open('places/yakima.py','w').write(s)
EOF
python3 places/yakima.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/yakima.py').read()
a=s.index("    groups = [(0, 96)"); b=s.index("    for x in range(W):\n        bot = int(line_y(BANK, x))\n        cv.put(x, bot, I['bank'])")
s=s[:a]+'''    # willow crowns as a crowd of clumps (tall, like dormant stems), light from the upper left;
    # the gold grass shows between them and along the bank
    wmask = band & (yy < line_y(BANK, xx) - 4)
    pts = [(x + r.uniform(-1.5, 1.5), y + r.uniform(-1, 1)) for y in range(60, 110, 4) for x in range(-2, W + 3, 4)]
    pts.sort(key=lambda p: p[1])
    for (x, y) in pts:
        xi, yi = int(np.clip(round(x), 0, W - 1)), int(np.clip(round(y), 0, H - 1))
        if not wmask[yi, xi] or r.uniform() < 0.15:
            continue
        rad = r.uniform(2.2, 3.4)
        # tall clump: draw two stacked clumps; cap on the upper-LEFT (sun at left)
        for dy in (0, -2):
            V.clump(cv, -(x) , y + dy, rad, 'wi1', 'wi2', 'wi4', I, seed=int(x * 7 + y * 3)) if False else None
            rr_ = rad
            for ddy in range(-int(rr_) - 1, int(rr_) + 2):
                for ddx in range(-int(rr_) - 1, int(rr_) + 2):
                    if (ddx / 0.8) ** 2 + (ddy / 1.3) ** 2 > rr_ ** 2:
                        continue
                    s_ = (-ddx * 0.6 - ddy * 0.8) / rr_
                    idx = I['wi1'] if s_ > 0.45 else (I['wi2'] if s_ > -0.3 else I['wi3'])
                    if (int(x) + ddx) % 3 == 0 and s_ < 0.45:
                        idx = I['wi4'] if s_ < -0.3 else I['wi3']       # vertical stem gaps
                    cv.put(x + ddx, y + dy + ddy, idx)
        if r.uniform() < 0.8:
            cv.put(x - 1, y - rad * 1.3 - 2, I['wit'])
'''+s[b:]
s=s.replace("    cloud = lit_ramp & ((xx - 250) - (yy - 10) * 0.9 + 5 * cv.noise(2.5) > 0)","    cloud = lit_ramp & ((xx - 270) - (yy - 4) * 1.4 + 5 * cv.noise(2.5) > 0)")
# move pine after willows: remove from terrace step and add before river
pine = """    V.spire(cv, 18, 86, 34, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=4, seed=3)
    V.spire(cv, 30, 80, 14, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=3, seed=4)"""
s=s.replace(pine+"\n","")
s=s.replace("    cv.snapshot('3 willow band","    V.spire(cv, 18, 90, 36, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=4, seed=3)\n    V.spire(cv, 32, 86, 16, {'b': I['pn1'], 'd': I['pn2'], 'l': I['pn1']}, body='b', dark='d', lit='l', sun=-1, w=3, seed=4)\n    cv.snapshot('3 willow band")
open('places/yakima.py','w').write(s)
EOF
python3 places/yakima.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 - <<'EOF'
s=open('places/sanjuan.py').read()
s=s.replace("    holes = crowns & (cv.noise(0.7) > 1.6 - 1.2 * near_sun)","    holes = crowns & (cv.noise(0.7) > 2.4 - 2.2 * near_sun) & (d < 110)")
# the far strip: keep a thin bright line only under the sun; elsewhere a dark band of oak shadow on the grass
s=s.replace("""    strip = (yy >= 56 + (cv.noise(2.0) * 0.8).astype(int)) & (yy < 63) & ~crowns
    cv.a[strip] = I['far1']
    cv.a[strip & (np.abs(xx - SUN[0]) < 60) & (yy >= 57) & (yy < 60)] = I['far2']""","""    strip = (yy >= 56 + (cv.noise(2.0) * 0.8).astype(int)) & (yy < 63) & ~crowns
    cv.a[strip] = I['m4']                                          # the oaks' shadow cast toward us: a dark sever
    glint = strip & (np.abs(xx - SUN[0]) + 3 * cv.noise(2.0) < 50) & (yy >= 57) & (yy < 60)
    cv.a[glint] = I['far2']
    cv.a[strip & (np.abs(xx - SUN[0]) + 3 * cv.noise(2.0) < 70) & ~glint & (yy >= 56) & (yy < 61)] = I['far1']""")
# oak shadows reaching over the near meadow: long diagonal dark tongues from each trunk group toward the viewer
s=s.replace("    cv.a = majority(cv.a, 1)\n    cv.snapshot('4 far strip","""    for x0 in (20, 70, 175, 215, 265, 305):
        ang = (x0 - SUN[0]) / 140.0                              # shadows fan away from the sun
        band = meadow & (np.abs(xx - (x0 + ang * (yy - 62))) < 6 + (yy - 62) * 0.18 + 2 * cv.noise(3.0)) & (yy < 120)
        cv.a[band] = np.minimum(cv.a[band] + 1, I['m4'])
    cv.a = majority(cv.a, 1)
    cv.snapshot('4 far strip""")
s=s.replace("            cv.put(x, y - 1, I['v1'])                                          # lit top toward the sun",
            "            cv.put(x, y - 1, I['rim1'] if abs(x - SUN[0]) < 60 else I['v1'])   # lit top: the light's colour near the sun axis")
open('places/sanjuan.py','w').write(s)
EOF
python3 places/sanjuan.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && python3 -c "
from PIL import Image
im=Image.open('places/skykomish_pair_right.png'); print(im.size)
im=im.crop((2,12,886,545)); im.save('places/skykomish_render.png'); print(im.size)"

# output:
(888, 556)
(884, 533)

"""The method applied to a voxsim render: the place-skykomish lane's Index wall (renders/sky/wall_pair_o
right half), repainted the Oga way at 320x193. No photo: the render is the only source.

What the render gives: rock (grey), conifers (green), their shadows. What it lacks, by the book:
  - one concentrated light (every rock face is lit the same; dark streaks everywhere) [7]
  - shadow colour: its shadows are neutral near-black [4][10]
  - organisation: trees are scattered members, not a crowd with a mass [3]
  - a severing band and an order of planes [6]
Passes:
  1 masses from the render (rock / trees), organised (smoothed 2 px);
  2 light: a cloud shadow over the left 60% of the wall, following the fall line; lit granite = the
    render's lightest organised values, shadowed granite = a simple cool family with warm loosening;
  3 trees: a dark crowd with spires only where the render has a tree top against rock, lit tips on the
    sun side (left);
  4 the edge of the light: the light's colour where the cloud edge crosses lit rock.
"""
import sys
ROOT = __file__.rsplit('/', 2)[0]
sys.path.insert(0, ROOT + '/src')
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter, binary_dilation, label
from okl import rgb_to_oklab, lch_to_lab, oklab_to_rgb
from copykit import Canvas, majority
import vocab as V

W = 320


def c(L, C, h):
    return oklab_to_rgb(lch_to_lab(np.array([L, C, np.radians(h)])))


P = dict(g1=c(0.88, 0.018, 85), g2=c(0.78, 0.02, 80), g3=c(0.67, 0.022, 70), rim=c(0.74, 0.10, 245),
         q1=c(0.62, 0.025, 255), q2=c(0.54, 0.028, 258), q3=c(0.45, 0.025, 255), qw=c(0.56, 0.022, 55),
         c_lit=c(0.56, 0.09, 135), c_mid=c(0.43, 0.07, 145), c_dark=c(0.31, 0.045, 160), c_hole=c(0.21, 0.03, 170),
         s_mid=c(0.36, 0.05, 185), s_dark=c(0.27, 0.04, 195))
NAMES = list(P); I = {k: i for i, k in enumerate(NAMES)}; PAL = np.array([P[k] for k in NAMES])


def paint(seed=51):
    src = Image.open(f'{ROOT}/places/skykomish_render.png').convert('RGB')
    H = round(src.height * W / src.width)
    a = np.asarray(src.resize((W, H), Image.BOX), float) / 255
    lab = rgb_to_oklab(a)
    L = gaussian_filter(lab[..., 0], 1.0)
    C = np.hypot(lab[..., 1], lab[..., 2]); hue = np.degrees(np.arctan2(lab[..., 2], lab[..., 1])) % 360
    tree = gaussian_filter(((hue > 100) & (hue < 200) & (C > 0.03)).astype(float), 1.2) > 0.45
    rock = ~tree
    cv = Canvas(W, H, PAL, seed=seed)
    yy, xx = np.mgrid[0:H, 0:W]
    # 2 light: the cloud shadow, following the fall line
    cloud = (xx - 0.3 * yy + 8 * cv.noise(3.0)) < 175
    Lr = gaussian_filter(lab[..., 0], 2.0)
    q = np.quantile(Lr[rock], [0.25, 0.55, 0.85])
    lev = np.searchsorted(q, Lr)
    lit_names = np.array([I['q3'], I['g3'], I['g2'], I['g1']])
    sh_names = np.array([I['q3'], I['q2'], I['q2'], I['q1']])
    cv.a[rock & ~cloud] = lit_names[lev][rock & ~cloud]
    cv.a[rock & cloud] = sh_names[lev][rock & cloud]
    cv.a = majority(cv.a, 3)
    cv.mottle(rock & cloud & (cv.a == I['q1']), I['qw'], 0.3, 2.0)
    litm = rock & ~cloud & np.isin(cv.a, [I['g1'], I['g2']])
    dk = np.roll(np.isin(cv.a, [I['q2'], I['q3']]), -1, 0)
    r = np.random.default_rng(seed)
    cv.a[litm & dk & (r.uniform(size=(H, W)) < 0.6)] = I['rim']
    cedge = rock & ~cloud & binary_dilation(cloud & rock) & np.isin(cv.a, [I['g2'], I['g3']])
    cv.a[cedge] = I['g1']
    V.fall_strokes(cv, litm, 'g3', I, n=60, lens=(2, 7), drift=0.05, seed=seed)
    cv.snapshot('1-2 rock: organised values, one concentrated light (cloud shadow on the left 60%)')
    # 3 trees: a dark crowd; spires where a tree mass has its top against rock
    cv.a[tree] = I['c_hole']
    Lt = gaussian_filter(lab[..., 0], 1.0)
    cv.a[tree & (Lt > np.quantile(Lt[tree], 0.5))] = I['c_dark']
    cv.a[tree & cloud & (cv.a == I['c_dark'])] = I['s_dark']
    lab_, n_ = label(tree)
    tops = tree & ~np.roll(tree, 2, 0)
    ys, xs = np.nonzero(tops)
    done = set()
    for i in r.permutation(len(ys)):
        x, y = xs[i], ys[i]
        key = (x // 4, y // 6)
        if key in done:
            continue
        done.add(key)
        h = int(r.integers(7, 15))
        lit = not cloud[y, x]
        V.spire(cv, x, y + h * 0.8, h, I, body='c_mid' if lit else 's_mid', dark='c_dark' if lit else 's_dark',
                lit='c_lit' if lit else 'c_mid', sun=-1, seed=int(x * 7 + y), where=tree | binary_dilation(tree, iterations=2))
    cv.snapshot('3 trees: a dark crowd, spires where a tree top meets the rock, lit tips (sun left) out of the cloud')
    return cv, a


if __name__ == '__main__':
    from sheet import zoom, grid, fit
    cv, a = paint()
    Image.fromarray((cv.rgb() * 255 + .5).astype(np.uint8)).save(f'{ROOT}/places/out/lane_skykomish.png')
    photo = Image.open(f'{ROOT}/places/skykomish_photo.jpg')
    grid([fit(photo, w=640), zoom(a, 2), zoom(cv.rgb(), 2)], 1,
         ['photo (Index Town Walls, SounderBruce, CC BY-SA 4.0)', 'before: the place-skykomish lane render, area-reduced to 320 px', 'after: the same render repainted by the Oga passes'],
         title='The method on a voxsim render: Skykomish, the Index wall').save(f'{ROOT}/sheets/lane_skykomish.png')

cd ~/work/pixelart-studies/books/oga && python3 places/lane_skykomish.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && sed -i '' 's|        key = (x // 4, y // 6)|        key = (x // 7, y // 12)|' places/lane_skykomish.py && python3 places/lane_skykomish.py

# output:
(Bash completed with no output)

cd ~/work/pixelart-studies/books/oga && du -sh . pages refs places sheets work; python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
from PIL import Image
from sheet import zoom, grid, fit
cells=[];labs=[]
for n,lab in [('enchant','Enchantments (200x300)'),('skykomish','Skykomish'),('olycoast','Olympic coast'),('yakima','Yakima'),('sanjuan','San Juan'),('lane_skykomish','voxsim render repainted')]:
    im=Image.open(f'places/out/{n}.png'); cells.append(fit(im,h=360,nearest=True) if n=='enchant' else zoom(im,2)); labs.append(lab)
grid(cells,2,labs,title='Five places painted the Oga way, and one voxsim render repainted (2x)').save('sheets/99_places.png')
cells=[];labs=[]
for f,lab in [('p1_foliage_2x','P1 crowns'),('p3_rocks','P3 rocks'),('p4_meadow','P4 meadow'),('p5_gorge','P5 gorge')]:
    cells.append(fit(Image.open(f'sheets/{f}.png'),w=900)); labs.append(lab)
EOF

# output:
247M    .
149M    pages
 40M    refs
 22M    places
 11M    sheets
5.6M    work

cd ~/work/pixelart-studies/books/oga && sed -i '' "s|    for m, lf in ((mright, np.clip(0.75 - (yy - (168 - OY)) / 30 + 0.15 \* cv.noise(2), 0, 1)),):|    for m, lf in ((mright, 0.7 * np.clip(0.75 - (yy - (168 - OY)) / 30 + 0.15 * cv.noise(2), 0, 1)),):|" places/skykomish.py && python3 places/skykomish.py && ls sheets

# output:
00_plate_swatches.png
00_survives.png
99_places.png
copy1_cover.png
copy1_cover_stages.png
copy2_c0007.png
copy2_c0007_stages.png
ex1a_ground.png
ex1b_plan.png
ex2_ramps.png
ex3_greys.png
ex3b_greys_by_place.png
ex4_gorge.png
ex4_gorge_8x.png
lane_skykomish.png
p1_foliage.png
p1_foliage_2x.png
p2_peak.png
p3_rocks.png
p4_meadow.png
p5_gorge.png
place_enchant.png
place_olycoast.png
place_olycoast_stages.png
place_sanjuan.png
place_sanjuan_stages.png
place_skykomish.png
place_skykomish_stages.png
place_yakima.png
place_yakima_stages.png

cd ~/work/pixelart-studies/books/oga && python3 places/skykomish.py && python3 - <<'EOF'
import sys; sys.path.insert(0,'src')
from PIL import Image
from sheet import zoom, grid, fit
cells=[];labs=[]
for n,lab in [('enchant','Enchantments (200x300)'),('skykomish','Skykomish'),('olycoast','Olympic coast'),('yakima','Yakima'),('sanjuan','San Juan'),('lane_skykomish','voxsim render repainted')]:
    im=Image.open(f'places/out/{n}.png'); cells.append(fit(im,h=360,nearest=True) if n=='enchant' else zoom(im,2)); labs.append(lab)
grid(cells,2,labs,title='Five places painted the Oga way, and one voxsim render repainted (2x)').save('sheets/99_places.png')
EOF
cat >> LESSONS.md <<'EOF'

### 4e. P4: the grass slope (C-0064) — `copies/p4_meadow.py`, `sheets/p4_meadow.png`

- **What his slope is made of:**
  - one plane with an undulation (C-0095, p.53);
  - a broad lemon crest band where it faces the sun, turning through mid green into a dark base;
  - strokes as tapered wedges that lean *along the slope's flow*;
  - contrast inside the mark: darker strokes in the lit band, lighter blades in the dark band, and big dark blade silhouettes at the base;
  - band boundaries broken by blade tips, never a line.
- **Pixel method:**
  1. The value turn is a function of distance below the crest line, modulated a little by his organised values. That alone is stage 1, and it already reads as a slope.
  2. Wedge strokes: 2 px wide at the base, 1 px after, about 28° lean, one step off the local band.
  3. Tips over the crest.
  4. Dark silhouettes at the base.
  5. Flowers as points.
- **First pass:** too busy in the lit crest. His crest is calm, so strokes there are halved (density at the points, p.58).
- **Carries well at 2×.** This is the meadow mark I reuse.

### 4f. P5: light cut into a gorge (C-0792) — `copies/p5_gorge.py`, `sheets/p5_gorge.png`

- **The book's point:** shadow about 2/3; light only on certain planes; three light levels. Reflected light takes the sky's colour, loosened by the object's own colour.
- **Built by hand:**
  1. A blue-black chasm.
  2. Shadowed boulders with moss patches (the object's colour in shadow).
  3. Lit boulders with sun only on their top planes and a 1-px band of the light's colour where the lit plane meets its own shadow.
  4. Detail (cracks) only in the light.
- **Measured:** 14% of pixels are in the light families.
- **Dead end:** I first drew the reflected sky light as a 1–2 px rim on every shadowed boulder. It read as a cartoon outline. In his plate the reflected light is a *plane*: the upper third of each up-facing shadowed boulder, broken by the rock's colour. With that change the gorge fills with his violet-blue.
- **What doesn't carry:** his wet-in-wet softness inside the lit planes. At this size I use one or two steps plus uneven paint.

## 5. The earlier procedural exercise, re-read

`sheets/ex4_gorge.png` (the raycast boulders lit only through a gap) comes to the same conclusion as P5 by another route. Lambert light on every stone gives "a pile of cookies". Letting the light in through a gap puts about 2/3 of the rock in shadow, and the picture gets a subject. It's the one procedural result I kept, because it's a *light decision*, not a texture.

## 6. The places: painting the five the way Oga would

Each study is a script in `places/`. It states Oga's decisions at the top, section by section of MODEL.md, then paints stage by stage (`sheets/place_*_stages.png`).

- **Masses:** hand polygons, or where that is too crude, the photo's own shapes smoothed. That's the "carbon transfer" of the art setting.
- **Light:** always my decision: a cloud shadow, a gap, overcast, or backlight.
- **Marks:** the passage vocabulary (`src/vocab.py`).

Photo credits are in each script and in `places/refs/*/sources.tsv`. One sheet shows everything: `sheets/99_places.png`.

### What happened, in order

- **Skykomish** (`places/skykomish.py`), the Index wall.
  - v1 drew the wall as vertical facets from my imagination and read as a striped curtain.
  - v2 took the wall's planes from the photo's values, organised. Better, but a cold critic said: "nothing says where the sun is, and light and shadow cover about the same area; two identical chartreuse domes steal the eye."
  - v3:
    - a cloud shadow over the left 60% of the wall, its edge following the fall line;
    - lit granite on the right buttresses only, with the light's colour where the cloud edge crosses it;
    - the shadowed granite simplified to three cool steps with a warm loosening;
    - one near maple, mostly in shadow.

  The light now makes the picture. Still weak: the ridge forest band is flat.
- **The generic painter.** For Enchantments, the coast and Yakima I first wrote `src/painter.py`: a Scene of masses plus one function per material, with colour families built by Oga's rules from one key colour.
  - It worked for **Enchantments**: a reflection that mirrors the peak one step down, the clear bed in the near water, skylight on the tops of shadowed boulders, and the larch gold as the only saturated note.
  - It failed the other two. On **the coast** the root mass became "a pale camouflage blob … a crashed plane" and the gravel was uniform. On **Yakima** it drew rectangular cloud boxes and mirrored the hills in a river 30 m wide.

  That was the Genge failure again at a smaller scale: a general machine gives general pictures. I rewrote both by hand.
- **Yakima by hand** (`places/yakima.py`).
  - My ruled geometry read as "a striped flag" and the willow band as fence panels.
  - What fixed it:
    - the photo's own light shape for the hills;
    - the willows as a crowd of tall clumps lit from the upper left, with the gold grass showing between;
    - fence posts without a ruled line;
    - a short mirror of the band in the river;
    - the drift boat as the one point.
  - Still weak: the top-left sky and far ridge, and a pine that reads as a stick.
- **The coast by hand** (`places/olycoast.py`).
  - **Overcast means light from above:** every form is lit on its top plane and dark underneath, and gets a cool soft cast shadow right under it.
  - The forest was improved by a better conifer mark (below).
  - Gravel runs from flat far, to dots, to 2–3 px stones lit on top near.
  - **The root plate still doesn't read.** It's a brown disc with cream folds and radiating roots, like a cake or an umbrella. The photo's root tangle is the hardest subject in the set. At 60 px wide it wants to be drawn root by root, which is exactly what the book says not to do with a crowd. I haven't found its organised impression yet. That's an honest open problem.
- **San Juan** (`places/sanjuan.py`) came out strongest. The critic: "the only one where one light and colourful shadow make up the picture."
  - Backlit oaks as violet masses, with sky holes only near the sun and orange rims of the light at the edges facing it.
  - The meadow glows far and darkens near. The oaks' shadows are cast toward us as dark tongues.
  - The camas are one mark: tiny and dense far, big and sparse near.
  - The mistake: I first scattered the camas uniformly, "one identical stamp in even rows". The fix is the book's crowd principle: **organise the crowd into drifts.** The drift field is smooth noise sampled in *ground* coordinates, so patches are round on the ground and flatten with distance. The camas become a violet sea with gaps.

### A better conifer mark

The first `spire` drew regular tiers of equal width, cartoon Christmas trees. The fix is the cover's step 6 in pixels:
- a 1-px leader;
- branch tiers at irregular 2–4 row intervals, each a short dash of random length left and right, with drooping ends;
- the lit end on the sun side, or on top when overcast;
- the core filled near the trunk so it reads as a mass, not a ladder.

At 4× the coastal forest now reads as spruce against a grey sky.

### The method on a voxsim render (`places/lane_skykomish.py`, `sheets/lane_skykomish.png`)

- **Input:** the place-skykomish lane's render of the same wall, and nothing else.
- **Passes:**
  1. masses from the render (rock and trees by hue);
  2. one light (a cloud shadow on 60%, the lit granite from the render's lightest organised values, the shadow a simple cool family);
  3. trees as a dark crowd, with spires only where a tree top meets rock.
- **Result:** the render's even lighting and neutral black shadows become a picture with a lit buttress and coloured shadow.
- **Still weak:** the render has no sky, no ridge and no foreground, so there's no severing band. Oga's planes can't be invented by a repaint; the lane's camera and composition have to supply them.

## 7. What didn't carry, and why

- **Wet-in-wet** (にじみ, ぼかし). Pixels have no water. I can imitate a bleed's *edge* with ragged tongues and its *unevenness* with broad patches of the adjacent step, but not the soft gradation inside a wash. At 320 px that is mostly fine: his gradations become two or three flat steps with wet seams.
- **The airbrush** (moonlight in the air, C-1482). Its whole point is diffuse light, and there is no pixel equivalent without dithering noise. Use the brush alternative the book gives: light made by shadows cast between trees (C-1486).
- **Brush tempo.** "Know beforehand what shape each brush motion makes" carries as *a mark per material*. The improvised tempo does not carry. Randomness imitates variety, not rhythm; the rhythm has to be designed (tier spacing, drift fields, the alternation of branches).
- **Global statistics.** Coloured greys, a bridging mid-range and concentrated detail don't separate his plates from photos when measured over the whole image. What makes a picture his is *where*: the decisions per plane. Measure locally or not at all.
- **Photos as a source of light.** Photos have their own light, usually spread everywhere. Every study that took its light from the photo came out flat. The light has to be designed per picture: a cloud, a gap, overcast top-light, backlight.

## 8. The rules, for students and the voxsim lanes

These are the book's model reduced to what a pixel painter can apply. Each rule has a passage copy as its reference image and regression test.

1. **Ground first** (地塗り). Decide the masses, one light, and the colour families at the lowest detail. The picture must read at this stage "by its silhouette alone". Detail is a thin last layer that must not break it.
   - *Test:* stage 1 of any `*_stages.png` sheet should already look like the picture.
2. **One light, concentrated** (C-0792). About 60–85% of the area is in shadow. Light falls on certain planes only: the ones facing it, where the world lets it through (a gap, a cloud break, the sky from above when overcast).
   - Never a screen-space spotlight (my first try, `src/oga.py`, did that).
   - *Reference:* `copies/p5_gorge.py`.
3. **Shadow is full of colour.**
   - Faces turned up take the sky's colour as a plane (violet-blue by day). Faces turned down stay darkest. The object's own warm colour is loosened in, in patches.
   - The shadow side is kept simple: three steps, no detail.
   - *Reference:* P3, P5.
4. **The light's colour at its edge** (際). Where a lit plane meets its own shadow, or a silhouette meets the glow, draw a 1-px band of the light's colour: warm by sun, sky-blue on the far edge of a lit rock top, orange at dusk.
   - *Reference:* P3's cobalt rim, San Juan's crown rims.
5. **Ramps.** Hue walks toward yellow as value rises, and chroma *rises* into the light: C ≈ 0.27·(L − 0.18) for greens, capped at 0.17. Never lighten with white or darken with black.
   - Greys are always tinted, and tints belong to places (earth warm, sky and distance violet), not to value steps.
   - Code: `src/palette.py`, `painter.palette_for()`. Measured: `sheets/ex2_ramps.png`, `ex3b`.
6. **A mark per material** (`src/vocab.py`). Know the shape before painting the crowd:
   - broadleaf: rounded clumps at four light levels (P1);
   - conifer: leader plus irregular drooping tiers (the cover's staggered flat brush);
   - far forest: staggered vertical dashes in irregular groups (P2);
   - rock: facets decided by lines, uneven paint inside one step (P3);
   - grass: wedges along the slope's flow, contrast inside the mark (P4);
   - flowers: one spike, organised into drifts (San Juan).
7. **Organise the crowd** (群れを捉える). Members are never scattered uniformly. They sit on the organised values of the mass, or in drifts sampled in ground coordinates, with gaps. About half of a crown mass is hole.
8. **Density only at the points.** Choose one to three points per picture (the lit buttress, the larch band, the boat, the root). Detail goes there; the rest holds at ground level. Lit crests stay calm.
9. **Sever to make depth.** A band of shadow, a willow band or a shore of pale rock between the near and the far. The far is sky-tinted and one step flatter; contrast softens with distance.
10. **Water mirrors what is painted above it, one step down.** Near the viewer you look *into* the water and see the bed. Dash rows of sky colour only in the mirror part. A thin light line where water meets the shore.

### Code

- `src/copykit.py` is the canvas of palette indices, with masses, wet edges, uneven paint, lines, dabs and the majority clean-up.
- `src/vocab.py` holds the marks, each with named palette slots and parameters (sizes, levels, spacing, sun side).
- `src/palette.py` holds the measured ramps. `painter.palette_for(key)` builds a lit family, a shadow family and a warm variant from one key colour.
- `src/painter.py` is the generic Scene painter over masses (form source plus materials plus designed light). **Use it only for a first ground.** My place studies show it gets the ground and the palette right and the marks wrong, unless the marks are placed by hand.
- `copies/*.py` are the passage copies, which are the references and regression tests. `places/*.py` are the five place studies and the lane repaint.
- The procedural ground experiments (`src/ground.py`, `src/scene.py`, `src/oga.py`) are kept as the honest record of §2–3.
EOF
echo ok

# output:
ok
[This command modified 1 file you've previously read: ../books/oga/LESSONS.md. Call Read before editing.]