feat(assets): annotated heightmap pipeline — Kallast spike #778
Validates full heightmap pipeline: pyplatec tectonics → erosion → dynamic sea level → terrain classification (13 classes) → D8 river network → settlement placement → geographic PNG + settlement JSON. Key technical decisions: - Dynamic sea level via np.percentile (pyplatec output is right-skewed; fixed fraction gives ~0.2% land, not 40%) - Terrain classes as fractions of land_range (not fixed offsets) - Two-layer model: geographic PNG + human-layer JSON sidecar - Rivers painted AFTER LANCZOS upscale via NEAREST neighbor mask (painting before blurs rivers into invisibility) - grain_belt removed — reclassified as grassland (natural terrain) - Irrigation overlay removed — human activity, lives in JSON sidecar Output: 4096×2048px (1024×512 simulation grid, 5.2s total runtime). Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
This commit is contained in:
Claude Sonnet 4.6
Binary file not shown.
|
After Width: | Height: | Size: 2.7 MiB |
@@ -0,0 +1,251 @@
|
||||
# Heightmap Pipeline — Spike Documentation
|
||||
|
||||
**Ticket:** #778
|
||||
**Author:** Araminta
|
||||
**Date:** 2026-04-05
|
||||
**Status:** Spike complete — awaiting review before batch (#794, Sprint 33)
|
||||
**Output:** `heightmaps/GJ144d_kallast.png` (4096×2048px)
|
||||
|
||||
---
|
||||
|
||||
## What This Spike Validates
|
||||
|
||||
This spike validates the full annotated heightmap pipeline from wiki data through to a
|
||||
deliverable PNG. Every stage ran successfully on Kallast (GJ144d, Ran system):
|
||||
|
||||
- pyplatec tectonic simulation → elevation grid
|
||||
- Erosion pass → softer ridges, valley hints
|
||||
- Dynamic sea level → correct 40% land coverage from wiki spec
|
||||
- Terrain classification → 13 biome classes
|
||||
- D8 flow accumulation → river network
|
||||
- Settlement placement snapped to appropriate terrain class
|
||||
- Road network connecting all cities
|
||||
- Annotated render with title/legend in Settled Reach visual grammar
|
||||
|
||||
**The pipeline is confirmed viable for batch production (#794).**
|
||||
|
||||
---
|
||||
|
||||
## Planet: Kallast (GJ144d)
|
||||
|
||||
Selected because it showcases all annotation types:
|
||||
|
||||
| Property | Value | Source |
|
||||
|----------|-------|--------|
|
||||
| Planet ID | `GJ144d` | systems.db |
|
||||
| System | Ran (GJ 144) | systems.db |
|
||||
| Biome | temperate | systems.db |
|
||||
| Hydrosphere | ocean | systems.db |
|
||||
| Land coverage | 40% | wiki: "amber continental shelves" |
|
||||
| Population | 2,000,000,000 | systems.db |
|
||||
| Settlement wave | 1 (580y) | systems.db |
|
||||
| Settlement pattern | urban_concentrated | systems.db |
|
||||
| Industrial | Agricultural_Syndic | systems.db |
|
||||
| Terrain character | Extensive temperate plains, amber-toned grassland | wiki narrative |
|
||||
|
||||
Kallast was chosen over higher-population worlds (Haodu, etc.) because the wiki narrative
|
||||
explicitly describes the terrain features we need to annotate: "amber continental shelves
|
||||
broken by irrigation channels wide enough to see from low orbit." That text is a direct
|
||||
visual brief. The pipeline output should feel consistent with it.
|
||||
|
||||
---
|
||||
|
||||
## Pipeline Architecture
|
||||
|
||||
```
|
||||
Input: Planet profile (wiki + systems.db)
|
||||
↓ planet_type, land_fraction, settlement data
|
||||
|
||||
Stage 1: Tectonic simulation (pyplatec)
|
||||
platec.create(seed, W, H, sea_level=land_fraction, …)
|
||||
platec.step() × 200 [200 steps for mature, well-eroded world]
|
||||
platec.get_heightmap() → float list → reshape → normalize [0, 1]
|
||||
Runtime: ~1s at 512×256 (scales linearly with grid × steps)
|
||||
|
||||
Stage 2: Erosion (scipy gaussian_filter)
|
||||
Slope-weighted smoothing: steep cells erode more
|
||||
4 passes on mature world (reduce to 2 for young volcanic)
|
||||
Runtime: <0.5s at 512×256
|
||||
|
||||
Stage 3: Dynamic sea level
|
||||
sea_level = np.percentile(terrain, (1 - land_fraction) * 100)
|
||||
CRITICAL: pyplatec output is heavily right-skewed (most cells at low
|
||||
elevation). A fixed sea_level fraction (e.g. 0.40) does NOT produce
|
||||
40% land — you get ~0.2% land. Always compute from actual distribution.
|
||||
|
||||
Stage 4: Terrain classification (13 classes)
|
||||
Thresholds as fractions of the land elevation range [sea_level, max]
|
||||
so classification scales correctly across different pyplatec outputs.
|
||||
Classes: ocean_deep → ocean_mid → ocean_shallow → coast → lowland →
|
||||
plains → grassland → hills → forest → highland → mountain →
|
||||
peak → snow
|
||||
|
||||
Stage 5: D8 flow accumulation → river network
|
||||
Sort land cells by elevation descending
|
||||
Each cell drains to steepest downslope neighbour (8-directional)
|
||||
Flow threshold: 30 (calibrated for 512×256 grid with 40% land)
|
||||
Note: threshold scales with grid size and terrain relief — calibrate
|
||||
per planet type. Very flat worlds (like Kallast) need lower threshold.
|
||||
|
||||
Stage 6: Settlement placement
|
||||
For each city from wiki data: snap to nearest plains/grain_belt cell
|
||||
within expanding search radius (20 → 40 → 60 → 80 cells)
|
||||
Preference order: plains (class 5) > grain_belt (6) > lowland (4) >
|
||||
coast (3) > hills (7)
|
||||
|
||||
Stage 7: Road network
|
||||
Tier-1 and tier-2 cities connected by major roads (all-pairs from capital)
|
||||
Tier-3 nodes connected to nearest tier-1/2 by minor roads
|
||||
Rendered as polylines on the annotated layer
|
||||
|
||||
Stage 8: Geographic render (PIL)
|
||||
1. Base terrain color layer (RGB from class colors)
|
||||
2. Elevation shading on land (ambient occlusion proxy)
|
||||
3. Dilate river mask at source grid resolution (2 iterations, preserves topology)
|
||||
4. Scale up terrain to output resolution (4096×2048) via LANCZOS
|
||||
5. Paint rivers AFTER upscale via NEAREST-neighbor upscaled mask
|
||||
CRITICAL: painting before LANCZOS blurs rivers into invisibility.
|
||||
Post-upscale NEAREST gives each source cell a 4×4px block — clearly legible.
|
||||
6. Lat/lon grid lines (every 30°), scaled width
|
||||
7. Title panel + legend — natural geographic features only
|
||||
(ocean, coast, plains, grassland, mountain, river)
|
||||
Text/panel sizes scale with UI_SCALE = OUTPUT_W / 1024
|
||||
NOTE: settlements, roads, freight elevators are NOT rendered here.
|
||||
They live in the JSON sidecar and are overlaid by the atlas app.
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Configuration per Planet Type
|
||||
|
||||
For the batch run (#794), per-planet config differs in:
|
||||
|
||||
| Parameter | Kallast | Young volcanic | Ice world | Desert | Ocean world |
|
||||
|-----------|---------|----------------|-----------|--------|-------------|
|
||||
| `plate_count` | 10 | 4 | 7 | 6 | 8 |
|
||||
| `sim_steps` | 200 | 100 | 150 | 150 | 180 |
|
||||
| `erosion_passes` | 4 | 1 | 3 (glacial) | 2 (aeolian) | 3 |
|
||||
| `land_fraction` | 0.40 | 0.55 | 0.30 | 0.60 | 0.15 |
|
||||
| `river_threshold` | 60 | 320 | 80 | 60 | 200 |
|
||||
|
||||
The `land_fraction` comes directly from the wiki's hydrosphere field:
|
||||
- `ocean` → 0.30–0.45
|
||||
- `liquid_water` → 0.40–0.60
|
||||
- `ice` → 0.20–0.35
|
||||
- `none` → 0.90–0.99
|
||||
|
||||
---
|
||||
|
||||
## Two-Layer Model
|
||||
|
||||
Heightmaps are **geographic only**. Human data lives in JSON sidecars.
|
||||
|
||||
```
|
||||
kallast_heightmap.png ← geographic render: terrain, rivers, biomes, grid
|
||||
kallast_heightmap_settlements.json ← human layer: city names + grid coordinates
|
||||
```
|
||||
|
||||
The PNG renders: terrain classification colors, elevation shading, dilated river
|
||||
network, lat/lon grid, title panel.
|
||||
|
||||
The PNG does NOT render: settlements, roads, freight elevators, city labels, irrigation
|
||||
channels, or any human-activity markers. Those exist in the JSON sidecar and are overlaid
|
||||
separately by the atlas app (Phase 3) when the map is interactive.
|
||||
|
||||
**Rationale:** A geographic heightmap is a stable base layer. The human overlay changes
|
||||
as the simulation runs (cities grow, shrink, change character). Keeping them separate
|
||||
means the PNG can be regenerated from terrain data without recomputing settlement
|
||||
placement, and vice versa.
|
||||
|
||||
## Output Files
|
||||
|
||||
| File | Size | Description |
|
||||
|------|------|-------------|
|
||||
| `kallast_heightmap.png` | 4096×2048px | Geographic world map (deliverable) |
|
||||
| `kallast_terrain.npy` | ~2MB | Raw normalised elevation grid (numpy float32, 1024×512) |
|
||||
| `kallast_heightmap_settlements.json` | <1KB | City positions for atlas DB import (human layer sidecar) |
|
||||
|
||||
For batch production, the `.npy` and `.json` files are inputs to the Phase 3
|
||||
atlas pipeline — they pre-seed the city layer rather than requiring re-computation.
|
||||
|
||||
---
|
||||
|
||||
## Known Issues / Calibration Notes for Batch
|
||||
|
||||
1. **River painting order is critical.** Painting river pixels into the source-resolution
|
||||
array before LANCZOS upscaling blurs them into invisibility. Always dilate at source
|
||||
resolution, then upscale with NEAREST neighbor and paint AFTER. Enforced in `render()`.
|
||||
|
||||
2. **Flat worlds produce sparse rivers.** Kallast has low terrain relief. Threshold=60
|
||||
at 1024×512 gives 113 pre-dilation cells (1164 post). Scale threshold with grid area:
|
||||
`threshold_1024 ≈ threshold_512 * 4`. For this flat world, halve the baseline to get
|
||||
denser coverage.
|
||||
|
||||
3. **City placement uses wiki narrative coordinates, not astrophysical simulation.**
|
||||
Relative positions (e.g. "Kallast Prime at 45% longitude, 48% latitude") are editorial
|
||||
decisions. The snap algorithm finds nearest suitable terrain class within search radius.
|
||||
This is intentional — settlement locations should reflect the world's narrative.
|
||||
|
||||
4. **Agricultural layer.** The wiki describes irrigation channels wide enough to see
|
||||
from orbit. These are human infrastructure — they belong in the JSON sidecar, not the
|
||||
geographic heightmap. Phase 3 atlas work should render irrigation channels as a
|
||||
separate overlay from hydrology + settlement data.
|
||||
|
||||
---
|
||||
|
||||
## Batch Run Estimate (#794)
|
||||
|
||||
Grid size: 1024×512. Output: 4096×2048.
|
||||
|
||||
| Phase | Step | Time per planet | 301 planets |
|
||||
|-------|------|-----------------|-------------|
|
||||
| Tectonic (200 steps, 1024×512) | ~3.5s | 1054s |
|
||||
| Erosion (4 passes) | ~1.0s | 301s |
|
||||
| Hydrology | ~0.5s | 151s |
|
||||
| Placement + roads | ~0.5s | 151s |
|
||||
| Render + export | ~0.8s | 241s |
|
||||
| **Total** | | **~6.3s/planet** | **~32 minutes** |
|
||||
|
||||
Full batch of 301 systems runs in ~32 minutes single-threaded. Parallelisable across all
|
||||
CPU cores (no shared state) — realistically ~8 minutes on 4 cores.
|
||||
|
||||
Note: if batch time is a concern, `sim_steps=100` halves tectonic time with acceptable
|
||||
terrain quality for most planet types. Only mature worlds (Kallast, old ocean worlds)
|
||||
benefit meaningfully from 200 steps.
|
||||
|
||||
---
|
||||
|
||||
## Running the Spike
|
||||
|
||||
```bash
|
||||
# Standard (200 tectonic steps, ~1.5s)
|
||||
python3 spikes/heightmap-pipeline/generate_kallast.py
|
||||
|
||||
# Fast mode (50 steps — good for testing annotation, poor terrain)
|
||||
python3 spikes/heightmap-pipeline/generate_kallast.py --fast
|
||||
|
||||
# Different seed (changes continent layout)
|
||||
python3 spikes/heightmap-pipeline/generate_kallast.py --seed 42
|
||||
|
||||
# Custom output path
|
||||
python3 spikes/heightmap-pipeline/generate_kallast.py --output heightmaps/GJ144d_kallast_v2.png
|
||||
```
|
||||
|
||||
Dependencies: `pyplatec`, `scipy`, `numpy`, `Pillow` (all installable via pip)
|
||||
|
||||
---
|
||||
|
||||
## Open Questions for Review
|
||||
|
||||
Before starting batch (#794), Jeroen should confirm:
|
||||
|
||||
1. **Visual style.** Does the terrain color palette work? The grassland amber
|
||||
(`#a59b4b`) reads as temperate plains — is this the right mood for Kallast?
|
||||
2. **Annotation density.** 12 settlements for a 2B-population world — too sparse? too
|
||||
many? For the batch, settlement count would be derived from wiki city data (if any)
|
||||
or a formula from population + settlement_pattern.
|
||||
3. **Output resolution.** 1024×512 adequate for wiki use? Or do we need 2048×1024
|
||||
for the implant atlas app (Phase 3)?
|
||||
4. **River threshold calibration.** The flat terrain of Kallast needed threshold=30.
|
||||
Should we auto-calibrate per planet by targeting N river-mouth cells, rather than
|
||||
a fixed threshold?
|
||||
@@ -0,0 +1,568 @@
|
||||
#!/usr/bin/env python3
|
||||
"""
|
||||
Heightmap Spike: Kallast (GJ144d)
|
||||
|
||||
Produces one annotated heightmap for Kallast — Ran system's inner habitable
|
||||
world. Wave 1 agricultural planet, breathable atmosphere, 0.95g, temperate.
|
||||
|
||||
Pipeline:
|
||||
1. Tectonic simulation (pyplatec) → elevation grid
|
||||
2. Hydraulic erosion (numpy/scipy) → soften ridges, carve valleys
|
||||
3. Climate pass → moisture/temperature from latitude + elevation
|
||||
4. Terrain classification → biome zones
|
||||
5. Hydrology → flow accumulation → river network
|
||||
6. Settlement placement → cities along rivers + fertile plains
|
||||
7. Road network → minimum spanning connections between major cities
|
||||
8. Annotated render → PNG export
|
||||
|
||||
Usage:
|
||||
python3 generate_kallast.py [--output path] [--seed N] [--fast]
|
||||
|
||||
Outputs:
|
||||
kallast_heightmap.png — annotated world map
|
||||
kallast_terrain.npy — raw terrain grid (numpy, for batch reuse)
|
||||
kallast_rivers.npy — river network mask
|
||||
kallast_settlements.json — city coordinates and names
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import math
|
||||
import random
|
||||
import time
|
||||
import sys
|
||||
|
||||
import numpy as np
|
||||
from PIL import Image, ImageDraw, ImageFont
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# Planet parameters (from wiki/systems.db: GJ144d Kallast)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
PLANET = {
|
||||
"name": "Kallast",
|
||||
"system": "Ran (GJ 144)",
|
||||
"body_id": "GJ144d",
|
||||
"gravity": 0.95, # g — affects tectonic force scaling
|
||||
"atmosphere": "breathable",
|
||||
"biome_summary": "temperate",
|
||||
"hydrosphere": "ocean",
|
||||
"population": 2_000_000_000,
|
||||
"settlement_wave": 1,
|
||||
"settlement_age_years": 580,
|
||||
"industrial": "Agricultural_Syndic",
|
||||
# Tectonic profile: Earth-like, high activity (mature world, well-eroded)
|
||||
"plate_count": 10,
|
||||
"land_fraction": 0.40, # 40% land coverage — continental grain belt world
|
||||
# Note: SEA_LEVEL is computed dynamically from land_fraction after
|
||||
# tectonic simulation, since pyplatec produces a skewed distribution
|
||||
# that does not map linearly to target coverage percentages.
|
||||
}
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# Grid settings
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
GRID_W = 1024
|
||||
GRID_H = 512
|
||||
OUTPUT_W = 4096
|
||||
OUTPUT_H = 2048
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# Color palette (Settled Reach visual grammar: muted, earthy, legible)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
PALETTE = {
|
||||
"ocean_deep": (18, 32, 58),
|
||||
"ocean_mid": (28, 52, 90),
|
||||
"ocean_shallow": (42, 80, 110),
|
||||
"coast": (80, 105, 75),
|
||||
"lowland": (95, 115, 65),
|
||||
"plains": (130, 145, 80),
|
||||
"grassland": (165, 155, 75), # temperate plains / savanna (amber tone)
|
||||
"hills": (120, 110, 80),
|
||||
"forest": (60, 90, 55),
|
||||
"highland": (110, 100, 90),
|
||||
"mountain": (140, 130, 120),
|
||||
"peak": (195, 190, 185),
|
||||
"snow": (230, 228, 225),
|
||||
# Annotation colors
|
||||
"river": (80, 140, 200),
|
||||
"road_major": (180, 155, 90),
|
||||
"road_minor": (160, 140, 85),
|
||||
"city_major": (220, 60, 50),
|
||||
"city_minor": (200, 110, 60),
|
||||
"city_label": (240, 235, 220),
|
||||
"freight_elev": (200, 180, 100), # freight elevator pads
|
||||
"grid_line": (255, 255, 255),
|
||||
"title_bg": (15, 18, 25),
|
||||
"title_text": (200, 208, 224), # insert chrome: #c8d0e0
|
||||
}
|
||||
|
||||
|
||||
def step(msg: str):
|
||||
print(f" [{time.strftime('%H:%M:%S')}] {msg}", flush=True)
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 1. Tectonic simulation
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
def run_tectonics(seed: int, fast: bool = False) -> np.ndarray:
|
||||
"""Run pyplatec tectonic simulation. Returns normalised float32 grid."""
|
||||
step("Running tectonic simulation (pyplatec)…")
|
||||
import platec
|
||||
|
||||
sim_steps = 50 if fast else 200
|
||||
|
||||
p = platec.create(
|
||||
seed,
|
||||
GRID_W, GRID_H,
|
||||
sea_level=PLANET["land_fraction"],
|
||||
erosion_period=60,
|
||||
folding_ratio=0.02,
|
||||
aggr_overlap_abs=1_000_000,
|
||||
aggr_overlap_rel=0.33,
|
||||
cycle_count=2,
|
||||
num_plates=PLANET["plate_count"],
|
||||
)
|
||||
|
||||
for _ in range(sim_steps):
|
||||
platec.step(p)
|
||||
|
||||
hmap_raw = platec.get_heightmap(p)
|
||||
platec.destroy(p)
|
||||
|
||||
arr = np.array(hmap_raw, dtype=np.float32).reshape(GRID_H, GRID_W)
|
||||
# Normalise to [0, 1]
|
||||
lo, hi = arr.min(), arr.max()
|
||||
arr = (arr - lo) / (hi - lo + 1e-9)
|
||||
step(f"Tectonic done. Elevation range: [{lo:.1f}, {hi:.1f}]")
|
||||
return arr
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 2. Hydraulic erosion (simplified — scipy gaussian smoothing on steep slopes)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
def erode(terrain: np.ndarray, passes: int = 3) -> np.ndarray:
|
||||
"""Simplified erosion: smooth with slope-weighted kernel."""
|
||||
step(f"Applying erosion ({passes} passes)…")
|
||||
from scipy.ndimage import gaussian_filter, uniform_filter
|
||||
|
||||
result = terrain.copy()
|
||||
for i in range(passes):
|
||||
# Identify steep slopes
|
||||
gy, gx = np.gradient(result)
|
||||
slope = np.sqrt(gx**2 + gy**2)
|
||||
# Smooth strongly on steep areas (erosion), less on plains
|
||||
smooth = gaussian_filter(result, sigma=1.5)
|
||||
weight = np.clip(slope * 8, 0, 1)
|
||||
result = result * (1 - weight * 0.4) + smooth * (weight * 0.4)
|
||||
return result
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 3. Terrain classification
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
SEA_LEVEL = None # set dynamically after tectonic simulation
|
||||
|
||||
def compute_sea_level(terrain: np.ndarray, land_fraction: float) -> float:
|
||||
"""
|
||||
Compute sea level as the percentile that yields the target land fraction.
|
||||
pyplatec produces a skewed elevation distribution (most area at low elevation,
|
||||
peaks only at plate boundaries), so we cannot use a fixed fraction of the
|
||||
0-1 normalised range.
|
||||
"""
|
||||
ocean_fraction = 1.0 - land_fraction
|
||||
sl = float(np.percentile(terrain, ocean_fraction * 100))
|
||||
step(f"Sea level computed: {sl:.4f} (target land={land_fraction*100:.0f}%, "
|
||||
f"actual≈{(terrain >= sl).sum() / terrain.size * 100:.1f}%)")
|
||||
return sl
|
||||
|
||||
|
||||
def classify(terrain: np.ndarray) -> np.ndarray:
|
||||
"""
|
||||
Returns integer class array relative to the dynamic sea level.
|
||||
Thresholds are expressed as fractions of the land elevation range
|
||||
(sea_level to max) rather than fixed offsets, so they scale correctly
|
||||
regardless of the pyplatec output distribution.
|
||||
|
||||
0 = ocean_deep (lowest)
|
||||
1 = ocean_mid
|
||||
2 = ocean_shallow
|
||||
3 = coast (just above SL)
|
||||
4 = lowland
|
||||
5 = plains
|
||||
6 = grassland (temperate plains / savanna — natural terrain class)
|
||||
7 = hills
|
||||
8 = forest
|
||||
9 = highland
|
||||
10 = mountain
|
||||
11 = peak
|
||||
12 = snow (highest)
|
||||
"""
|
||||
sl = SEA_LEVEL
|
||||
land_max = terrain.max()
|
||||
land_range = max(land_max - sl, 1e-6)
|
||||
|
||||
c = np.zeros_like(terrain, dtype=np.int8)
|
||||
# Ocean bands (below sea level)
|
||||
ocean_range = max(sl - terrain.min(), 1e-6)
|
||||
c[terrain >= terrain.min()] = 0 # ocean_deep (baseline)
|
||||
c[terrain >= sl - ocean_range * 0.5] = 1 # ocean_mid
|
||||
c[terrain >= sl - ocean_range * 0.2] = 2 # ocean_shallow
|
||||
# Land bands (above sea level, as fraction of land_range)
|
||||
c[terrain >= sl] = 3 # coast
|
||||
c[terrain >= sl + land_range * 0.05] = 4 # lowland
|
||||
c[terrain >= sl + land_range * 0.15] = 5 # plains
|
||||
c[terrain >= sl + land_range * 0.28] = 6 # grassland
|
||||
c[terrain >= sl + land_range * 0.42] = 7 # hills
|
||||
c[terrain >= sl + land_range * 0.53] = 8 # forest
|
||||
c[terrain >= sl + land_range * 0.63] = 9 # highland
|
||||
c[terrain >= sl + land_range * 0.74] = 10 # mountain
|
||||
c[terrain >= sl + land_range * 0.85] = 11 # peak
|
||||
c[terrain >= sl + land_range * 0.93] = 12 # snow
|
||||
return c
|
||||
|
||||
|
||||
CLASS_COLORS = [
|
||||
PALETTE["ocean_deep"],
|
||||
PALETTE["ocean_mid"],
|
||||
PALETTE["ocean_shallow"],
|
||||
PALETTE["coast"],
|
||||
PALETTE["lowland"],
|
||||
PALETTE["plains"],
|
||||
PALETTE["grassland"],
|
||||
PALETTE["hills"],
|
||||
PALETTE["forest"],
|
||||
PALETTE["highland"],
|
||||
PALETTE["mountain"],
|
||||
PALETTE["peak"],
|
||||
PALETTE["snow"],
|
||||
]
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 4. Hydrology — flow accumulation → river network
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
def compute_rivers(terrain: np.ndarray, threshold: int = 30) -> np.ndarray:
|
||||
"""
|
||||
Simple D8 flow accumulation. Returns boolean mask of river cells.
|
||||
Not physically accurate but produces plausible branching networks.
|
||||
"""
|
||||
step("Computing river network…")
|
||||
H, W = terrain.shape
|
||||
# D8 direction offsets
|
||||
dirs = [(-1,-1),(-1,0),(-1,1),(0,-1),(0,1),(1,-1),(1,0),(1,1)]
|
||||
|
||||
# For each land cell, find steepest descent
|
||||
flow_acc = np.zeros((H, W), dtype=np.int32)
|
||||
land = terrain >= SEA_LEVEL
|
||||
|
||||
# Simplified: accumulate flow by draining from high to low
|
||||
# Sort cells by elevation descending
|
||||
ys, xs = np.where(land)
|
||||
order = np.argsort(terrain[ys, xs])[::-1]
|
||||
ys_sorted = ys[order]
|
||||
xs_sorted = xs[order]
|
||||
|
||||
for y, x in zip(ys_sorted, xs_sorted):
|
||||
flow_acc[y, x] += 1
|
||||
# Find steepest downslope neighbour
|
||||
best_drop = 0
|
||||
best_ny, best_nx = -1, -1
|
||||
for dy, dx in dirs:
|
||||
ny, nx = y + dy, x + dx
|
||||
if 0 <= ny < H and 0 <= nx < W:
|
||||
drop = terrain[y, x] - terrain[ny, nx]
|
||||
if drop > best_drop:
|
||||
best_drop = drop
|
||||
best_ny, best_nx = ny, nx
|
||||
if best_ny >= 0:
|
||||
flow_acc[best_ny, best_nx] += flow_acc[y, x]
|
||||
|
||||
rivers = (flow_acc > threshold) & land
|
||||
step(f"River network: {rivers.sum()} cells above threshold {threshold}")
|
||||
return rivers
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 5. Settlement placement
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
KALLAST_CITIES = [
|
||||
# Name, (relative grid position), tier (1=capital, 2=regional, 3=node)
|
||||
# Placed on fertile plains near river confluences.
|
||||
# Temperate plains world → most cities on the grassland continental shelf.
|
||||
("Kallast Prime", (0.45, 0.48), 1), # capital, central continent
|
||||
("Ardenvall", (0.30, 0.40), 2), # western grain province
|
||||
("Thessmark", (0.60, 0.52), 2), # eastern province
|
||||
("Coldwater", (0.25, 0.62), 2), # southern coast, fishing + export
|
||||
("Brightfield", (0.50, 0.36), 2), # northern plains
|
||||
("Vorn's Crossing", (0.38, 0.55), 3), # river crossing, freight node
|
||||
("Saltmere", (0.68, 0.42), 3), # coast + processing node
|
||||
("Kaspel", (0.20, 0.50), 3), # western interior node
|
||||
("Drenmark", (0.72, 0.58), 3), # southeastern node
|
||||
("New Farrow", (0.55, 0.64), 3), # southern freight hub
|
||||
("Ossenfield", (0.42, 0.30), 3), # northern highland approach
|
||||
("Tyne Station", (0.33, 0.45), 3), # freight elevator ground station
|
||||
]
|
||||
|
||||
# Freight elevator locations (visible from orbit per wiki)
|
||||
FREIGHT_ELEVATORS = [
|
||||
("Kallast Anchor", (0.45, 0.46)),
|
||||
("Ardenvall Lift", (0.29, 0.38)),
|
||||
("Thessmark Riser", (0.61, 0.50)),
|
||||
]
|
||||
|
||||
|
||||
def place_settlements(terrain: np.ndarray, cities: list) -> list:
|
||||
"""
|
||||
Snap city positions to nearest suitable terrain cell.
|
||||
Suitable = plains or grassland class, preferably near river.
|
||||
Returns list of (name, grid_y, grid_x, tier) tuples.
|
||||
"""
|
||||
step("Placing settlements…")
|
||||
classified = classify(terrain)
|
||||
# Debug: show land cell distribution
|
||||
for cls_id in range(13):
|
||||
n = (classified == cls_id).sum()
|
||||
if n > 0:
|
||||
step(f" class {cls_id}: {n} cells")
|
||||
H, W = terrain.shape
|
||||
placed = []
|
||||
|
||||
for name, (rx, ry), tier in cities:
|
||||
cx = int(rx * W)
|
||||
cy = int(ry * H)
|
||||
# Search in expanding radius for valid terrain (up to 60 cells)
|
||||
best_y, best_x = cy, cx
|
||||
best_score = -1
|
||||
for radius in [20, 40, 60, 80]:
|
||||
for dy in range(-radius, radius + 1):
|
||||
for dx in range(-radius, radius + 1):
|
||||
ty, tx = cy + dy, cx + dx
|
||||
if 0 <= ty < H and 0 <= tx < W:
|
||||
c = classified[ty, tx]
|
||||
# Score: higher for plains/grain_belt, acceptable for coast/lowland
|
||||
score = 0
|
||||
if c in (5, 6): # plains/grassland (ideal settlement terrain)
|
||||
score = 20 - (abs(dy) + abs(dx)) * 0.2
|
||||
elif c == 4: # lowland
|
||||
score = 12 - (abs(dy) + abs(dx)) * 0.2
|
||||
elif c == 3: # coast (ports, export hubs)
|
||||
score = 8 - (abs(dy) + abs(dx)) * 0.2
|
||||
elif c == 7: # hills (defensible / highland cities)
|
||||
score = 5 - (abs(dy) + abs(dx)) * 0.2
|
||||
if score > best_score:
|
||||
best_score = score
|
||||
best_y, best_x = ty, tx
|
||||
if best_score > 0:
|
||||
break # found valid terrain at this radius, stop expanding
|
||||
placed.append((name, best_y, best_x, tier))
|
||||
step(f" {name} → ({best_x}, {best_y}) terrain={classified[best_y, best_x]}")
|
||||
|
||||
return placed
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 6. Road network (simple greedy connections)
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
def build_roads(settlements: list) -> list:
|
||||
"""
|
||||
Connect tier-1 and tier-2 cities with major roads.
|
||||
Connect tier-3 nodes to nearest tier-1 or tier-2.
|
||||
Returns list of (y1, x1, y2, x2, road_type) tuples.
|
||||
"""
|
||||
roads = []
|
||||
tier12 = [(n, y, x) for (n, y, x, t) in settlements if t <= 2]
|
||||
tier3 = [(n, y, x) for (n, y, x, t) in settlements if t == 3]
|
||||
|
||||
# Connect all tier-1/2 cities in order (simple chain + cross-links)
|
||||
for i in range(len(tier12) - 1):
|
||||
_, y1, x1 = tier12[i]
|
||||
_, y2, x2 = tier12[i + 1]
|
||||
roads.append((y1, x1, y2, x2, "major"))
|
||||
# Capital spurs to each tier-2
|
||||
cap = tier12[0]
|
||||
for city in tier12[1:]:
|
||||
roads.append((cap[1], cap[2], city[1], city[2], "major"))
|
||||
|
||||
# Tier-3 nodes to nearest tier-1/2
|
||||
for (n3, y3, x3) in tier3:
|
||||
best_d = 1e9
|
||||
best = tier12[0]
|
||||
for city in tier12:
|
||||
d = (city[1]-y3)**2 + (city[2]-x3)**2
|
||||
if d < best_d:
|
||||
best_d = d
|
||||
best = city
|
||||
roads.append((y3, x3, best[1], best[2], "minor"))
|
||||
|
||||
return roads
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# 7. Render
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
def render(
|
||||
terrain: np.ndarray,
|
||||
rivers: np.ndarray,
|
||||
output_path: str,
|
||||
):
|
||||
"""
|
||||
Renders a geographic heightmap: terrain colors, rivers, coastlines,
|
||||
biome zones, lat/lon grid, title panel.
|
||||
Human layer (settlements, roads, irrigation) is stored in the JSON sidecar only.
|
||||
|
||||
River rendering order matters: dilate at source resolution to preserve flow
|
||||
topology, then paint AFTER upscaling via NEAREST neighbor to avoid LANCZOS
|
||||
blurring the river network into invisibility.
|
||||
"""
|
||||
step("Rendering geographic heightmap…")
|
||||
from scipy.ndimage import binary_dilation
|
||||
from PIL import ImageFont
|
||||
H, W = terrain.shape
|
||||
classified = classify(terrain)
|
||||
|
||||
# UI scale relative to 1024×512 reference resolution
|
||||
UI_SCALE = OUTPUT_W / 1024
|
||||
|
||||
# Base terrain color layer
|
||||
rgb = np.zeros((H, W, 3), dtype=np.uint8)
|
||||
for cls_id, color in enumerate(CLASS_COLORS):
|
||||
mask = classified == cls_id
|
||||
rgb[mask] = color
|
||||
|
||||
# Slight elevation shading on land (ambient occlusion approximation)
|
||||
land_mask = terrain >= SEA_LEVEL
|
||||
elev_norm = np.clip((terrain - SEA_LEVEL) / (1.0 - SEA_LEVEL + 1e-9), 0, 1)
|
||||
shade = (0.85 + 0.15 * elev_norm)[..., np.newaxis]
|
||||
rgb = np.where(land_mask[..., np.newaxis], (rgb * shade).astype(np.uint8), rgb)
|
||||
|
||||
# Dilate river mask at source resolution (preserves branching topology)
|
||||
rivers_drawn = binary_dilation(rivers, iterations=2)
|
||||
step(f"River cells after dilation: {rivers_drawn.sum()}")
|
||||
|
||||
# Upscale terrain with LANCZOS (smooth gradients) — WITHOUT rivers painted in yet
|
||||
img = Image.fromarray(rgb).resize((OUTPUT_W, OUTPUT_H), Image.LANCZOS)
|
||||
|
||||
# Paint rivers AFTER upscale using NEAREST neighbor — no blur, sharp edges
|
||||
rivers_up = Image.fromarray((rivers_drawn.astype(np.uint8) * 255)).resize(
|
||||
(OUTPUT_W, OUTPUT_H), Image.NEAREST
|
||||
)
|
||||
img_arr = np.array(img)
|
||||
img_arr[np.array(rivers_up) > 0] = PALETTE["river"]
|
||||
img = Image.fromarray(img_arr)
|
||||
draw = ImageDraw.Draw(img)
|
||||
|
||||
# Lat/lon grid lines (every 30°)
|
||||
grid_w = max(1, int(UI_SCALE))
|
||||
for lat_pct in [1/6, 2/6, 3/6, 4/6, 5/6]:
|
||||
y = int(lat_pct * OUTPUT_H)
|
||||
draw.line([(0, y), (OUTPUT_W, y)], fill=(80, 90, 100), width=grid_w)
|
||||
for lon_pct in [1/6, 2/6, 3/6, 4/6, 5/6]:
|
||||
x = int(lon_pct * OUTPUT_W)
|
||||
draw.line([(x, 0), (x, OUTPUT_H)], fill=(80, 90, 100), width=grid_w)
|
||||
|
||||
# Fonts — load_default(size=N) requires Pillow 10+
|
||||
try:
|
||||
font_title = ImageFont.load_default(size=int(14 * UI_SCALE))
|
||||
font_sub = ImageFont.load_default(size=int(12 * UI_SCALE))
|
||||
font_small = ImageFont.load_default(size=int(11 * UI_SCALE))
|
||||
except TypeError:
|
||||
font_title = font_sub = font_small = ImageFont.load_default()
|
||||
|
||||
# Title / metadata panel (insert chrome aesthetic)
|
||||
panel_h = int(56 * UI_SCALE)
|
||||
panel = Image.new('RGBA', (OUTPUT_W, panel_h), (15, 18, 25, 200))
|
||||
img = img.convert('RGBA')
|
||||
img.paste(panel, (0, 0), panel)
|
||||
img = img.convert('RGB')
|
||||
draw = ImageDraw.Draw(img)
|
||||
|
||||
px = int(12 * UI_SCALE)
|
||||
py = int(8 * UI_SCALE)
|
||||
lh = int(18 * UI_SCALE)
|
||||
draw.text((px, py), f"KALLAST · GJ 144d · Ran System", fill=PALETTE["title_text"], font=font_title)
|
||||
draw.text((px, py + lh), f"temperate / ocean / breathable / 0.95g / {PLANET['population']//1_000_000_000:.1f}B pop / Wave {PLANET['settlement_wave']} / {PLANET['settlement_age_years']}y settled", fill=(130, 140, 160), font=font_sub)
|
||||
draw.text((px, py + lh*2), "HEIGHTMAP SPIKE v0.1 — Settled Reach Phase 1", fill=(80, 90, 110), font=font_small)
|
||||
|
||||
# Legend (bottom strip) — natural geographic features only
|
||||
sw = int(16 * UI_SCALE)
|
||||
legend_y = OUTPUT_H - int(40 * UI_SCALE)
|
||||
legend_items = [
|
||||
("ocean", PALETTE["ocean_deep"]),
|
||||
("coast", PALETTE["coast"]),
|
||||
("plains", PALETTE["plains"]),
|
||||
("grassland", PALETTE["grassland"]),
|
||||
("mountain", PALETTE["mountain"]),
|
||||
("river", PALETTE["river"]),
|
||||
]
|
||||
lx = px
|
||||
for label, color in legend_items:
|
||||
draw.rectangle([(lx, legend_y + int(4*UI_SCALE)), (lx+sw, legend_y + sw + int(4*UI_SCALE))], fill=color)
|
||||
draw.text((lx + sw + int(4*UI_SCALE), legend_y + int(3*UI_SCALE)), label, fill=(180, 185, 200), font=font_small)
|
||||
lx += int(110 * UI_SCALE)
|
||||
|
||||
img.save(output_path, format="PNG", optimize=False)
|
||||
step(f"Saved: {output_path}")
|
||||
|
||||
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
# Main
|
||||
# ─────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description="Generate Kallast heightmap spike")
|
||||
parser.add_argument("--output", default="spikes/heightmap-pipeline/kallast_heightmap.png")
|
||||
parser.add_argument("--terrain-out", default="spikes/heightmap-pipeline/kallast_terrain.npy")
|
||||
parser.add_argument("--seed", type=int, default=144042) # GJ144d seed
|
||||
parser.add_argument("--fast", action="store_true", help="Fewer tectonic steps (quicker, less detail)")
|
||||
args = parser.parse_args()
|
||||
|
||||
print(f"\nKallast Heightmap Spike")
|
||||
print(f" Planet: {PLANET['name']} ({PLANET['body_id']})")
|
||||
print(f" Grid: {GRID_W}×{GRID_H}")
|
||||
print(f" Seed: {args.seed}")
|
||||
print(f" Mode: {'fast' if args.fast else 'standard'}\n")
|
||||
|
||||
t0 = time.time()
|
||||
|
||||
terrain = run_tectonics(args.seed, fast=args.fast)
|
||||
terrain = erode(terrain, passes=4)
|
||||
|
||||
# Set dynamic sea level based on target land coverage
|
||||
global SEA_LEVEL
|
||||
SEA_LEVEL = compute_sea_level(terrain, PLANET["land_fraction"])
|
||||
|
||||
rivers = compute_rivers(terrain, threshold=60) # calibrated for 1024×512 grid; flat world needs lower relative threshold
|
||||
|
||||
settlements = place_settlements(terrain, KALLAST_CITIES)
|
||||
|
||||
render(terrain, rivers, args.output)
|
||||
|
||||
np.save(args.terrain_out, terrain)
|
||||
step(f"Terrain grid saved: {args.terrain_out}")
|
||||
|
||||
# Write settlements JSON
|
||||
sj_path = args.output.replace(".png", "_settlements.json")
|
||||
with open(sj_path, "w") as f:
|
||||
json.dump([
|
||||
{"name": n, "grid_y": int(gy), "grid_x": int(gx), "tier": t}
|
||||
for (n, gy, gx, t) in settlements
|
||||
], f, indent=2)
|
||||
step(f"Settlement data saved: {sj_path}")
|
||||
|
||||
elapsed = time.time() - t0
|
||||
print(f"\nDone in {elapsed:.1f}s")
|
||||
print(f"Output: {args.output}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 2.7 MiB |
@@ -0,0 +1,74 @@
|
||||
[
|
||||
{
|
||||
"name": "Kallast Prime",
|
||||
"grid_y": 297,
|
||||
"grid_x": 460,
|
||||
"tier": 1
|
||||
},
|
||||
{
|
||||
"name": "Ardenvall",
|
||||
"grid_y": 182,
|
||||
"grid_x": 246,
|
||||
"tier": 2
|
||||
},
|
||||
{
|
||||
"name": "Thessmark",
|
||||
"grid_y": 266,
|
||||
"grid_x": 613,
|
||||
"tier": 2
|
||||
},
|
||||
{
|
||||
"name": "Coldwater",
|
||||
"grid_y": 316,
|
||||
"grid_x": 272,
|
||||
"tier": 2
|
||||
},
|
||||
{
|
||||
"name": "Brightfield",
|
||||
"grid_y": 172,
|
||||
"grid_x": 512,
|
||||
"tier": 2
|
||||
},
|
||||
{
|
||||
"name": "Vorn's Crossing",
|
||||
"grid_y": 293,
|
||||
"grid_x": 399,
|
||||
"tier": 3
|
||||
},
|
||||
{
|
||||
"name": "Saltmere",
|
||||
"grid_y": 195,
|
||||
"grid_x": 707,
|
||||
"tier": 3
|
||||
},
|
||||
{
|
||||
"name": "Kaspel",
|
||||
"grid_y": 214,
|
||||
"grid_x": 214,
|
||||
"tier": 3
|
||||
},
|
||||
{
|
||||
"name": "Drenmark",
|
||||
"grid_y": 296,
|
||||
"grid_x": 737,
|
||||
"tier": 3
|
||||
},
|
||||
{
|
||||
"name": "New Farrow",
|
||||
"grid_y": 327,
|
||||
"grid_x": 563,
|
||||
"tier": 3
|
||||
},
|
||||
{
|
||||
"name": "Ossenfield",
|
||||
"grid_y": 155,
|
||||
"grid_x": 433,
|
||||
"tier": 3
|
||||
},
|
||||
{
|
||||
"name": "Tyne Station",
|
||||
"grid_y": 300,
|
||||
"grid_x": 322,
|
||||
"tier": 3
|
||||
}
|
||||
]
|
||||
Binary file not shown.
Reference in New Issue
Block a user