Tooling
This commit is contained in:
Rainer Leit
@@ -0,0 +1,818 @@
|
||||
package template
|
||||
|
||||
import (
|
||||
"math"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"salty/terrain/internal/world"
|
||||
)
|
||||
|
||||
const goodLegend = `{
|
||||
"image": "x.png",
|
||||
"classes": [
|
||||
{ "name": "ocean", "rgb": [0, 0, 255], "sea": true, "depth_m": 500 },
|
||||
{ "name": "land", "rgb": [0, 255, 0], "uplift_mm_yr": 0.5, "k_mult": 2 },
|
||||
{ "name": "ice", "rgb": [200, 200, 200], "uplift_mm_yr": 0.05 },
|
||||
{ "name": "white", "rgb": [255, 255, 255], "stroke": true, "edge_class": "ice" },
|
||||
{ "name": "outline", "rgb": [255, 0, 255], "stroke": true }
|
||||
]
|
||||
}`
|
||||
|
||||
func mustLegend(t *testing.T, src string) *Legend {
|
||||
t.Helper()
|
||||
l, err := Parse([]byte(src))
|
||||
if err != nil {
|
||||
t.Fatalf("Parse: %v", err)
|
||||
}
|
||||
return l
|
||||
}
|
||||
|
||||
func TestLegendResolves(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
if l.WarnDistance != DefaultWarnDistance {
|
||||
t.Errorf("WarnDistance = %v, want the default %v", l.WarnDistance, DefaultWarnDistance)
|
||||
}
|
||||
if got := l.Index("land"); got != 1 {
|
||||
t.Errorf("Index(land) = %d, want 1", got)
|
||||
}
|
||||
if got := l.EdgeIndex(3); got != 2 {
|
||||
t.Errorf("EdgeIndex(white) = %d, want 2 (ice)", got)
|
||||
}
|
||||
if got := l.EdgeIndex(1); got != -1 {
|
||||
t.Errorf("EdgeIndex(land) = %d, want -1", got)
|
||||
}
|
||||
if got := l.Classes[1].K(); got != 2 {
|
||||
t.Errorf("land K = %v, want 2", got)
|
||||
}
|
||||
if got := l.Classes[2].K(); got != 1 {
|
||||
t.Errorf("ice K = %v, want 1 (zero reads as one)", got)
|
||||
}
|
||||
if got := l.Classes[1].RateMYr(); got != 0.0005 {
|
||||
t.Errorf("land rate = %v m/yr, want 0.0005", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegendRefusesTheImpossible(t *testing.T) {
|
||||
cases := []struct{ name, src, want string }{
|
||||
{"no classes", `{"classes":[]}`, "no classes"},
|
||||
{"duplicate colour", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3]},{"name":"b","rgb":[1,2,3]}]}`, "share the colour"},
|
||||
{"duplicate name", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3]},{"name":"a","rgb":[4,5,6]}]}`, "both named"},
|
||||
{"sea with uplift", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"sea":true,"uplift_mm_yr":1}]}`, "would never read them"},
|
||||
{"land with depth", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"depth_m":10}]}`, "carries depth_m"},
|
||||
{"negative depth", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"sea":true,"depth_m":-10}]}`, "so positive"},
|
||||
{"edge on a non-stroke", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3]},{"name":"b","rgb":[4,5,6],"edge_class":"a"}]}`, "is not a stroke"},
|
||||
{"edge names nothing", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3]},{"name":"b","rgb":[4,5,6],"stroke":true,"edge_class":"z"}]}`,
|
||||
"is not a class"},
|
||||
{"everything is a stroke", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"stroke":true}]}`, "nothing for them to dissolve into"},
|
||||
{"rgb out of range", `{"classes":[{"name":"a","rgb":[1,2,300]}]}`, "outside 0..255"},
|
||||
{"sea with a massif", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"sea":true,"massif":{"floor_mm_yr":0.01,"fraction":0.2}}]}`,
|
||||
"carries a land property"},
|
||||
{"massif floor at or above the rate", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"uplift_mm_yr":0.08,"massif":{"floor_mm_yr":0.08,"fraction":0.2}}]}`,
|
||||
"below the rate they reach"},
|
||||
{"negative massif floor", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"uplift_mm_yr":0.08,"massif":{"floor_mm_yr":-0.01,"fraction":0.2}}]}`,
|
||||
"subsidence is not modelled"},
|
||||
{"massif fraction of nothing", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"uplift_mm_yr":0.08,"massif":{"floor_mm_yr":0.01,"fraction":0}}]}`,
|
||||
"must be over 0"},
|
||||
{"massif fraction past the ramp", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"uplift_mm_yr":0.08,"massif":{"floor_mm_yr":0.01,"fraction":0.8}}]}`,
|
||||
"must be over 0"},
|
||||
{"misspelt massif key", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"uplift_mm_yr":0.08,"massif":{"floor":0.01,"fraction":0.2}}]}`,
|
||||
"unknown field"},
|
||||
{"sea with faults", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"sea":true,"faults":{"per_1000km2":5,"throw_m":[100,200],
|
||||
"length_km":[4,8]}}]}`, "carries a land property"},
|
||||
{"sea with a lithology mix", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"sea":true,"lithology_mix":0.5}]}`, "carries a land property"},
|
||||
{"a fault block asking for nothing", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"faults":{"per_1000km2":0,"throw_m":[100,200],
|
||||
"length_km":[4,8]}}]}`, "leave the block out"},
|
||||
{"fault length the wrong way round", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"faults":{"per_1000km2":5,"throw_m":[100,200],
|
||||
"length_km":[8,4]}}]}`, "low-to-high range in kilometres"},
|
||||
{"fault throw the wrong way round", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"faults":{"per_1000km2":5,"throw_m":[200,100],
|
||||
"length_km":[4,8]}}]}`, "low-to-high range of total"},
|
||||
{"lithology mix past one", `{"classes":[
|
||||
{"name":"a","rgb":[1,2,3],"lithology_mix":1.5}]}`, "outside 0..1"},
|
||||
}
|
||||
for _, c := range cases {
|
||||
t.Run(c.name, func(t *testing.T) {
|
||||
_, err := Parse([]byte(c.src))
|
||||
if err == nil {
|
||||
t.Fatalf("accepted %s", c.name)
|
||||
}
|
||||
if !strings.Contains(err.Error(), c.want) {
|
||||
t.Errorf("error %q does not mention %q", err, c.want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// build an RGB buffer from a small picture written as one rune per pixel.
|
||||
func picture(t *testing.T, l *Legend, rows []string) ([]uint8, int, int) {
|
||||
t.Helper()
|
||||
h := len(rows)
|
||||
w := len(rows[0])
|
||||
px := make([]uint8, w*h*3)
|
||||
for y, row := range rows {
|
||||
if len(row) != w {
|
||||
t.Fatalf("row %d is %d wide, want %d", y, len(row), w)
|
||||
}
|
||||
for x, r := range row {
|
||||
var ci int
|
||||
switch r {
|
||||
case 'o':
|
||||
ci = l.Index("ocean")
|
||||
case 'L':
|
||||
ci = l.Index("land")
|
||||
case 'i':
|
||||
ci = l.Index("ice")
|
||||
case 'W':
|
||||
ci = l.Index("white")
|
||||
case 'X':
|
||||
ci = l.Index("outline")
|
||||
case '?':
|
||||
ci = -1
|
||||
default:
|
||||
t.Fatalf("unknown pixel %q", r)
|
||||
}
|
||||
o := (y*w + x) * 3
|
||||
if ci < 0 {
|
||||
px[o], px[o+1], px[o+2] = 0, 0, 0 // the stray black pixel a real template had
|
||||
continue
|
||||
}
|
||||
c := l.Classes[ci]
|
||||
px[o], px[o+1], px[o+2] = uint8(c.RGB[0]), uint8(c.RGB[1]), uint8(c.RGB[2])
|
||||
}
|
||||
}
|
||||
return px, w, h
|
||||
}
|
||||
|
||||
func render(l *Legend, r *Raster) []string {
|
||||
sym := map[string]rune{"ocean": 'o', "land": 'L', "ice": 'i', "white": 'W', "outline": 'X'}
|
||||
out := make([]string, r.H)
|
||||
for y := 0; y < r.H; y++ {
|
||||
var b strings.Builder
|
||||
for x := 0; x < r.W; x++ {
|
||||
b.WriteRune(sym[l.Classes[r.Class[y*r.W+x]].Name])
|
||||
}
|
||||
out[y] = b.String()
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func TestClassifyIsTotalAndReportsTheStrays(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
px, w, h := picture(t, l, []string{
|
||||
"ooLL",
|
||||
"oo?L",
|
||||
})
|
||||
r, m := l.Classify(px, w, h)
|
||||
if m.Total != 8 {
|
||||
t.Errorf("Total = %d, want 8", m.Total)
|
||||
}
|
||||
// Black is nearest to ocean here, and nothing is unclassified - but it must be reported as far.
|
||||
if m.Far != 1 {
|
||||
t.Errorf("Far = %d, want 1: the black pixel", m.Far)
|
||||
}
|
||||
if m.MaxAt != [2]int{2, 1} {
|
||||
t.Errorf("MaxAt = %v, want the black pixel at 2,1", m.MaxAt)
|
||||
}
|
||||
if m.MaxDist < 100 {
|
||||
t.Errorf("MaxDist = %.1f, want it large", m.MaxDist)
|
||||
}
|
||||
if got := render(l, r)[0]; got != "ooLL" {
|
||||
t.Errorf("row 0 = %q", got)
|
||||
}
|
||||
if n := m.Counts[l.Index("land")]; n != 3 {
|
||||
t.Errorf("land count = %d, want 3", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestWhiteAtThePoleIsIceAndWhiteAroundAnIslandIsNot(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
px, w, h := picture(t, l, []string{
|
||||
"WWWW", // the cap: touches row 0, so it is ice
|
||||
"WWWW",
|
||||
"oooo",
|
||||
"oWWo", // an island's outline: touches nothing, so it dissolves
|
||||
"oWLo",
|
||||
"oooo",
|
||||
})
|
||||
r, _ := l.Classify(px, w, h)
|
||||
edge, dissolved := r.DissolveStrokes(l)
|
||||
if edge != 8 {
|
||||
t.Errorf("edge rewrites = %d, want 8", edge)
|
||||
}
|
||||
if dissolved != 3 {
|
||||
t.Errorf("dissolved = %d, want 3", dissolved)
|
||||
}
|
||||
got := render(l, r)
|
||||
want := []string{"iiii", "iiii", "oooo", "oooo", "ooLo", "oooo"}
|
||||
for y := range want {
|
||||
if got[y] != want[y] {
|
||||
t.Errorf("row %d = %q, want %q (whole picture %v)", y, got[y], want[y], got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// A stroke lying between land and water is split down the middle. Giving it wholly to one side would
|
||||
// move the coastline by the width of the artist's brush, which on a real template is hundreds of metres.
|
||||
func TestStrokeSplitsDownItsMiddle(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
px, w, h := picture(t, l, []string{
|
||||
"LLL",
|
||||
"LLL",
|
||||
"WWW",
|
||||
"WWW",
|
||||
"ooo",
|
||||
"ooo",
|
||||
})
|
||||
r, _ := l.Classify(px, w, h)
|
||||
if _, n := r.DissolveStrokes(l); n != 6 {
|
||||
t.Errorf("dissolved = %d, want 6", n)
|
||||
}
|
||||
got := render(l, r)
|
||||
want := []string{"LLL", "LLL", "LLL", "ooo", "ooo", "ooo"}
|
||||
for y := range want {
|
||||
if got[y] != want[y] {
|
||||
t.Errorf("row %d = %q, want %q (whole picture %v)", y, got[y], want[y], got)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The map is a cylinder: a stroke on the left edge is reached by land on the right edge.
|
||||
func TestDissolveWrapsInX(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
// One row, and a stroke class with no edge_class so the polar rescue never applies. The stroke at
|
||||
// x=0 has land only at x=5, on the far side of the seam; if X did not wrap it would take the ocean
|
||||
// in the middle instead.
|
||||
px, w, h := picture(t, l, []string{"XXoXXL"})
|
||||
r, _ := l.Classify(px, w, h)
|
||||
r.DissolveStrokes(l)
|
||||
got := render(l, r)
|
||||
want := []string{"LoooLL"}
|
||||
for y := range want {
|
||||
if got[y] != want[y] {
|
||||
t.Errorf("row %d = %q, want %q", y, got[y], want[y])
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRasterAtWrapsXAndClampsY(t *testing.T) {
|
||||
r := &Raster{W: 3, H: 2, Class: []uint8{1, 2, 3, 4, 5, 6}}
|
||||
if got := r.At(-1, 0); got != 3 {
|
||||
t.Errorf("At(-1,0) = %d, want 3", got)
|
||||
}
|
||||
if got := r.At(3, 0); got != 1 {
|
||||
t.Errorf("At(3,0) = %d, want 1", got)
|
||||
}
|
||||
if got := r.At(0, -1); got != 1 {
|
||||
t.Errorf("At(0,-1) = %d, want 1 (clamped to the pole)", got)
|
||||
}
|
||||
if got := r.At(0, 9); got != 4 {
|
||||
t.Errorf("At(0,9) = %d, want 4", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestProjectIsNearestNeighbourAndPadsThePoles(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
// A 4x2 paint: land on the right half, ocean on the left.
|
||||
px, w, h := picture(t, l, []string{
|
||||
"ooLL",
|
||||
"ooLL",
|
||||
})
|
||||
r, _ := l.Classify(px, w, h)
|
||||
|
||||
// 8 columns of 10 m is an 80 m circumference; the paint's 4:2 aspect gives 4 painted rows, plus 1 of
|
||||
// pad at each end.
|
||||
p, err := world.New(80, 10, w, h, 1, 80)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if p.W != 8 || p.PaintH() != 4 || p.H != 6 {
|
||||
t.Fatalf("planet is %dx%d with %d painted rows, want 8x6 with 4", p.W, p.H, p.PaintH())
|
||||
}
|
||||
|
||||
m := r.Project(p, l, l.Index("ocean"))
|
||||
|
||||
for x := 0; x < p.W; x++ {
|
||||
if !m.Sea[0*p.W+x] || !m.Sea[(p.H-1)*p.W+x] {
|
||||
t.Fatalf("pad row is not sea at column %d", x)
|
||||
}
|
||||
}
|
||||
// Every painted row upsamples the same way: four ocean cells then four land cells, and no third class
|
||||
// has been invented in between.
|
||||
for y := p.PadY; y < p.H-p.PadY; y++ {
|
||||
for x := 0; x < p.W; x++ {
|
||||
wantSea := x < 4
|
||||
if m.Sea[y*p.W+x] != wantSea {
|
||||
t.Fatalf("cell (%d,%d): sea = %v, want %v", x, y, m.Sea[y*p.W+x], wantSea)
|
||||
}
|
||||
name := l.Classes[m.Class[y*p.W+x]].Name
|
||||
if name != "ocean" && name != "land" {
|
||||
t.Fatalf("cell (%d,%d) is %q; projection invented a class", x, y, name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
perClass, land, total := m.Counts()
|
||||
if total != p.W*p.PaintH() {
|
||||
t.Errorf("Counts total = %d, want %d (the pad is not part of the world)", total, p.W*p.PaintH())
|
||||
}
|
||||
if land != 16 {
|
||||
t.Errorf("land = %d, want 16", land)
|
||||
}
|
||||
if perClass[l.Index("land")] != 16 {
|
||||
t.Errorf("land class count = %d, want 16", perClass[l.Index("land")])
|
||||
}
|
||||
}
|
||||
|
||||
func TestPerClassTables(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
rates := l.Rates()
|
||||
if got := rates[l.Index("land")]; got != 0.0005 {
|
||||
t.Errorf("land rate = %v, want 0.0005 m/yr", got)
|
||||
}
|
||||
if got := rates[l.Index("ocean")]; got != 0 {
|
||||
t.Errorf("ocean rate = %v, want 0", got)
|
||||
}
|
||||
ks := l.Erodibilities()
|
||||
if got := ks[l.Index("land")]; got != 2 {
|
||||
t.Errorf("land K = %v, want 2", got)
|
||||
}
|
||||
if got := ks[l.Index("ocean")]; got != 1 {
|
||||
t.Errorf("ocean K = %v, want 1: a zero would be carried into a division", got)
|
||||
}
|
||||
if got := l.Depths()[l.Index("ocean")]; got != 500 {
|
||||
t.Errorf("ocean depth = %v, want 500", got)
|
||||
}
|
||||
}
|
||||
|
||||
// A class with no massif block is one rate all over, and the tables have to say so in the way internal/uplift
|
||||
// reads them: a zero fraction, which is what switches the fabric off, and a floor that is the class's own rate
|
||||
// so that nothing can read a plain out of a class that never asked for one.
|
||||
func TestAClassWithNoMassifIsOneRateAllOver(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
floor, fraction := l.Massifs()
|
||||
i := l.Index("land")
|
||||
if fraction[i] != 0 {
|
||||
t.Errorf("fraction = %v, want 0 for a class with no massif block", fraction[i])
|
||||
}
|
||||
if got := floor[i]; got != 0.0005 {
|
||||
t.Errorf("floor = %v, want the class rate 0.0005 m/yr", got)
|
||||
}
|
||||
if l.HasMassifs() {
|
||||
t.Error("HasMassifs is true for a legend with no massif block anywhere")
|
||||
}
|
||||
}
|
||||
|
||||
// And a class that asks for one reports the numbers the fabric is cut with.
|
||||
func TestAMassifClassReportsItsFloorAndFraction(t *testing.T) {
|
||||
l := mustLegend(t, `{"classes":[
|
||||
{"name":"ocean","rgb":[0,0,255],"sea":true,"depth_m":500},
|
||||
{"name":"land","rgb":[0,255,0],"uplift_mm_yr":0.08,
|
||||
"massif":{"floor_mm_yr":0.012,"fraction":0.16}}]}`)
|
||||
if !l.HasMassifs() {
|
||||
t.Fatal("HasMassifs is false for a legend that has one")
|
||||
}
|
||||
floor, fraction := l.Massifs()
|
||||
i := l.Index("land")
|
||||
if got, want := float64(floor[i]), 0.000012; math.Abs(got-want) > 1e-12 {
|
||||
t.Errorf("floor = %v m/yr, want %v", got, want)
|
||||
}
|
||||
if fraction[i] != 0.16 {
|
||||
t.Errorf("fraction = %v, want 0.16", fraction[i])
|
||||
}
|
||||
// Sea classes carry neither, and the fraction has to be zero rather than inherited: a sea cell is held at
|
||||
// base level for the whole run and a fabric there would be a field nobody reads.
|
||||
if j := l.Index("ocean"); floor[j] != 0 || fraction[j] != 0 {
|
||||
t.Errorf("ocean carries floor %v fraction %v, want both zero", floor[j], fraction[j])
|
||||
}
|
||||
}
|
||||
|
||||
// White is drawn twice on a hand-painted world map: the polar caps and the stroke around every island. Only
|
||||
// one class can own that colour, and it has to be the stroke - so what the caps become is a class with no
|
||||
// colour of its own.
|
||||
func TestADerivedClassIsNeverMatched(t *testing.T) {
|
||||
const src = `{"classes":[
|
||||
{"name":"sea","rgb":[0,0,255],"sea":true},
|
||||
{"name":"ice","derived":true,"uplift_mm_yr":0.05},
|
||||
{"name":"white","rgb":[238,238,238],"stroke":true,"edge_class":"ice"}
|
||||
]}`
|
||||
l := mustLegend(t, src)
|
||||
|
||||
// A pixel near white must become the stroke, not the derived ice, however close ice's zero colour is.
|
||||
px := []uint8{236, 236, 236}
|
||||
r, m := l.Classify(px, 1, 1)
|
||||
if got := l.Classes[r.Class[0]].Name; got != "white" {
|
||||
t.Errorf("a near-white pixel classified as %q, want the painted stroke", got)
|
||||
}
|
||||
if m.Counts[l.Index("ice")] != 0 {
|
||||
t.Error("the derived class matched a pixel")
|
||||
}
|
||||
}
|
||||
|
||||
// A derived class may carry a colour, and it is display only: the diagnostic maps need something to draw it
|
||||
// with, and without one the polar caps came out as black holes in map_class.png.
|
||||
func TestADerivedClassColourIsDisplayOnly(t *testing.T) {
|
||||
l := mustLegend(t, `{"classes":[
|
||||
{"name":"sea","rgb":[0,0,255],"sea":true},
|
||||
{"name":"ice","derived":true,"rgb":[250,250,250]},
|
||||
{"name":"white","rgb":[238,238,238],"stroke":true,"edge_class":"ice"}
|
||||
]}`)
|
||||
// 245,245,245 is nearer to ice's display colour than to the painted stroke, and must still be the stroke.
|
||||
r, _ := l.Classify([]uint8{245, 245, 245}, 1, 1)
|
||||
if got := l.Classes[r.Class[0]].Name; got != "white" {
|
||||
t.Errorf("classified as %q, want the painted stroke: a derived colour must not match", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLegendRefusesAllDerived(t *testing.T) {
|
||||
_, err := Parse([]byte(`{"classes":[{"name":"a","derived":true}]}`))
|
||||
if err == nil || !strings.Contains(err.Error(), "every class is derived") {
|
||||
t.Fatalf("error = %v, want a refusal", err)
|
||||
}
|
||||
}
|
||||
|
||||
// The mask is opt-in: zero amplitude has to leave the painting exactly as drawn, because every template
|
||||
// written before it existed was drawn against that contract.
|
||||
func TestNoCoastMaskLeavesThePaintingExactly(t *testing.T) {
|
||||
p := testCylinder(t, 512, 288)
|
||||
l := mustLegend(t, goodLegend)
|
||||
r := stripeRaster(512, 288, l)
|
||||
|
||||
out := r.RoughenCoast(l, p, Coast{AmplitudePx: 0, WavelengthPx: 64, Octaves: 4, Gain: 0.5})
|
||||
for i := range r.Class {
|
||||
if out.Class[i] != r.Class[i] {
|
||||
t.Fatalf("pixel %d changed with the mask switched off", i)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// What it is for: a ruled painted coastline has to come back with bays in it. Measured as the spread of the
|
||||
// waterline's row along the map - zero for a drawn line, tens of pixels for a coast.
|
||||
func TestTheCoastMaskCutsBaysIntoARuledShore(t *testing.T) {
|
||||
p := testCylinder(t, 1024, 512)
|
||||
l := mustLegend(t, goodLegend)
|
||||
r := stripeRaster(1024, 512, l) // land above the halfway row, ocean below
|
||||
|
||||
if lo, hi := shoreSpread(r, l); hi-lo != 0 {
|
||||
t.Fatalf("the painted shore is not ruled: rows %d..%d; the test would measure nothing", lo, hi)
|
||||
}
|
||||
|
||||
out := r.RoughenCoast(l, p, Coast{
|
||||
AmplitudePx: 48, WavelengthPx: 256, Octaves: 5, Gain: 0.55, Seed: 7,
|
||||
})
|
||||
lo, hi := shoreSpread(out, l)
|
||||
if hi-lo < 20 {
|
||||
t.Errorf("the roughened shore spans %d rows (%d..%d); the mask is barely moving it", hi-lo+1, lo, hi)
|
||||
}
|
||||
// And it must stay a coastline rather than dissolving into speckle: the land has to remain one run down
|
||||
// every column, not a scatter of pixels.
|
||||
if runs := columnRuns(out, l, 1024/2); runs > 3 {
|
||||
t.Errorf("a column crosses the waterline %d times; the mask is dissolving the shore, not shaping it",
|
||||
runs)
|
||||
}
|
||||
}
|
||||
|
||||
// An archipelago has to survive. Under a wavelength far wider than an islet the noise is very nearly a
|
||||
// constant across it, so without the guard the whole islet steps to the wrong side of zero at once and a
|
||||
// scatter of islands disappears between two runs.
|
||||
func TestSmallIslandsAreNibbledRatherThanDeleted(t *testing.T) {
|
||||
p := testCylinder(t, 1024, 512)
|
||||
l := mustLegend(t, goodLegend)
|
||||
land := uint8(l.Index("land"))
|
||||
sea := uint8(l.Index("ocean"))
|
||||
|
||||
r := &Raster{W: 1024, H: 512, Class: make([]uint8, 1024*512)}
|
||||
for i := range r.Class {
|
||||
r.Class[i] = sea
|
||||
}
|
||||
// Twelve islets of radius 8, well apart, none of them anywhere near the amplitude in size.
|
||||
centres := [][2]int{}
|
||||
for k := 0; k < 12; k++ {
|
||||
centres = append(centres, [2]int{60 + k*80, 200 + (k%3)*90})
|
||||
}
|
||||
for _, c := range centres {
|
||||
for dy := -8; dy <= 8; dy++ {
|
||||
for dx := -8; dx <= 8; dx++ {
|
||||
if dx*dx+dy*dy <= 64 {
|
||||
r.Class[(c[1]+dy)*r.W+c[0]+dx] = land
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
out := r.RoughenCoast(l, p, Coast{
|
||||
AmplitudePx: 64, WavelengthPx: 256, Octaves: 5, Gain: 0.55, Seed: 7,
|
||||
})
|
||||
|
||||
gone := 0
|
||||
for _, c := range centres {
|
||||
alive := false
|
||||
for dy := -20; dy <= 20 && !alive; dy++ {
|
||||
for dx := -20; dx <= 20; dx++ {
|
||||
x, y := c[0]+dx, c[1]+dy
|
||||
if x < 0 || y < 0 || x >= out.W || y >= out.H {
|
||||
continue
|
||||
}
|
||||
if out.Class[y*out.W+x] == land {
|
||||
alive = true
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if !alive {
|
||||
gone++
|
||||
}
|
||||
}
|
||||
if gone > 0 {
|
||||
t.Errorf("%d of %d islets were erased by a mask four times their radius; the island guard is not "+
|
||||
"holding", gone, len(centres))
|
||||
}
|
||||
}
|
||||
|
||||
// The seam is the one place a coastline can break invisibly, because the map's two edges are as far apart on
|
||||
// screen as they can be. The mask is world-indexed and its distance transform wraps, so a shore crossing the
|
||||
// seam has to come out continuous.
|
||||
func TestTheCoastMaskWrapsAtTheSeam(t *testing.T) {
|
||||
p := testCylinder(t, 1024, 512)
|
||||
l := mustLegend(t, goodLegend)
|
||||
r := stripeRaster(1024, 512, l)
|
||||
out := r.RoughenCoast(l, p, Coast{
|
||||
AmplitudePx: 48, WavelengthPx: 256, Octaves: 5, Gain: 0.55, Seed: 7,
|
||||
})
|
||||
|
||||
// The waterline's row in the first column and in the last must be within a pixel or two of each other,
|
||||
// exactly as two adjacent columns anywhere inside the map are.
|
||||
rowAt := func(x int) int {
|
||||
for y := 0; y < out.H; y++ {
|
||||
if l.Classes[out.Class[y*out.W+x]].Sea {
|
||||
return y
|
||||
}
|
||||
}
|
||||
return -1
|
||||
}
|
||||
seam := rowAt(0) - rowAt(out.W-1)
|
||||
if seam < 0 {
|
||||
seam = -seam
|
||||
}
|
||||
worst := 0
|
||||
for x := 1; x < out.W; x++ {
|
||||
d := rowAt(x) - rowAt(x-1)
|
||||
if d < 0 {
|
||||
d = -d
|
||||
}
|
||||
if d > worst {
|
||||
worst = d
|
||||
}
|
||||
}
|
||||
if seam > worst {
|
||||
t.Errorf("the shore steps %d rows across the seam against %d anywhere inside the map", seam, worst)
|
||||
}
|
||||
}
|
||||
|
||||
func testCylinder(t *testing.T, w, h int) world.Planet {
|
||||
t.Helper()
|
||||
p := world.Planet{CellM: 8, W: w, H: h, PadY: 0, NoisePeriodM: float64(w) * 8}
|
||||
if err := p.Validate(); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return p
|
||||
}
|
||||
|
||||
// shoreSpread is the lowest and highest row at which a column first meets water.
|
||||
func shoreSpread(r *Raster, l *Legend) (lo, hi int) {
|
||||
lo, hi = 1<<30, -1
|
||||
for x := 0; x < r.W; x++ {
|
||||
for y := 0; y < r.H; y++ {
|
||||
if l.Classes[r.Class[y*r.W+x]].Sea {
|
||||
if y < lo {
|
||||
lo = y
|
||||
}
|
||||
if y > hi {
|
||||
hi = y
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
return lo, hi
|
||||
}
|
||||
|
||||
// columnRuns counts how many times a column crosses the waterline.
|
||||
func columnRuns(r *Raster, l *Legend, x int) int {
|
||||
n := 0
|
||||
prev := l.Classes[r.Class[x]].Sea
|
||||
for y := 1; y < r.H; y++ {
|
||||
cur := l.Classes[r.Class[y*r.W+x]].Sea
|
||||
if cur != prev {
|
||||
n++
|
||||
prev = cur
|
||||
}
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// stripeRaster is a painting with one ruled coastline: land in the top half, ocean in the bottom.
|
||||
func stripeRaster(w, h int, l *Legend) *Raster {
|
||||
r := &Raster{W: w, H: h, Class: make([]uint8, w*h)}
|
||||
land := uint8(l.Index("land"))
|
||||
sea := uint8(l.Index("ocean"))
|
||||
for y := 0; y < h; y++ {
|
||||
c := land
|
||||
if y >= h/2 {
|
||||
c = sea
|
||||
}
|
||||
for x := 0; x < w; x++ {
|
||||
r.Class[y*w+x] = c
|
||||
}
|
||||
}
|
||||
return r
|
||||
}
|
||||
|
||||
// The failure this exists for, built in miniature: a one-pixel ribbon of a class nobody painted, lying along
|
||||
// the boundary between the two it is a blend of. On the real template that ribbon was `desert` along every
|
||||
// temperate coast, because the JPEG's blend of surf and lowland is nearer to desert than to either parent.
|
||||
func TestDespeckleRemovesAHairlineBetweenTwoClasses(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
const w, h = 64, 64
|
||||
land := uint8(l.Index("land"))
|
||||
sea := uint8(l.Index("ocean"))
|
||||
ice := uint8(l.Index("ice")) // standing in for the class nobody painted
|
||||
|
||||
r := &Raster{W: w, H: h, Class: make([]uint8, w*h)}
|
||||
for y := 0; y < h; y++ {
|
||||
for x := 0; x < w; x++ {
|
||||
c := land
|
||||
if y > h/2 {
|
||||
c = sea
|
||||
}
|
||||
if y == h/2 {
|
||||
c = ice // the hairline, one pixel wide, all the way across
|
||||
}
|
||||
r.Class[y*w+x] = c
|
||||
}
|
||||
}
|
||||
|
||||
n := r.Despeckle()
|
||||
if n == 0 {
|
||||
t.Fatal("nothing was despeckled; the hairline is still there")
|
||||
}
|
||||
for x := 0; x < w; x++ {
|
||||
if got := r.Class[(h/2)*w+x]; got == ice {
|
||||
t.Fatalf("column %d of the hairline survived as %q", x, l.Classes[got].Name)
|
||||
}
|
||||
}
|
||||
// And it must have joined one of its neighbours rather than becoming something else again.
|
||||
for x := 0; x < w; x++ {
|
||||
if got := r.Class[(h/2)*w+x]; got != land && got != sea {
|
||||
t.Fatalf("column %d became %q, which is neither side of the boundary", x, l.Classes[got].Name)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The other half of the contract, and the one that keeps the rule honest: a band two pixels wide is
|
||||
// something an author drew, and it has to survive untouched. Without this the threshold could be raised
|
||||
// until it ate the map.
|
||||
func TestDespeckleLeavesARealBandAlone(t *testing.T) {
|
||||
l := mustLegend(t, goodLegend)
|
||||
const w, h = 64, 64
|
||||
land := uint8(l.Index("land"))
|
||||
sea := uint8(l.Index("ocean"))
|
||||
ice := uint8(l.Index("ice"))
|
||||
|
||||
r := &Raster{W: w, H: h, Class: make([]uint8, w*h)}
|
||||
for y := 0; y < h; y++ {
|
||||
for x := 0; x < w; x++ {
|
||||
c := land
|
||||
if y > h/2+1 {
|
||||
c = sea
|
||||
}
|
||||
if y == h/2 || y == h/2+1 {
|
||||
c = ice // two pixels wide: a painted shoreline band, not a codec artefact
|
||||
}
|
||||
r.Class[y*w+x] = c
|
||||
}
|
||||
}
|
||||
before := append([]uint8(nil), r.Class...)
|
||||
r.Despeckle()
|
||||
for i := range before {
|
||||
if before[i] != r.Class[i] {
|
||||
t.Fatalf("pixel %d changed; a two-pixel band is a feature and must survive", i)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// The mask can be masked, which is the whole of D-57's contribution to the coastline: a shore somebody drew
|
||||
// on purpose stays where they drew it while the rest of the world is still roughened.
|
||||
func TestTheCoastMaskIsMaskedByTheOverlay(t *testing.T) {
|
||||
const w, h = 1024, 512
|
||||
p := testCylinder(t, w, h)
|
||||
l := mustLegend(t, goodLegend)
|
||||
r := stripeRaster(w, h, l) // land above the halfway row, ocean below
|
||||
|
||||
cfg := Coast{AmplitudePx: 48, WavelengthPx: 256, Octaves: 5, Gain: 0.55, Seed: 7}
|
||||
free := r.RoughenCoast(l, p, cfg)
|
||||
|
||||
// Pin the left half and say nothing about the right. "Say nothing" is -1, not 1: an unmarked cell takes
|
||||
// its instruction from the far side of the waterline, and that is what makes a stroke on one side enough.
|
||||
scale := make([]float32, w*h)
|
||||
for i := range scale {
|
||||
scale[i] = -1
|
||||
}
|
||||
for y := 0; y < h; y++ {
|
||||
for x := 0; x < w/2; x++ {
|
||||
scale[y*w+x] = 0
|
||||
}
|
||||
}
|
||||
cfg.Scale = scale
|
||||
masked := r.RoughenCoast(l, p, cfg)
|
||||
|
||||
// The pinned half is the painting, exactly.
|
||||
for y := 0; y < h; y++ {
|
||||
for x := 0; x < w/2; x++ {
|
||||
if masked.Class[y*w+x] != r.Class[y*w+x] {
|
||||
t.Fatalf("pixel (%d,%d) moved inside a pinned stretch", x, y)
|
||||
}
|
||||
}
|
||||
}
|
||||
// And the half that said nothing is still roughened, or the test above proves nothing.
|
||||
moved := 0
|
||||
for y := 0; y < h; y++ {
|
||||
for x := w / 2; x < w; x++ {
|
||||
if masked.Class[y*w+x] != r.Class[y*w+x] {
|
||||
moved++
|
||||
}
|
||||
}
|
||||
}
|
||||
if moved == 0 {
|
||||
t.Fatal("nothing moved in the unmarked half; the mask is switching the whole pass off")
|
||||
}
|
||||
// The unmarked half must be exactly what it was with no mask at all - the noise is a function of world
|
||||
// position, so pinning one stretch cannot move another.
|
||||
for y := 0; y < h; y++ {
|
||||
for x := w/2 + int(cfg.AmplitudePx) + 2; x < w; x++ {
|
||||
if masked.Class[y*w+x] != free.Class[y*w+x] {
|
||||
t.Fatalf("pixel (%d,%d) differs from the unmasked run; pinning one stretch moved another",
|
||||
x, y)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Painting only the water is enough, and so is painting only the land. A mark is a brush stroke along a
|
||||
// coastline and it lands on whichever side the author's hand was on; if an unmarked cell took the default
|
||||
// amplitude, the other side would march across the line anyway and the coast would move regardless.
|
||||
func TestPinningOneSideOfTheWaterlineIsEnough(t *testing.T) {
|
||||
const w, h = 512, 256
|
||||
p := testCylinder(t, w, h)
|
||||
l := mustLegend(t, goodLegend)
|
||||
r := stripeRaster(w, h, l)
|
||||
cfg := Coast{AmplitudePx: 24, WavelengthPx: 128, Octaves: 4, Gain: 0.55, Seed: 3}
|
||||
|
||||
// Everything that could move is within the amplitude of the halfway row, so the two cases below pin the
|
||||
// same stretch of shore from opposite sides.
|
||||
landOnly := make([]float32, w*h)
|
||||
seaOnly := make([]float32, w*h)
|
||||
for i := range landOnly {
|
||||
landOnly[i], seaOnly[i] = -1, -1
|
||||
}
|
||||
for y := 0; y < h; y++ {
|
||||
for x := 0; x < w; x++ {
|
||||
if y < h/2 {
|
||||
landOnly[y*w+x] = 0
|
||||
} else {
|
||||
seaOnly[y*w+x] = 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for _, c := range []struct {
|
||||
name string
|
||||
scale []float32
|
||||
}{{"the land side", landOnly}, {"the sea side", seaOnly}} {
|
||||
cfg.Scale = c.scale
|
||||
out := r.RoughenCoast(l, p, cfg)
|
||||
for i := range r.Class {
|
||||
if out.Class[i] != r.Class[i] {
|
||||
t.Fatalf("painting %s only did not hold the shore: pixel %d moved", c.name, i)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user