Terrain round 32: water repaint skips water-coloured ground, colour map keeps callers' colours, small-ground preview cameras, running elapsed time

app/llms.txt

@@ -204,8 +204,10 @@ Request (JSON; only the ground and a prompt are required):
   (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. If you place your own 3D trees,
   make the forest layer their floor: from_above "pine-needle forest floor, no tree crowns" and a brown colour (a
-  green patch is painted as crowns); then no trees are painted anywhere. Presets (when layers is omitted, chosen
-  from the prompt's words): alpine, temperate, desert, arctic, winter, volcanic (GET /api lists them).
+  green patch is painted as crowns); then no trees are painted anywhere. A layer's "color" [r, g, b] is kept:
+  the colour map is turned to its hue (the image model drifts, e.g. red autumn leaves toward olive). 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).

app/server.py

@@ -51,6 +51,12 @@ def identity_from(headers, token: str | None = None) -> Identity:
     return Identity(token=tok or None, ip_token=headers.get("x-ip-token") or None)
 
 
+def elapsed(job) -> float:
+    """Seconds since the job was created: up to now while it runs (the last event's time stood still through a
+    long step, round 32), else up to its last event."""
+    return round((time.time() if job.state in ("queued", "running") else job.updated) - job.created, 1)
+
+
 def terrain_status(job, base: str, events: int = 12) -> dict:
     """The status of a terrain job: progress, the files, what each layer covers, and what to do next."""
     url = f"{base}/api/jobs/{job.id}"
@@ -63,7 +69,7 @@ def terrain_status(job, base: str, events: int = 12) -> dict:
         "job_id": job.id, "kind": "terrain", "state": job.state, "operation": job.op, "progress": job.progress,
         "backend": job.params.get("backend"),
         "quota_identity": job.identity.kind if BACKENDS[job.params["backend"]]["uses_quota"] else "not needed",
-        "elapsed_seconds": round(job.updated - job.created, 1), "files": files, "error": job.error,
+        "elapsed_seconds": elapsed(job), "files": files, "error": job.error,
         "recent_events": job.events[-events:],
     }
     warnings = list(job.result.get("warnings") or []) + list(st.get("warnings") or [])
@@ -211,7 +217,7 @@ def status_payload(job, base: str, events: int = 12) -> dict:
         "job_id": job.id, "state": job.state, "operation": job.op, "progress": job.progress,
         "backend": job.params.get("backend"), "mode": job.params.get("mode"),
         "quota_identity": job.identity.kind if BACKENDS[job.params["backend"]]["uses_quota"] else "not needed",
-        "elapsed_seconds": round(job.updated - job.created, 1), "summary": summary, "files": files,
+        "elapsed_seconds": elapsed(job), "summary": summary, "files": files,
         "views": views, "error": job.error, "recent_events": job.events[-events:],
     }
     last = dict(job.result.get("last") or {})
@@ -544,7 +550,8 @@ class TerrainLayer(BaseModel):
     breakup: float | None = Field(None, ge=0, le=1, description="How irregular the layer's edges are (default 0.5)")
     tile_m: float = Field(4.0, gt=0.2, le=50, description="Size in metres of one repeat of the detail texture")
     color: list[float] | None = Field(None, description="Optional [r, g, b] 0-255 the layer shows in the overview "
-                                                        "guide (default: its detail texture's mean colour)")
+                                                        "guide (default: its detail texture's mean colour); the "
+                                                        "colour map is turned to its hue")
     triplanar: bool | None = Field(None, description="Project the detail texture from the sides on steep slopes "
                                                      "(default: layers whose rules start at 30 degrees or more)")
     from_above: str | None = Field(None, description="How the layer looks from high above in the colour map, if "

projtex/terrain.py

@@ -1053,6 +1053,44 @@ def _lab(rgb) -> np.ndarray:
     return cv2.cvtColor(np.asarray(rgb, np.float32).reshape(1, 1, 3), cv2.COLOR_RGB2LAB)[0, 0]
 
 
+def match_colours(img: np.ndarray, W: np.ndarray, layers: list[dict], keep: np.ndarray | None = None,
+                  chroma: float = 0.5, cap: float = 15.0) -> np.ndarray:
+    """The colour map with each layer the caller gave a ``color`` turned toward that colour's hue (and half way to
+    its chroma, at most ``cap`` in a*b*), lightness and texture as painted. The image model drifts toward its idea
+    of the place: October leaf litter asked for in rust (126, 74, 38) came back olive brown, a* 19 -> 6, and red
+    blueberry scrub olive, hue 55 -> 94 degrees (round 32): the tester recoloured the materials by hand.
+    ``W`` and ``keep`` (0..1, where to change it: not the caller's water) are at the splat map's size; the shift is
+    measured there and resized to the image."""
+    import cv2
+
+    S = W.shape[1]
+    lab = lambda a: cv2.cvtColor(np.clip(a, 0, 1).astype(np.float32), cv2.COLOR_RGB2LAB)  # noqa: E731
+    small = lab(cv2.resize(img, (S, S), interpolation=cv2.INTER_AREA) if img.shape[0] != S else img)
+    shift = np.zeros((S, S, 2), np.float32)
+    inner = np.ones((S, S), bool) if keep is None else keep > 0.5
+    for i, L in enumerate(layers):
+        if not L.get("color"):
+            continue
+        m = cv2.erode(((W[i] > 0.7) & inner).astype(np.uint8), np.ones((5, 5), np.uint8)) > 0
+        if m.sum() < max(100, 1e-4 * m.size):
+            continue
+        ab = small[m][:, 1:].mean(0)
+        want = _lab(guide_colour(L))[1:]
+        c, wc = float(np.hypot(*ab)), float(np.hypot(*want))
+        tc = c + chroma * (wc - c)
+        target = want * tc / wc if wc > 3 else ab * tc / max(c, 1e-6)  # a grey has no hue to turn to
+        d = target - ab
+        d *= min(1.0, cap / max(float(np.linalg.norm(d)), 1e-6))
+        shift += W[i][..., None] * d.astype(np.float32)
+    if keep is not None:
+        shift *= keep[..., None]
+    if not shift.any():
+        return img
+    out = lab(img)
+    out[..., 1:] += cv2.resize(shift, img.shape[1::-1], interpolation=cv2.INTER_LINEAR) if img.shape[0] != S else shift
+    return np.clip(cv2.cvtColor(out, cv2.COLOR_LAB2RGB), 0, 1)
+
+
 def lift_darks(colors: np.ndarray, floor: float = 18.0, knee: float = 30.0) -> np.ndarray:
     """Guide colours (sRGB 0..1) darker than ``knee`` L* pressed into ``floor``..``knee``, their order kept: flat
     near-black reads as ink drawn on the picture, not as ground (round 31: black lava flows, L* 6, were painted
@@ -1257,14 +1295,18 @@ _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, cell=(1.0, 1.0)) -> tuple[np.ndarray, int]:
+                      relief: float, water_rgb, cell=(1.0, 1.0), guide: np.ndarray | None = None
+                      ) -> 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. 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."""
+    slopes up to 30 degrees, at most 6 m up). Nor does ground asked for in a colour like water's (``guide``, the
+    colour map the model was given): Iceland's black sand and lava were within 12 of it, and repainting them in
+    the only colour left, the glacier's, ringed the lava with white (round 32). ``H``, ``W`` and ``guide`` 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
 
@@ -1283,12 +1325,17 @@ def dry_painted_water(img: np.ndarray, H: np.ndarray, level: float, W: np.ndarra
     fallback = np.median(L[plain], 0) if plain.sum() >= 30 else ground
     if fallback is None:
         return img, 0
-    refs = [np.median(L[(w > 0.6) & plain], 0) if ((w > 0.6) & plain).sum() >= 30 else fallback for w in W]
+    G = None if guide is None else lab(guide)
+    asked = [np.median(G[w > 0.6], 0) if G is not None and (w > 0.6).sum() >= 30 else None for w in W]
+    refs = [np.median(L[(w > 0.6) & plain], 0) if ((w > 0.6) & plain).sum() >= 30 else
+            a if a is not None else fallback for w, a in zip(W, asked)]
     E = np.einsum("lhw,lc->hwc", W, np.stack(refs).astype(np.float32))
+    A = np.einsum("lhw,lc->hwc", W, np.stack([r if a is None else a for a, r in zip(asked, refs)]).astype(np.float32))
     de = np.linalg.norm(L - E, 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)))
+    wet &= np.linalg.norm(A - mu, axis=-1) > 20  # ground asked for in a colour like water's: cannot tell them apart
     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
@@ -1716,7 +1763,8 @@ class Terrain:
             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],
-                                         (self.state["depth_m"] / H.shape[0], self.state["width_m"] / H.shape[1]))
+                                         (self.state["depth_m"] / H.shape[0], self.state["width_m"] / H.shape[1]),
+                                         guide=resample(g, ov.shape[0]))
             if n:
                 _save(self.root / "macro" / "overview_raw.png", ov)
                 ov = fixed
@@ -1790,6 +1838,12 @@ class Terrain:
             tiles = {(i, j): _load(d / f"tile_{i}_{j}.png") for i in range(lay["n"]) for j in range(lay["n"])}
             macro = merge_tiles(tiles, lay, ov)
         F = macro.shape[0]
+        W = self.weights()
+        keep = None
+        if self.prm.get("water_level") is not None:  # the water painted below the caller's plane stays water
+            H = resample(np.load(self.root / "mesh" / "height.npy").astype(np.float32), W.shape[1])
+            keep = cv2.GaussianBlur((H >= float(self.prm["water_level"])).astype(np.float32), (0, 0), 1)
+        macro = match_colours(macro, W, self.state["layers"], keep)
         _save(self.root / "macro" / "macro.jpg", macro, quality=92)
         self.state["macro_file"] = "macro/macro.jpg"
         (x0, _), (x1, _) = self.bounds
@@ -1797,7 +1851,6 @@ class Terrain:
         self.state["macro_soft_file"] = "macro/macro_soft.jpg"
         # colour modulation for engines that multiply splatted layers by a colour map (Unity/Godot style):
         # lowpass(macro) / lowpass(sum of w_i * layer mean), linear, stored halved (0.5 = x1)
-        W = self.weights()
         means = np.stack([np.asarray(L.get("mean_linear") or [0.2, 0.2, 0.2], np.float32)
                           for L in self.state["layers"]])
         S = W.shape[1]
@@ -1955,19 +2008,25 @@ class Terrain:
         if drawn:
             near_drawn = ndi.uniform_filter(W[drawn].sum(0), max(3, S // 30))
             score = score + 0.8 * near_drawn / max(float(near_drawn.max()), 1e-6)
+        m = S // 8
+        score[:m], score[-m:], score[:, :m], score[:, -m:] = -1e9, -1e9, -1e9, -1e9
         wl = self.prm.get("water_level")
         if wl is not None:  # look at the land, not at the bed of the caller's lake (round 28)
             Hs = resample(H, S)
-            score[Hs < float(wl) + max(0.3, 0.002 * self.state["relief_m"])] = -1e9
-        m = S // 8
-        score[:m], score[-m:], score[:, :m], score[:, -m:] = -1e9, -1e9, -1e9, -1e9
+            # a zen garden's gravel was 6 cm above its pond's level: all of it "lake bed", and the views went to
+            # the corner (round 32)
+            for above in (max(0.3, 0.002 * self.state["relief_m"]), 0.0):
+                if (score[Hs >= float(wl) + above] > -1e8).any():
+                    score[Hs < float(wl) + above] = -1e9
+                    break
         r, cc = np.unravel_index(int(np.argmax(score)), score.shape)
         px, pz = x0 + (cc + 0.5) / S * (x1 - x0), z0 + (r + 0.5) / S * (z1 - z0)
         toward = np.array([c[0] - px, c[2] - pz])
         toward = toward / (np.linalg.norm(toward) + 1e-9)
-        for name, dd, hh, fov in (("mid", float(np.clip(0.12 * span, 40, 350)), 0.45, 50),
-                                  ("near", float(np.clip(0.004 * span, 4, 12)), 0.4, 60)):
+        for name, dd, hh, fov in (("mid", float(np.clip(0.12 * span, min(40, 0.3 * span), 350)), 0.45, 50),
+                                  ("near", float(np.clip(0.004 * span, min(4, 0.1 * span), 12)), 0.4, 60)):
             ex, ez = px - toward[0] * dd, pz - toward[1] * dd
+            ex, ez = np.clip(ex, x0, x1), np.clip(ez, z0, z1)  # over the ground, not beyond its edge
             ey = max(self._ground_y(H, ex, ez), self._ground_y(H, px, pz), float(wl) if wl is not None else -1e18) \
                 + hh * dd
             tgt = [px, self._ground_y(H, px, pz), pz]