Terrain round 30: drawn layers with rules stay in their shapes, forest-floor swatches, water repaint only on low gentle ground

app/llms.txt

@@ -193,17 +193,17 @@ Request (JSON; only the ground and a prompt are required):
   20 % of the layer's area in natural patches (dirt in grass). paths/areas are ground coordinates in metres:
   [x, z] of glTF / three.js; from Blender pass "axes": "z-up" and give [x, y]. A layer with only paths or areas
   exists only there (roads, fields); with rules too, the rules apply inside them.
-  The layer prompt describes the ground close up (it becomes a 1024 px photo texture of tile_m metres); the main
-  prompt describes the place as a whole: climate, season, region. The colour map shows only the ground: buildings
-  named in the prompt are left out (put them in your scene as 3D models; texture them with POST /api/jobs and give
-  the ground around them as a layer area, e.g. a yard), and roads or streams drawn by a layer's paths follow your
-  points, not the prompt's words. Trees and bushes appear only when the prompt or a layer asks for them, and with a
-  forest layer only inside it (ask for "scattered trees" or "hedgerows" to get them elsewhere). The texture repeats
-  in fixed directions, so describe surfaces, not structures with a direction: "packed gravel", not "a lane with two
-  ruts and a grass strip" (paths get an even surface automatically). "from_above" (optional) says how a layer looks
-  in the colour map when that differs from its close-up; forests and woods default to their tree crowns. Presets
-  (when layers is omitted, chosen from the prompt's words): alpine, temperate, desert, arctic, winter, volcanic (GET
-  /api lists them).
+  The layer prompt describes the ground close up (it becomes a 1024 px photo texture of tile_m metres, made from
+  that prompt alone: name the material, "groomed snow piste", not "groomed piste"); the main prompt describes the
+  place as a whole: climate, season, region. The colour map shows only the ground: buildings named in the prompt are
+  left out (put them in your scene as 3D models; texture them with POST /api/jobs and give the ground around them as
+  a layer area, e.g. a yard), and roads or streams drawn by a layer's paths follow your points, not the prompt's
+  words. Trees and bushes appear only when the prompt or a layer asks for them, and with a forest layer only inside
+  it (ask for "scattered trees" or "hedgerows" to get them elsewhere). The texture repeats in fixed directions, so
+  describe surfaces, not structures with a direction: "packed gravel", not "a lane with two ruts and a grass strip"
+  (paths get an even surface automatically). "from_above" (optional) says how a layer looks in the colour map when
+  that differs from its close-up; forests and woods default to their tree crowns. Presets (when layers is omitted,
+  chosen from the prompt's words): alpine, temperate, desert, arctic, winter, volcanic (GET /api lists them).
 - uv: planar (default: terrain.glb gets top-down UVs) | keep (the colour map is baked into your own UVs).
 - backend: qwen-turbo (default) | qwen-space | mock (free dry run). Cost: layers + 1 + tiles images (2048: about
   15 images, ~2 min of GPU quota and ~2-3 min in all; 4096: ~31 images).

projtex/terrain.py

@@ -305,8 +305,9 @@ def splat_weights(maps: dict, layers: list[dict], seed: int = 0) -> np.ndarray:
     W = np.zeros((len(layers), size, size), np.float32)
     for i, L in enumerate(layers):
         w = np.ones((size, size), np.float32)
-        if i and not L.get("where") and (L.get("paths") or L.get("areas")):
-            w[:] = 0  # drawn only where its shapes are (added by Terrain.plan)
+        if i and (L.get("paths") or L.get("areas")):
+            w[:] = 0  # drawn only where its shapes are, its rules applied there (Terrain.plan); round 30: with
+            # rules too it also covered every slope its rules allow, 38 % of a fjord for a 0.6 % village green
         elif i:
             br = float(L.get("breakup", 0.5))
             nz = fbm(size, 6, 5, seed * 1000 + 17 * i) if br > 0 else 0.0
@@ -890,6 +891,35 @@ def wooded(layer: dict) -> bool:
     return bool(re.search(_WOODED, text, re.I))
 
 
+_TREE_PARTS = (r"\b(?:trunks?|crowns?|canop(?:y|ies)|trees?|branch(?:es)?|foliage|woodlands?|woods|forests?|groves?|"
+               r"copses?|thickets?|jungles?)\b(?!\s+floor)")
+_WOOD_NOUN = r"\b(?:woodlands?|woods|forests?|groves?|copses?|thickets?|jungles?|orchards?)\b"
+
+
+def floor_words(prompt: str) -> str:
+    """What a wooded layer's detail texture shows: the ground under the trees. A prompt describing the trees
+    ("dense Nordic birch woodland: slender white birch trunks, bright fresh green canopy, ...") gave a swatch of a
+    whole wood seen from afar, tiled on the ground every 8 m (round 30); asking for "the forest floor under" it kept
+    the trees. Clauses about the trees are dropped; the ground clauses stay, after the wood's name."""
+    import re
+
+    clauses = [c.strip() for c in re.split(r"[,;:.]", prompt or "") if c.strip()]
+    trees = [c for c in clauses if re.search(_TREE_PARTS, c, re.I)]
+    if not trees:
+        return prompt
+    ground = []
+    for c in clauses:  # "gnarled olive trees on dry red earth with stones": the earth stays
+        tail = re.search(r"\b(?:on|over|among|in)\s+(.+)$", c, re.I) if c in trees else None
+        if c not in trees or (tail and not re.search(_TREE_PARTS, tail.group(1), re.I)):
+            ground.append(c if c not in trees else tail.group(1))
+    # the wood's name: its noun and up to three words before it ("dense Nordic birch woodland")
+    m = re.search(r"\b((?:(?!(?:in|on|of|a|an|the|with|and|trees?)\b)[\w-]+\s+){0,3})" + _WOOD_NOUN, " ".join(trees),
+                  re.I)
+    wood = m.group(0).strip() if m else "woodland"
+    return (f"forest floor of {'an' if wood[0].lower() in 'aeiou' else 'a'} {wood}: "
+            + (", ".join(ground) if ground else "fallen leaves or needles, twigs and moss"))
+
+
 def guide_colour(layer: dict) -> np.ndarray:
     """A layer's colour in the overview's guide: the given colour, else canopy green for trees (the guide must
     agree with the legend: a forest floor's brown under "pine tree crowns" made the model ignore the guide), else
@@ -1127,11 +1157,14 @@ _WATER_LAYER = r"\b(?:water|rivers?|streams?|creeks?|brooks?|ponds?|lakes?|sea|o
 
 
 def dry_painted_water(img: np.ndarray, H: np.ndarray, level: float, W: np.ndarray, layers: list[dict],
-                      relief: float, water_rgb) -> tuple[np.ndarray, int]:
+                      relief: float, water_rgb, cell=(1.0, 1.0)) -> tuple[np.ndarray, int]:
     """Water the image model painted on ground above the caller's water plane, repainted in the colour its layers
     have elsewhere in the image. Measured (round 29): an 18 m pond in an 800 m desert was painted 33 to 52 times
     its area whatever the prompt said; under the caller's water plane the extra became dark blue "water" on dry
-    sand. ``H`` and ``W`` are at the image's size; returns the image and the number of pixels repainted."""
+    sand. Only gentle ground near the level counts (under 30 degrees, within max(10 m, 2 % of the relief)): shaded
+    fjord cliffs hundreds of metres up are as dark and blue as water (round 30; the oasis's extra water lay on
+    slopes up to 30 degrees, at most 6 m up). ``H`` and ``W`` are at the image's size, ``cell`` its metres per pixel
+    (along Z, along X); returns the image and the number of pixels repainted."""
     import cv2
     import re
 
@@ -1153,7 +1186,9 @@ def dry_painted_water(img: np.ndarray, H: np.ndarray, level: float, W: np.ndarra
     refs = [np.median(L[(w > 0.6) & plain], 0) if ((w > 0.6) & plain).sum() >= 30 else fallback for w in W]
     E = np.einsum("lhw,lc->hwc", W, np.stack(refs).astype(np.float32))
     de = np.linalg.norm(L - E, axis=-1)
-    wet = dry & (dw < de) & (dw < np.maximum(12.0, 0.5 * np.linalg.norm(E - mu, axis=-1)))
+    gz, gx = np.gradient(H.astype(np.float64), float(cell[0]), float(cell[1]))
+    low = (np.degrees(np.arctan(np.hypot(gx, gz))) < 30) & (H < level + max(10.0, 0.02 * relief))
+    wet = dry & low & (dw < de) & (dw < np.maximum(12.0, 0.5 * np.linalg.norm(E - mu, axis=-1)))
     keep = [i for i, Lr in enumerate(layers) if re.search(_WATER_LAYER, Lr.get("name", "").replace("_", " "), re.I)]
     if keep:
         wet &= W[keep].sum(0) < 0.3
@@ -1492,7 +1527,10 @@ class Terrain:
             seed = self._seed("layer:" + L["name"], new_seeds)
             col = np.asarray(L["color"], np.float32) / 255 if L.get("color") else np.asarray(default_colour(L))
             path = bool(L.get("paths"))
-            prompt = SWATCH_PROMPT.format(m=L["tile_m"], p=surface_words(L["prompt"]) if path else L["prompt"])
+            words = surface_words(L["prompt"]) if path else floor_words(L["prompt"]) if wooded(L) else L["prompt"]
+            if words != L["prompt"]:
+                L["detail_prompt"] = words
+            prompt = SWATCH_PROMPT.format(m=L["tile_m"], p=words)
             if path:  # the texture repeats in fixed directions: ruts or edge lines would cross the road
                 prompt += (" Only the road surface material itself, even all over: no edges, verges, ruts, lines or "
                            "stripes running across it.")
@@ -1573,7 +1611,8 @@ class Terrain:
             H = resample(np.load(self.root / "mesh" / "height.npy").astype(np.float32), ov.shape[0])
             fixed, n = dry_painted_water(ov, H, float(self.prm["water_level"]), self.weights(ov.shape[0]),
                                          self.state["layers"], self.state["relief_m"],
-                                         water_look(self.prm.get("prompt", ""))[0])
+                                         water_look(self.prm.get("prompt", ""))[0],
+                                         (self.state["depth_m"] / H.shape[0], self.state["width_m"] / H.shape[1]))
             if n:
                 _save(self.root / "macro" / "overview_raw.png", ov)
                 ov = fixed