Added: Initial world generation tool
This commit is contained in:
Rainer Leit
@@ -0,0 +1,617 @@
|
||||
// Command terrain generates L_World's heightmap. See Docs/Terrain.md.
|
||||
//
|
||||
// terrain generate the manifest as it stands
|
||||
// terrain generate --seed 12 another continent
|
||||
// terrain generate --stage fluvial --size 1024 one pass at a small size, the iteration loop
|
||||
//
|
||||
// The flags are deliberately the ones Scripts/Authoring/generate_heightmap.py had, so the two documented
|
||||
// commands in RawContent/World/README.md and everybody's muscle memory survive the port.
|
||||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"flag"
|
||||
"fmt"
|
||||
"image/png"
|
||||
"math"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"time"
|
||||
|
||||
"salty/terrain/internal/coast"
|
||||
"salty/terrain/internal/field"
|
||||
"salty/terrain/internal/fluvial"
|
||||
"salty/terrain/internal/manifest"
|
||||
"salty/terrain/internal/stats"
|
||||
"salty/terrain/internal/thermal"
|
||||
"salty/terrain/internal/uplift"
|
||||
)
|
||||
|
||||
func main() {
|
||||
if len(os.Args) < 2 {
|
||||
usage()
|
||||
os.Exit(2)
|
||||
}
|
||||
switch os.Args[1] {
|
||||
case "generate":
|
||||
if err := generate(os.Args[2:]); err != nil {
|
||||
fmt.Fprintln(os.Stderr, "terrain:", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
case "-h", "--help", "help":
|
||||
usage()
|
||||
default:
|
||||
fmt.Fprintf(os.Stderr, "terrain: unknown command %q\n", os.Args[1])
|
||||
usage()
|
||||
os.Exit(2)
|
||||
}
|
||||
}
|
||||
|
||||
func usage() {
|
||||
fmt.Fprint(os.Stderr, `terrain - the world's heightmap generator (Docs/Terrain.md)
|
||||
|
||||
terrain generate [flags]
|
||||
|
||||
--manifest PATH default RawContent/World/World.json, found by walking up from the working directory
|
||||
--seed N override the noise seed for this run
|
||||
--size N run the geology grid at N instead of the manifest's, for iterating
|
||||
--stage NAME stop after a stage: uplift, fluvial (default: the last one built)
|
||||
--steps N override the fluvial step count
|
||||
--out DIR where the PNGs go (default: beside the manifest, or Preview/ for a --size run)
|
||||
--quiet only the summary
|
||||
--no-coast skip the coastal pass: a flat sea floor and an unworked shoreline
|
||||
`)
|
||||
}
|
||||
|
||||
func generate(args []string) error {
|
||||
fs := flag.NewFlagSet("generate", flag.ExitOnError)
|
||||
manifestPath := fs.String("manifest", "", "path to World.json")
|
||||
seed := fs.Int64("seed", -1, "override the noise seed")
|
||||
size := fs.Int("size", 0, "run the geology grid at this size instead of the manifest's")
|
||||
stage := fs.String("stage", "fluvial", "stop after this stage: uplift, fluvial")
|
||||
steps := fs.Int("steps", 0, "override the fluvial step count")
|
||||
out := fs.String("out", "", "output directory")
|
||||
quiet := fs.Bool("quiet", false, "only print the summary")
|
||||
fillEvery := fs.Int("fill-every", 0, "override the priority-flood interval")
|
||||
channelKm2 := fs.Float64("channel-km2", 1.0, "drainage area that counts as a channel, km2")
|
||||
criticalM2 := fs.Float64("critical-m2", 0, "override where channels begin, m2")
|
||||
diffusion := fs.Float64("diffusion", 0, "override hillslope diffusivity, m2/yr")
|
||||
talusDeg := fs.Float64("talus", 0, "override the angle of repose, degrees")
|
||||
thermalEvery := fs.Int("thermal-every", 0, "override the landslide interval, steps")
|
||||
thermalPasses := fs.Int("thermal-passes", 0, "override landslide passes per application")
|
||||
convergent := fs.Float64("convergent", 0, "override the convergent uplift rate, mm/yr")
|
||||
intraplate := fs.Float64("intraplate", 0, "override the intraplate sag rate, mm/yr")
|
||||
intraSwell := fs.Float64("intraplate-swell", 0, "override the intraplate swell rate, mm/yr")
|
||||
lithTypes := fs.Int("lithology-types", -1, "override the rock type count; 1 disables lithology")
|
||||
faultScale := fs.Float64("fault-scale", -1, "scale the fault counts; 0 disables faults")
|
||||
kOverride := fs.Float64("k", 0, "override the stream-power erodibility K")
|
||||
cropX := fs.Float64("crop-x", 0.20, "detail crop, left edge in map coordinates")
|
||||
cropY := fs.Float64("crop-y", 0.62, "detail crop, top edge in map coordinates")
|
||||
cropSize := fs.Float64("crop-size", 0.22, "detail crop, side length in map coordinates")
|
||||
reliefWindowM := fs.Float64("relief-window", 500, "window the per-bucket local relief is measured over, m")
|
||||
criticalSlope := fs.Float64("critical-slope", -1, "override Sc in the nonlinear hillslope law, degrees; 0 reverts to linear diffusion and the in-loop clamp")
|
||||
slopeCap := fs.Float64("slope-cap", 0, "override where the nonlinear flux stops stiffening, as a fraction of Sc")
|
||||
hillslopeSub := fs.Int("hillslope-substeps", 0, "override the nonlinear hillslope sub-step budget")
|
||||
mapSize := fs.Int("map-size", 1400, "side, in pixels, of the false-colour data maps")
|
||||
outlineOctaves := fs.Int("outline-octaves", 0, "override how much detail the coastline outline has")
|
||||
outlineGain := fs.Float64("outline-gain", 0, "override the coastline outline's octave gain: how crenellated it is")
|
||||
noCoast := fs.Bool("no-coast", false, "skip the coastal pass: a flat sea floor and an unworked shoreline")
|
||||
surfReach := fs.Float64("surf-reach", 0, "override how far inland the surf planes on open coast, m")
|
||||
cutFraction := fs.Float64("cut-fraction", 0, "override how completely the surf planes the shore platform, 0..1")
|
||||
shelfKm := fs.Float64("shelf-km", 0, "override the widest continental shelf, km")
|
||||
driftM := fs.Float64("drift", 0, "override how far sediment is carried along the shore, m")
|
||||
riverSediment := fs.Float64("river-sediment", -1, "override the river load per km2 of catchment, m3; 0 disables deltas")
|
||||
if err := fs.Parse(args); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
path, err := findManifest(*manifestPath)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
m, err := manifest.Load(path)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if *seed >= 0 {
|
||||
m.Source.Seed = *seed
|
||||
}
|
||||
if *steps > 0 {
|
||||
m.Pipeline.Fluvial.Steps = *steps
|
||||
}
|
||||
if *fillEvery > 0 {
|
||||
m.Pipeline.Fluvial.FillEvery = *fillEvery
|
||||
}
|
||||
if *criticalM2 > 0 {
|
||||
m.Pipeline.Fluvial.CriticalAreaM2 = *criticalM2
|
||||
}
|
||||
if *diffusion > 0 {
|
||||
m.Pipeline.Fluvial.DiffusionM2Yr = *diffusion
|
||||
}
|
||||
if *talusDeg > 0 {
|
||||
m.Pipeline.Thermal.TalusDeg = *talusDeg
|
||||
}
|
||||
if *thermalEvery > 0 {
|
||||
m.Pipeline.Thermal.Every = *thermalEvery
|
||||
}
|
||||
if *thermalPasses > 0 {
|
||||
m.Pipeline.Thermal.CoarsePasses = *thermalPasses
|
||||
}
|
||||
if *convergent > 0 {
|
||||
m.Pipeline.Plates.ConvergentMmYr[1] = *convergent
|
||||
}
|
||||
if *intraplate > 0 {
|
||||
m.Pipeline.Plates.IntraplateMmYr = *intraplate
|
||||
}
|
||||
if *intraSwell > 0 {
|
||||
m.Pipeline.Plates.IntraplateSwellMmYr = *intraSwell
|
||||
}
|
||||
if *criticalSlope >= 0 {
|
||||
m.Pipeline.Fluvial.CriticalSlopeDeg = *criticalSlope
|
||||
}
|
||||
if *slopeCap > 0 {
|
||||
m.Pipeline.Fluvial.SlopeCap = *slopeCap
|
||||
}
|
||||
if *hillslopeSub > 0 {
|
||||
m.Pipeline.Fluvial.MaxHillslopeSub = *hillslopeSub
|
||||
}
|
||||
if *kOverride > 0 {
|
||||
m.Pipeline.Fluvial.K = *kOverride
|
||||
}
|
||||
if *lithTypes >= 1 {
|
||||
m.Pipeline.Lithology.Types = *lithTypes
|
||||
}
|
||||
if *faultScale >= 0 {
|
||||
m.Pipeline.Faults.Major[0] *= *faultScale
|
||||
m.Pipeline.Faults.Major[1] *= *faultScale
|
||||
m.Pipeline.Faults.Minor[0] *= *faultScale
|
||||
m.Pipeline.Faults.Minor[1] *= *faultScale
|
||||
}
|
||||
if *outlineOctaves > 0 {
|
||||
m.Pipeline.Continent.OutlineOctaves = *outlineOctaves
|
||||
}
|
||||
if *outlineGain > 0 {
|
||||
m.Pipeline.Continent.OutlineGain = *outlineGain
|
||||
}
|
||||
if *noCoast {
|
||||
m.Pipeline.Coast.Enabled = false
|
||||
}
|
||||
if *surfReach > 0 {
|
||||
m.Pipeline.Coast.SurfReachM = *surfReach
|
||||
}
|
||||
if *cutFraction > 0 {
|
||||
m.Pipeline.Coast.CutFraction = *cutFraction
|
||||
}
|
||||
if *shelfKm > 0 {
|
||||
m.Pipeline.Coast.ShelfKm[1] = *shelfKm
|
||||
}
|
||||
if *driftM > 0 {
|
||||
m.Pipeline.Coast.DriftM = *driftM
|
||||
}
|
||||
if *riverSediment >= 0 {
|
||||
m.Pipeline.Coast.RiverM3PerKm2 = *riverSediment
|
||||
}
|
||||
if m.Erosion != nil {
|
||||
fmt.Println("note: this manifest still has an 'erosion' block; D-47 replaced it with 'pipeline' and it is ignored")
|
||||
}
|
||||
|
||||
geoSize := m.GeologySize()
|
||||
geoCell := m.GeologyCellM()
|
||||
preview := *size > 0
|
||||
if preview {
|
||||
// A --size run keeps the manifest's physical extent and just samples it more coarsely, so the
|
||||
// metres, the uplift rates and the stream-power constants all still mean what they mean.
|
||||
geoSize = *size
|
||||
geoCell = m.SideM() / float64(*size-1)
|
||||
}
|
||||
|
||||
outDir := *out
|
||||
if outDir == "" {
|
||||
if preview {
|
||||
outDir = filepath.Join(manifest.ProjectRoot(path), "RawContent", "World", "Preview")
|
||||
} else {
|
||||
outDir = filepath.Join(filepath.Dir(path), "Heightmaps")
|
||||
}
|
||||
}
|
||||
|
||||
log := func(format string, a ...any) {
|
||||
if !*quiet {
|
||||
fmt.Printf(format+"\n", a...)
|
||||
}
|
||||
}
|
||||
log("%s", m.Describe())
|
||||
log("geology grid %d at %.2f m a cell, %d cores, GOMAXPROCS %d", geoSize, geoCell, runtime.NumCPU(), runtime.GOMAXPROCS(0))
|
||||
if preview {
|
||||
log("preview run: the geology grid only, written to %s", outDir)
|
||||
}
|
||||
|
||||
started := time.Now()
|
||||
up := uplift.Build(geoSize, geoCell, m)
|
||||
rateLo, rateHi := up.Rate.MinMax()
|
||||
hLo, hHi := up.Height.MinMax()
|
||||
landFrac := fractionTrue(invert(up.Base))
|
||||
kLo, kHi := float32(1), float32(1)
|
||||
if up.K != nil {
|
||||
kLo, kHi = up.K.MinMax()
|
||||
}
|
||||
log("uplift %.3f..%.3f mm/yr, K x%.2f..%.2f, %d faults, initial relief %.0f..%.0f m, %.0f%% land [%s]",
|
||||
float64(rateLo)*1000, float64(rateHi)*1000, kLo, kHi, len(up.Faults), hLo, hHi, landFrac*100, since(started))
|
||||
|
||||
h := up.Height.Clone()
|
||||
var grid *fluvial.Grid
|
||||
var kField []float32
|
||||
if up.K != nil {
|
||||
kField = up.K.Data
|
||||
}
|
||||
|
||||
if *stage != "uplift" {
|
||||
p := fluvial.Params{
|
||||
K: m.Pipeline.Fluvial.K, M: m.Pipeline.Fluvial.M, N: m.Pipeline.Fluvial.N,
|
||||
DtYr: m.Pipeline.Fluvial.DtYr, Steps: m.Pipeline.Fluvial.Steps,
|
||||
Diffusion: m.Pipeline.Fluvial.DiffusionM2Yr, FillEvery: m.Pipeline.Fluvial.FillEvery,
|
||||
TalusSlope: thermal.TalusFromDegrees(m.Pipeline.Thermal.TalusDeg),
|
||||
ThermalEvery: m.Pipeline.Thermal.Every,
|
||||
ThermalPasses: m.Pipeline.Thermal.CoarsePasses,
|
||||
CriticalAreaM2: m.Pipeline.Fluvial.CriticalAreaM2,
|
||||
ChannelTaper: m.Pipeline.Fluvial.ChannelTaper,
|
||||
CriticalSlope: thermal.TalusFromDegrees(m.Pipeline.Fluvial.CriticalSlopeDeg),
|
||||
SlopeCap: m.Pipeline.Fluvial.SlopeCap,
|
||||
MaxHillslopeSub: m.Pipeline.Fluvial.MaxHillslopeSub,
|
||||
}
|
||||
hillslope := fmt.Sprintf("linear D %.3f m2/yr, repose clamp every %d steps", p.Diffusion, m.Pipeline.Thermal.Every)
|
||||
if p.CriticalSlope > 0 {
|
||||
hillslope = fmt.Sprintf("nonlinear D %.3f m2/yr, Sc %.0f deg, cap %.2f, up to %d sub-steps",
|
||||
p.Diffusion, m.Pipeline.Fluvial.CriticalSlopeDeg, p.SlopeCap, p.MaxHillslopeSub)
|
||||
}
|
||||
log("fluvial %d steps of %.0f yr (%.1f Myr), K %.1e, m %.2f, n %.2f, fill every %d",
|
||||
p.Steps, p.DtYr, float64(p.Steps)*p.DtYr/1e6, p.K, p.M, p.N, p.FillEvery)
|
||||
log("hillslope: %s", hillslope)
|
||||
grid = fluvial.NewGrid(geoSize, geoSize, geoCell, up.Base)
|
||||
grid.SetSeed(m.Source.Seed) // the flat-routing jitter; see internal/fluvial/jitter.go
|
||||
// Size the flood's bucket queue to the elevation the run can actually reach: the manifest's range,
|
||||
// with headroom for uplift that outruns erosion before the warning catches it.
|
||||
grid.SetElevationRange(m.ElevationM.Min-200, m.ElevationM.Max+500)
|
||||
solveStart := time.Now()
|
||||
grid.Run(h.Data, up.Rate.Data, kField, p, func(step, total int, pct float64) {
|
||||
if step == 0 {
|
||||
return
|
||||
}
|
||||
lo, hi := h.MinMax()
|
||||
elapsed := time.Since(solveStart)
|
||||
eta := time.Duration(float64(elapsed) / (pct / 100) * (1 - pct/100))
|
||||
log(" %3.0f%% step %d/%d height %.0f..%.0f m eta %s", pct, step, total, lo, hi, eta.Round(time.Second))
|
||||
})
|
||||
log("fluvial done [%s]", since(solveStart))
|
||||
}
|
||||
|
||||
// The coast, last, on the terrain the solve produced: the sea floor, the surf and the sediment it moves.
|
||||
// It owns the sea floor outright — the ocean cells were held at sea level for the whole solve so that
|
||||
// rivers cut down to sea level and no further, and this is where they stop being held.
|
||||
coastStart := time.Now()
|
||||
var flow []float32
|
||||
if grid != nil {
|
||||
flow = grid.Area
|
||||
}
|
||||
cs := coast.Build(coast.Input{
|
||||
Height: h, Sea: up.Base, SeaLevelM: m.SeaLevelM,
|
||||
BreakM: -m.Pipeline.Continent.SeaFloorM.Hi(), AbyssM: -m.Pipeline.Continent.SeaFloorM.Lo(),
|
||||
Flow: flow, Seed: m.Source.Seed, Cfg: m.Pipeline.Coast,
|
||||
})
|
||||
if m.Pipeline.Coast.Enabled {
|
||||
log("coast: shelf %.1f..%.1f km, surf reach %.0f m, drift %.0f m, %d fetch rays to %.0f m [%s]",
|
||||
m.Pipeline.Coast.ShelfKm.Lo(), m.Pipeline.Coast.ShelfKm.Hi(), m.Pipeline.Coast.SurfReachM,
|
||||
m.Pipeline.Coast.DriftM, m.Pipeline.Coast.FetchDirections, m.Pipeline.Coast.FetchRangeM,
|
||||
since(coastStart))
|
||||
}
|
||||
|
||||
// Everything downstream asks about the terrain rather than about the mask that seeded it: a beach the
|
||||
// coastal pass built is land and a headland it planed under the waterline is not, so the mask that the
|
||||
// statistics, the preview and the data maps use is the one the coast pass finished with.
|
||||
sea := cs.Sea
|
||||
land := invert(sea)
|
||||
landFrac = fractionTrue(land)
|
||||
hLo, hHi = h.MinMax()
|
||||
landLo, landHi := minMaxWhere(h.Data, land)
|
||||
rep := stats.Report{
|
||||
LandFraction: landFrac,
|
||||
ClipFraction: m.ClipFraction(h.Data),
|
||||
MinM: float64(hLo), MaxM: float64(hHi), ReliefM: float64(hHi - hLo),
|
||||
LandMinM: landLo, LandMaxM: landHi, LandReliefM: landHi - landLo,
|
||||
Slopes: stats.ComputeSlopes(h, land),
|
||||
Hypsometry: stats.ComputeHypsometry(h, land),
|
||||
Buckets: stats.UpliftBuckets(h, up.Rate.Data, land, m.Pipeline.Thermal.TalusDeg, *reliefWindowM),
|
||||
}
|
||||
if grid != nil {
|
||||
threshold := *channelKm2 * 1e6 // the incoming spec's channel definition is 1 km²
|
||||
stats.SetExpected(m.Pipeline.Fluvial.M, m.Pipeline.Fluvial.N)
|
||||
rep.SlopeArea = stats.ComputeSlopeArea(h, grid.Area, grid.Receiver, grid.Length, land,
|
||||
up.Rate.Data, kField, m.Pipeline.Fluvial.K, m.Pipeline.Fluvial.N, threshold)
|
||||
rep.DrainageDensity = stats.DrainageDensity(grid.Area, land, geoCell, threshold)
|
||||
}
|
||||
fmt.Println(rep.Summary())
|
||||
if m.Pipeline.Coast.Enabled {
|
||||
fmt.Println()
|
||||
fmt.Println(cs.Stats.Summary())
|
||||
}
|
||||
if rep.ClipFraction > 0.001 {
|
||||
fmt.Printf("\nWARNING: %.2f%% of the map is outside elevation_m %g..%g. U/K is the relief knob and the\n"+
|
||||
" ceiling is a hard clip in the 16-bit encoding, so this is a failed run, not a rounded one.\n",
|
||||
rep.ClipFraction*100, m.ElevationM.Min, m.ElevationM.Max)
|
||||
}
|
||||
|
||||
if err := os.MkdirAll(outDir, 0o755); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := field.WriteThumbnail(filepath.Join(outDir, "thumb.png"), h, 512); err != nil {
|
||||
return err
|
||||
}
|
||||
// The one that is actually worth looking at: hypsometric tint, hillshade and the drainage network.
|
||||
pv := field.PreviewOptions{Sea: sea, SeaLevelM: m.SeaLevelM, RiverKm2: 0.5, Size: 1600}
|
||||
if grid != nil {
|
||||
flow := field.New(h.W, h.H, h.CellM)
|
||||
copy(flow.Data, grid.Area)
|
||||
pv.Flow = flow
|
||||
}
|
||||
if err := field.WritePreview(filepath.Join(outDir, "preview.png"), h, pv); err != nil {
|
||||
return err
|
||||
}
|
||||
// A detail crop as well, always. The whole continent at 1500 px cannot show whether the lowlands read as
|
||||
// hill country or as small mountains, and that distinction is the current question.
|
||||
detail := pv
|
||||
detail.Crop = [4]float64{*cropX, *cropY, *cropX + *cropSize, *cropY + *cropSize}
|
||||
detail.Size = 1400
|
||||
detail.RiverKm2 = 0.15
|
||||
detail.Exaggeration = 2.0
|
||||
if err := field.WritePreview(filepath.Join(outDir, "preview_detail.png"), h, detail); err != nil {
|
||||
return err
|
||||
}
|
||||
// The geology-grid height, so a preview run has something to look at. The full-resolution height belongs
|
||||
// to the detail passes, which are not built yet (build-order steps 5 to 8).
|
||||
if err := field.WriteGray16(filepath.Join(outDir, "geology_height.png"), h.W, h.H, m.Encode(h.Data), png.DefaultCompression); err != nil {
|
||||
return err
|
||||
}
|
||||
if grid != nil {
|
||||
flow := field.New(h.W, h.H, h.CellM)
|
||||
copy(flow.Data, grid.Area)
|
||||
unit := flow.ToUnit(99.5, true)
|
||||
if err := field.WriteGray8(filepath.Join(outDir, "geology_flow.png"), unit.W, unit.H, toBytes(unit.Data), png.BestSpeed); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
// The false-colour maps: the inputs the run worked from and the structure it produced, beside the result.
|
||||
// preview.png says whether the landscape looks right; these say why it looks the way it does, and when it
|
||||
// does not they are where the answer is. See internal/field/datamap.go.
|
||||
if err := writeDataMaps(outDir, h, up, cs, grid, *mapSize); err != nil {
|
||||
return err
|
||||
}
|
||||
meta := map[string]any{
|
||||
"seed": m.Source.Seed,
|
||||
"generated_at": time.Now().UTC().Format(time.RFC3339),
|
||||
"geology_size": geoSize,
|
||||
"geology_cell_m": geoCell,
|
||||
"preview": preview,
|
||||
"manifest": m,
|
||||
"stats": rep,
|
||||
"coast": cs.Stats,
|
||||
"elapsed_s": time.Since(started).Seconds(),
|
||||
}
|
||||
blob, err := json.MarshalIndent(meta, "", " ")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(outDir, "meta.json"), blob, 0o644); err != nil {
|
||||
return err
|
||||
}
|
||||
log("\nwritten to %s in %s", outDir, since(started))
|
||||
return nil
|
||||
}
|
||||
|
||||
func toBytes(v []float32) []uint8 {
|
||||
out := make([]uint8, len(v))
|
||||
for i, x := range v {
|
||||
if x < 0 {
|
||||
x = 0
|
||||
} else if x > 1 {
|
||||
x = 1
|
||||
}
|
||||
out[i] = uint8(x*255 + 0.5)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func invert(b []bool) []bool {
|
||||
out := make([]bool, len(b))
|
||||
for i, v := range b {
|
||||
out[i] = !v
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func minMaxWhere(v []float32, mask []bool) (float64, float64) {
|
||||
lo, hi := math.Inf(1), math.Inf(-1)
|
||||
for i, x := range v {
|
||||
if !mask[i] {
|
||||
continue
|
||||
}
|
||||
f := float64(x)
|
||||
if f < lo {
|
||||
lo = f
|
||||
}
|
||||
if f > hi {
|
||||
hi = f
|
||||
}
|
||||
}
|
||||
if math.IsInf(lo, 1) {
|
||||
return 0, 0
|
||||
}
|
||||
return lo, hi
|
||||
}
|
||||
|
||||
func fractionTrue(b []bool) float64 {
|
||||
if len(b) == 0 {
|
||||
return 0
|
||||
}
|
||||
n := 0
|
||||
for _, v := range b {
|
||||
if v {
|
||||
n++
|
||||
}
|
||||
}
|
||||
return float64(n) / float64(len(b))
|
||||
}
|
||||
|
||||
func since(t time.Time) string { return time.Since(t).Round(time.Millisecond).String() }
|
||||
|
||||
// findManifest walks up from the working directory, so the command works from anywhere in the repository
|
||||
// rather than only from the root.
|
||||
func findManifest(explicit string) (string, error) {
|
||||
if explicit != "" {
|
||||
return explicit, nil
|
||||
}
|
||||
dir, err := os.Getwd()
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
for i := 0; i < 8; i++ {
|
||||
candidate := filepath.Join(dir, "RawContent", "World", "World.json")
|
||||
if _, err := os.Stat(candidate); err == nil {
|
||||
return candidate, nil
|
||||
}
|
||||
parent := filepath.Dir(dir)
|
||||
if parent == dir {
|
||||
break
|
||||
}
|
||||
dir = parent
|
||||
}
|
||||
return "", fmt.Errorf("no RawContent/World/World.json above %q; pass --manifest", mustWd())
|
||||
}
|
||||
|
||||
func mustWd() string {
|
||||
d, _ := os.Getwd()
|
||||
return d
|
||||
}
|
||||
|
||||
// writeDataMaps renders the run's inputs and structure as false-colour PNGs beside the result.
|
||||
//
|
||||
// Which maps, and why each one earns its place:
|
||||
//
|
||||
// - map_uplift: rock uplift in mm/yr, the field everything else is a consequence of. Steady-state slope is
|
||||
// U/(K*A^m), so this map and the slope map should be recognisably the same picture; when they are not,
|
||||
// something downstream is overriding the tectonics, which is exactly how the repose clamp turned out to
|
||||
// be the surface of the whole continent.
|
||||
// - map_erodibility: the lithology multiplier on K. Hard bands stand up as ridges and soft ones are cut
|
||||
// away, so this is where the texture inside a range comes from.
|
||||
// - map_slope: degrees. The one to read next to map_uplift.
|
||||
// - map_relief: local relief over 500 m, which separates a 5 m hummock from a 500 m mountainside — both
|
||||
// can stand at 30 degrees and the slope map cannot tell them apart.
|
||||
// - map_basins: one colour per drainage basin. The direct picture of whether the solve made a network.
|
||||
// - map_flow: log drainage area, the rivers themselves.
|
||||
func writeDataMaps(dir string, h *field.Field, up *uplift.Result, cs *coast.Result, grid *fluvial.Grid, size int) error {
|
||||
sea := cs.Sea
|
||||
|
||||
rateMmYr := field.NewLike(up.Rate)
|
||||
for i, v := range up.Rate.Data {
|
||||
rateMmYr.Data[i] = v * 1000
|
||||
}
|
||||
if err := field.WriteDataMap(filepath.Join(dir, "map_uplift.png"), rateMmYr,
|
||||
field.DataMapOptions{Sea: sea, Size: size, Palette: field.Inferno}); err != nil {
|
||||
return err
|
||||
}
|
||||
if up.K != nil {
|
||||
if err := field.WriteDataMap(filepath.Join(dir, "map_erodibility.png"), up.K,
|
||||
field.DataMapOptions{Sea: sea, Size: size}); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
slope := h.Slope()
|
||||
deg := field.NewLike(slope)
|
||||
for i, s := range slope.Data {
|
||||
deg.Data[i] = float32(math.Atan(float64(s)) * 180 / math.Pi)
|
||||
}
|
||||
if err := field.WriteDataMap(filepath.Join(dir, "map_slope.png"), deg,
|
||||
field.DataMapOptions{Sea: sea, Size: size, Lo: 0, Hi: 45, Palette: field.Inferno}); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if err := field.WriteDataMap(filepath.Join(dir, "map_relief.png"), localRelief(h, 500),
|
||||
field.DataMapOptions{Sea: sea, Size: size, Palette: field.Inferno}); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
// The coast's own two. Exposure is the input both shore processes are driven by, and it is the one to
|
||||
// read when a beach turns up on a headland or a cliff at the back of a bay. The change map is the pass's
|
||||
// whole effect in one picture: cool where the surf cut, warm where the sediment landed.
|
||||
//
|
||||
// Exposure is drawn only within a kilometre of the water, and the rest is rendered as the flat "no data"
|
||||
// colour. That is not tidiness: exposure is measured on the waterline and carried to every other cell by
|
||||
// "the stretch of shore nearest to you", which past a few hundred metres is a map of the continent's
|
||||
// medial axis rather than of anything coastal. The first render of it was a sunburst of polygonal wedges
|
||||
// meeting in the middle of the continent, which says nothing about a coast and hides what does.
|
||||
band := make([]bool, len(cs.Exposure.Data))
|
||||
for i, d := range cs.Geometry.Dist.Data {
|
||||
band[i] = math.Abs(float64(d)) > 1000
|
||||
}
|
||||
if err := field.WriteDataMap(filepath.Join(dir, "map_exposure.png"), cs.Exposure,
|
||||
field.DataMapOptions{Sea: band, Size: size, Lo: 0, Hi: 1, Palette: field.Inferno}); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := field.WriteDataMap(filepath.Join(dir, "map_coast.png"), cs.Change,
|
||||
field.DataMapOptions{Size: size, Lo: -30, Hi: 30, Palette: field.Divergent}); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if grid == nil {
|
||||
return nil
|
||||
}
|
||||
flow := field.New(h.W, h.H, h.CellM)
|
||||
copy(flow.Data, grid.Area)
|
||||
if err := field.WriteDataMap(filepath.Join(dir, "map_flow.png"), flow,
|
||||
field.DataMapOptions{Sea: sea, Size: size, Log: true}); err != nil {
|
||||
return err
|
||||
}
|
||||
return field.WriteBasinMap(filepath.Join(dir, "map_basins.png"), h.W, h.H, grid.Receiver, sea, size)
|
||||
}
|
||||
|
||||
// localRelief is max minus min over a square window, as a field. Separable: the row pass then the column
|
||||
// pass, each a sliding min and max, so the cost does not grow with the window.
|
||||
func localRelief(h *field.Field, windowM float64) *field.Field {
|
||||
r := int(math.Round(windowM / h.CellM / 2))
|
||||
if r < 1 {
|
||||
r = 1
|
||||
}
|
||||
rowLo, rowHi := field.NewLike(h), field.NewLike(h)
|
||||
for y := 0; y < h.H; y++ {
|
||||
for x := 0; x < h.W; x++ {
|
||||
lo, hi := float32(math.Inf(1)), float32(math.Inf(-1))
|
||||
for d := -r; d <= r; d++ {
|
||||
v := h.AtClamped(x+d, y)
|
||||
if v < lo {
|
||||
lo = v
|
||||
}
|
||||
if v > hi {
|
||||
hi = v
|
||||
}
|
||||
}
|
||||
rowLo.Data[y*h.W+x], rowHi.Data[y*h.W+x] = lo, hi
|
||||
}
|
||||
}
|
||||
out := field.NewLike(h)
|
||||
for y := 0; y < h.H; y++ {
|
||||
for x := 0; x < h.W; x++ {
|
||||
lo, hi := float32(math.Inf(1)), float32(math.Inf(-1))
|
||||
for d := -r; d <= r; d++ {
|
||||
if v := rowLo.AtClamped(x, y+d); v < lo {
|
||||
lo = v
|
||||
}
|
||||
if v := rowHi.AtClamped(x, y+d); v > hi {
|
||||
hi = v
|
||||
}
|
||||
}
|
||||
out.Data[y*h.W+x] = hi - lo
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
Reference in New Issue
Block a user