Tooling
This commit is contained in:
Rainer Leit
@@ -0,0 +1,543 @@
|
||||
// Package plates is the tectonics a painted planet does not draw: which rigid pieces the lithosphere is in,
|
||||
// how they move, and therefore where they are colliding.
|
||||
//
|
||||
// It exists because of one row in Docs/Terrain.md's pass table. Pass 1 writes `uplift` *and* `boundaries`,
|
||||
// and pass 3 - faults - reads `boundaries`. D-53 dropped passes 1 to 4 on the painted path, because a
|
||||
// painted template is already a statement about where the ranges are. What went out with them was the
|
||||
// boundary set, and `uplift/painted_faults.go` substituted a noise grain field for it - a field that has
|
||||
// never been told where a belt is. That substitution is visible in `map_uplift.png`: cyan traces striking
|
||||
// across the bright belts at angles unrelated to them, the densest set sitting in a lowland, and several
|
||||
// walking out over open ocean.
|
||||
//
|
||||
// The correction is not a better grain field. A range and its faults are not two things, one decorating the
|
||||
// other: they are both consequences of the same convergence, and the line they are consequences of is the
|
||||
// plate boundary. So the boundary is what gets built first, and the uplift and the faults are both read off
|
||||
// it.
|
||||
//
|
||||
// **The plates live on the cylinder, not on a sphere.** A real plate moves by rotating about an Euler pole
|
||||
// through the centre of the planet, and the velocity that produces varies along a boundary - which is the
|
||||
// reason one margin is a head-on collision at one end and a strike-slip fault at the other. That variation
|
||||
// is worth having; the sphere is not. Every other pass here measures distance in flat metres on a cylinder
|
||||
// of fixed circumference with an 8 m cell that never varies (D-48), so a pass that believed in a sphere
|
||||
// would be the only one whose distances disagreed with the solve's, and its velocities would converge at
|
||||
// poles nothing else knows are there. The compromise keeps the property and drops the geometry: a plate's
|
||||
// motion is a translation plus a rotation about a pole **in the map plane**,
|
||||
//
|
||||
// v(x) = T + omega x (x - pole)
|
||||
//
|
||||
// which is the two-dimensional analogue and varies along a boundary for the same reason.
|
||||
//
|
||||
// **What the painting still owns.** Whether a plate is continental is read from the land mask rather than
|
||||
// drawn from the seed: a plate covering the author's continent *is* a continental plate. That is the one
|
||||
// place the painting feeds the model rather than competing with it, and it is what makes an ocean-continent
|
||||
// margin land where an author would expect a subduction zone.
|
||||
//
|
||||
// **The tectonic grid is its own, and coarse.** The partition is rasterised at a few hundred metres rather
|
||||
// than at the 8 m geology cell. A plate boundary belt is tens of kilometres wide and the finest thing read
|
||||
// off the line is a fault trace, so a quarter-kilometre lattice is already finer than anything downstream
|
||||
// can use, and it makes the whole pass a few million operations instead of a few hundred million. What
|
||||
// leaves this package is polylines in **world metres**, which is the same form `uplift.FaultTrace` already
|
||||
// travels in and for the same reason: a region filters the planet's set to what reaches its own frame, so a
|
||||
// boundary crossing a region edge is one boundary and two decompositions agree.
|
||||
package plates
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
|
||||
"salty/terrain/internal/noise"
|
||||
"salty/terrain/internal/world"
|
||||
)
|
||||
|
||||
// Pass indices for this package's seeded streams. They sit above the detail passes' 40s so that adding one
|
||||
// here cannot reshuffle any existing field.
|
||||
const (
|
||||
srcSites = 50
|
||||
srcMotion = 51
|
||||
srcWarp = 52
|
||||
)
|
||||
|
||||
// Config is what the manifest asks for. Every zero field takes a default from withDefaults.
|
||||
type Config struct {
|
||||
// Layer and Legend are the painted tectonic layer: an image where a colour is a plate, and a legend
|
||||
// saying how each one moves. Naming them is what turns the plates from something the seed invents into
|
||||
// something an author draws, and it is the intended way to use this package - see paint.go.
|
||||
//
|
||||
// With no layer the plates come from Count and the seed, which is a Voronoi partition that knows nothing
|
||||
// about where the continents are. That mode's real job is Propose: it writes a first painting, which the
|
||||
// author then edits.
|
||||
Layer string `json:"layer"`
|
||||
Legend string `json:"legend"`
|
||||
|
||||
// Count is how many plates the lithosphere is in. Earth has seven or eight majors and a couple of dozen
|
||||
// minors; what matters here is that a boundary has to have room to be a mountain belt, so the useful
|
||||
// range on a hundred-kilometre planet is single digits.
|
||||
Count int `json:"count"`
|
||||
|
||||
// SizeSpread is the ratio between the largest and smallest plate weight. The partition is a
|
||||
// multiplicatively weighted Voronoi, so a heavier site claims ground further away: 1 makes every plate
|
||||
// the same size, which is the one thing real plates never are.
|
||||
SizeSpread float64 `json:"size_spread"`
|
||||
|
||||
// VelocityCmYr is how fast a plate moves, low to high. Earth runs 1 to 10; the number that matters
|
||||
// downstream is the *relative* speed across a boundary, which is a difference of two of these.
|
||||
VelocityCmYr [2]float64 `json:"velocity_cm_yr"`
|
||||
|
||||
// SpinFraction is how much of a plate's speed is rotation about its own centre rather than translation.
|
||||
// Zero makes every margin uniform along its length, which is the defect the in-plane pole exists to
|
||||
// avoid; one makes the plate a pinwheel. A third of it is enough to turn a collision into a transform
|
||||
// over a few tens of kilometres.
|
||||
//
|
||||
// A pointer because zero is a real answer here and so is "say nothing". JSON cannot tell an absent
|
||||
// number from a zero one, and a plain float64 read them as the same thing - which is how a proposal came
|
||||
// out with every plate's spin at zero and every margin uniform, the one defect this field exists to
|
||||
// prevent. Absent takes the default; an explicit 0 means none.
|
||||
SpinFraction *float64 `json:"spin_fraction"`
|
||||
|
||||
// WarpFraction is how far a boundary wanders from the straight Voronoi edge, as a fraction of the mean
|
||||
// plate spacing. Without it the partition is a polygon net and every margin is a ruled line.
|
||||
//
|
||||
// It is applied over two octaves, and that is not decoration either: one octave at the plate wavelength
|
||||
// gives a margin one long shallow bend, which at planet scale is still a ruled line with a kink in it.
|
||||
// The second octave at a third of the wavelength is what puts a promontory and a re-entrant into a
|
||||
// margin, and those are where a collision belt gets its along-strike segmentation from.
|
||||
WarpFraction float64 `json:"warp_fraction"`
|
||||
|
||||
// ResolutionM is the tectonic grid's cell. See the package comment: coarse on purpose.
|
||||
ResolutionM float64 `json:"resolution_m"`
|
||||
|
||||
// ContinentalFraction is the share of a plate's painted area that has to be land before it counts as
|
||||
// continental. Well below a half, because a continental plate carries a shelf and a passive margin as
|
||||
// well as its continent.
|
||||
ContinentalFraction float64 `json:"continental_fraction"`
|
||||
|
||||
// ObliqueDeg is where a margin stops being convergent or divergent and becomes transform: the angle
|
||||
// between the relative velocity and the boundary normal, past which the strike-slip component is the
|
||||
// one in charge. 60 degrees means a margin stays convergent until the slip is over 1.7 times the
|
||||
// closing.
|
||||
ObliqueDeg float64 `json:"oblique_deg"`
|
||||
|
||||
// Faults is the deformation zone around every margin: how wide it is and how densely it is broken. A
|
||||
// zero block means the margins carry no faults of their own, which is what every painted planet had
|
||||
// before it existed - the legend's per-class `faults` blocks are a separate, and now secondary, set.
|
||||
Faults Belt `json:"faults"`
|
||||
}
|
||||
|
||||
// Default is the configuration a manifest that says nothing gets.
|
||||
func Default() Config {
|
||||
return Config{
|
||||
Count: 7,
|
||||
SizeSpread: 1.7,
|
||||
VelocityCmYr: [2]float64{1, 6},
|
||||
SpinFraction: nil, // see Spin(); the default lives there so that an explicit 0 can mean none
|
||||
WarpFraction: 0.34,
|
||||
ResolutionM: 250,
|
||||
ContinentalFraction: 0.18,
|
||||
ObliqueDeg: 60,
|
||||
}
|
||||
}
|
||||
|
||||
// DefaultSpinFraction is what a config that does not mention spin gets. It is not zero on purpose: a planet
|
||||
// of plates that only drift has margins identical along their whole length, and the along-strike change from
|
||||
// collision to transform is the most useful thing the model gives a fault set.
|
||||
const DefaultSpinFraction = 0.35
|
||||
|
||||
// Spin is the configured spin fraction, or the default when the manifest said nothing. An explicit zero is
|
||||
// honoured and means no rotation at all.
|
||||
func (c Config) Spin() float64 {
|
||||
if c.SpinFraction == nil {
|
||||
return DefaultSpinFraction
|
||||
}
|
||||
if *c.SpinFraction < 0 {
|
||||
return 0
|
||||
}
|
||||
return *c.SpinFraction
|
||||
}
|
||||
|
||||
func (c Config) withDefaults() Config {
|
||||
d := Default()
|
||||
if c.Count <= 0 {
|
||||
c.Count = d.Count
|
||||
}
|
||||
if c.SizeSpread < 1 {
|
||||
c.SizeSpread = d.SizeSpread
|
||||
}
|
||||
if c.VelocityCmYr[1] <= 0 {
|
||||
c.VelocityCmYr = d.VelocityCmYr
|
||||
}
|
||||
if c.VelocityCmYr[0] < 0 {
|
||||
c.VelocityCmYr[0] = 0
|
||||
}
|
||||
if c.WarpFraction < 0 {
|
||||
c.WarpFraction = d.WarpFraction
|
||||
}
|
||||
if c.ResolutionM <= 0 {
|
||||
c.ResolutionM = d.ResolutionM
|
||||
}
|
||||
if c.ContinentalFraction <= 0 {
|
||||
c.ContinentalFraction = d.ContinentalFraction
|
||||
}
|
||||
if c.ObliqueDeg <= 0 || c.ObliqueDeg >= 90 {
|
||||
c.ObliqueDeg = d.ObliqueDeg
|
||||
}
|
||||
return c
|
||||
}
|
||||
|
||||
// Plate is one rigid piece of the lithosphere.
|
||||
type Plate struct {
|
||||
ID int `json:"id"`
|
||||
|
||||
// SiteXM, SiteYM is the Voronoi site in world metres, and Weight is what makes plates different sizes.
|
||||
SiteXM float64 `json:"site_x_m"`
|
||||
SiteYM float64 `json:"site_y_m"`
|
||||
Weight float64 `json:"weight"`
|
||||
|
||||
// CentroidXM, CentroidYM is the plate's centre of area, measured the short way round the cylinder. It is
|
||||
// where the plate turns about, and it is the one position a painted plate has - a painting has no site.
|
||||
CentroidXM float64 `json:"centroid_x_m"`
|
||||
CentroidYM float64 `json:"centroid_y_m"`
|
||||
|
||||
// The motion, in metres a year: a translation plus a rotation about a pole in the map plane. The pole is
|
||||
// always the centroid; it is stored rather than derived so that VelocityAt needs nothing but the plate.
|
||||
TransXM float64 `json:"trans_x_m_yr"`
|
||||
TransYM float64 `json:"trans_y_m_yr"`
|
||||
PoleXM float64 `json:"pole_x_m"`
|
||||
PoleYM float64 `json:"pole_y_m"`
|
||||
OmegaRadYr float64 `json:"omega_rad_yr"`
|
||||
|
||||
// Continental is read from the painting rather than drawn from the seed: see the package comment.
|
||||
Continental bool `json:"continental"`
|
||||
LandFraction float64 `json:"land_fraction"`
|
||||
|
||||
// AreaCells is the plate's size on the tectonic grid, which is what decides who overrides whom when two
|
||||
// oceanic plates converge.
|
||||
AreaCells int `json:"area_cells"`
|
||||
}
|
||||
|
||||
// VelocityAt is the plate's motion at a world point, in metres a year.
|
||||
//
|
||||
// The lever arm is measured the short way round the cylinder. Without that a plate whose pole sits just east
|
||||
// of the seam would spin the wrong way for every point just west of it, and the boundary running through the
|
||||
// seam would be classified as convergent on one side and divergent on the other - the one bug this whole
|
||||
// coordinate system exists to make impossible.
|
||||
func (pl Plate) VelocityAt(p world.Planet, xM, yM float64) (vx, vy float64) {
|
||||
rx := wrapDelta(xM-pl.PoleXM, p.CircumferenceM())
|
||||
ry := yM - pl.PoleYM
|
||||
return pl.TransXM - pl.OmegaRadYr*ry, pl.TransYM + pl.OmegaRadYr*rx
|
||||
}
|
||||
|
||||
// SpeedMYr is how fast the plate is going at its own site, which is the number worth printing.
|
||||
func (pl Plate) SpeedMYr(p world.Planet) float64 {
|
||||
vx, vy := pl.VelocityAt(p, pl.SiteXM, pl.SiteYM)
|
||||
return math.Hypot(vx, vy)
|
||||
}
|
||||
|
||||
// Model is a planet's tectonics: the plates, the grid they were rasterised on, and the boundaries between
|
||||
// them.
|
||||
type Model struct {
|
||||
P world.Planet `json:"-"`
|
||||
Cfg Config `json:"config"`
|
||||
|
||||
Plates []Plate `json:"plates"`
|
||||
|
||||
// The tectonic grid. GCellM is derived rather than taken: it is the circumference divided by a whole
|
||||
// number of columns, so the grid wraps exactly and a boundary crossing the seam is an ordinary one.
|
||||
GW int `json:"-"`
|
||||
GH int `json:"-"`
|
||||
GCellM float64 `json:"grid_cell_m"`
|
||||
|
||||
// Cell is the plate id at every tectonic cell, row-major, X cyclic.
|
||||
Cell []int16 `json:"-"`
|
||||
|
||||
// Boundaries is the whole planet's set, in world metres.
|
||||
Boundaries []Boundary `json:"boundaries"`
|
||||
}
|
||||
|
||||
// GridXM and GridYM are the world position of a tectonic cell's centre. Y runs from the top of the polar
|
||||
// pad, so a grid row and a planet row mean the same place.
|
||||
func (m *Model) GridXM(gx int) float64 { return (float64(gx) + 0.5) * m.GCellM }
|
||||
func (m *Model) GridYM(gy int) float64 { return m.P.YM(0) + (float64(gy)+0.5)*m.GCellM }
|
||||
|
||||
// GridIdx wraps X and clamps Y, the same way world.Planet.Idx does.
|
||||
func (m *Model) GridIdx(gx, gy int) int {
|
||||
gx = ((gx % m.GW) + m.GW) % m.GW
|
||||
if gy < 0 {
|
||||
gy = 0
|
||||
} else if gy >= m.GH {
|
||||
gy = m.GH - 1
|
||||
}
|
||||
return gy*m.GW + gx
|
||||
}
|
||||
|
||||
// PlateAt is which plate owns a world position.
|
||||
func (m *Model) PlateAt(xM, yM float64) int {
|
||||
gx := int(math.Floor(xM / m.GCellM))
|
||||
gy := int(math.Floor((yM - m.P.YM(0)) / m.GCellM))
|
||||
return int(m.Cell[m.GridIdx(gx, gy)])
|
||||
}
|
||||
|
||||
// Build draws a planet's plates and the boundaries between them, once, deterministically from the seed.
|
||||
//
|
||||
// land reports whether a world position is painted land. It is a callback rather than a raster so that this
|
||||
// package knows nothing about templates: what it needs from the painting is one bit, and asking for it this
|
||||
// way also means the caller decides how the land mask is sampled.
|
||||
func Build(p world.Planet, seed int64, cfg Config, land func(xM, yM float64) bool) (*Model, error) {
|
||||
cfg = cfg.withDefaults()
|
||||
if cfg.Count < 2 {
|
||||
return nil, fmt.Errorf("a planet in %d plate(s) has no boundaries", cfg.Count)
|
||||
}
|
||||
|
||||
circ := p.CircumferenceM()
|
||||
gw := int(circ/cfg.ResolutionM + 0.5)
|
||||
if gw < cfg.Count*4 {
|
||||
gw = cfg.Count * 4
|
||||
}
|
||||
gcell := circ / float64(gw)
|
||||
gh := int(float64(p.H)*p.CellM/gcell + 0.5)
|
||||
if gh < 2 {
|
||||
gh = 2
|
||||
}
|
||||
|
||||
m := &Model{P: p, Cfg: cfg, GW: gw, GH: gh, GCellM: gcell}
|
||||
m.Plates = placeSites(p, seed, cfg, gh, gcell)
|
||||
giveMotion(p, seed, cfg, m.Plates)
|
||||
m.Cell = partition(m, seed)
|
||||
m.measure(land)
|
||||
m.Boundaries = m.buildBoundaries()
|
||||
return m, nil
|
||||
}
|
||||
|
||||
// warpFineGain is how strong the second warp octave is against the first. Held well below a half: past that
|
||||
// the displacement folds back on itself and the partition grows islands of one plate inside another, which
|
||||
// is a nonsense the boundary tracer would faithfully chain into a ring.
|
||||
const warpFineGain = 0.4
|
||||
|
||||
// spacingM is the mean distance between neighbouring sites: the length every other length in this package is
|
||||
// a fraction of.
|
||||
func spacingM(circ, heightM float64, count int) float64 {
|
||||
return math.Sqrt(circ * heightM / float64(count))
|
||||
}
|
||||
|
||||
// placeSites scatters the plate centres, refusing any that lands on top of another.
|
||||
//
|
||||
// Rejection rather than relaxation. Lloyd's algorithm would give an even, hexagonal net, which is a worse
|
||||
// answer than this one: plates are not even, and the interesting boundary geometry - a small plate wedged
|
||||
// between two large ones, a long thin one - comes from exactly the irregularity relaxation removes. The
|
||||
// minimum separation is only there to stop two sites coinciding, which produces a sliver no boundary tracer
|
||||
// can chain.
|
||||
func placeSites(p world.Planet, seed int64, cfg Config, gh int, gcell float64) []Plate {
|
||||
s := noise.NewSource(seed, srcSites)
|
||||
circ := p.CircumferenceM()
|
||||
heightM := float64(gh) * gcell
|
||||
top := p.YM(0)
|
||||
minSep := 0.5 * spacingM(circ, heightM, cfg.Count)
|
||||
|
||||
out := make([]Plate, 0, cfg.Count)
|
||||
for len(out) < cfg.Count {
|
||||
for try := 0; ; try++ {
|
||||
x := s.Float() * circ
|
||||
y := top + s.Float()*heightM
|
||||
// After enough refusals the separation is the thing that is wrong, not the draw, so it is given
|
||||
// up rather than looped on for ever - a count near the area's limit can have no valid position
|
||||
// left at all.
|
||||
if try < 64 && tooClose(out, p, x, y, minSep) {
|
||||
continue
|
||||
}
|
||||
out = append(out, Plate{
|
||||
ID: len(out),
|
||||
SiteXM: x,
|
||||
SiteYM: y,
|
||||
Weight: 1 + (cfg.SizeSpread-1)*s.Float(),
|
||||
})
|
||||
break
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func tooClose(out []Plate, p world.Planet, x, y, minSep float64) bool {
|
||||
circ := p.CircumferenceM()
|
||||
for i := range out {
|
||||
dx := wrapDelta(x-out[i].SiteXM, circ)
|
||||
dy := y - out[i].SiteYM
|
||||
if math.Hypot(dx, dy) < minSep {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// giveMotion draws each plate's translation and its spin.
|
||||
//
|
||||
// **Every plate turns about its own centre of area**, which measure fills in once the partition exists. An
|
||||
// earlier version put the pole a plate-width off to one side, on the reasoning that a pole at the middle
|
||||
// would cancel symmetrically and leave the margins as uniform as a pure translation does. That reasoning is
|
||||
// wrong: the relative velocity at a contact is
|
||||
//
|
||||
// (T_a - T_b) + omega_a x (x - c_a) - omega_b x (x - c_b)
|
||||
//
|
||||
// which varies along the contact for any pole at all, and a pole at the centre puts the *largest* rotational
|
||||
// contribution out at the margins, where it is wanted. The offset pole bought nothing and cost something
|
||||
// real: it cannot be written into a painted legend, where an author says "this plate is also turning
|
||||
// clockwise" and means about its own middle. A proposal therefore did not read back as the planet it was
|
||||
// proposed from, which is what TestAProposalReadsBackAsTheSamePlanet caught.
|
||||
func giveMotion(p world.Planet, seed int64, cfg Config, ps []Plate) {
|
||||
s := noise.NewSource(seed, srcMotion)
|
||||
circ := p.CircumferenceM()
|
||||
spacing := spacingM(circ, p.HeightM(), cfg.Count)
|
||||
for i := range ps {
|
||||
speed := s.Range(cfg.VelocityCmYr[0], cfg.VelocityCmYr[1]) / 100 // cm/yr to m/yr
|
||||
dir := s.Float() * 2 * math.Pi
|
||||
ps[i].TransXM = math.Cos(dir) * speed
|
||||
ps[i].TransYM = math.Sin(dir) * speed
|
||||
|
||||
// The spin is set so that the rotational speed one spacing from the pole is SpinFraction of the
|
||||
// translation speed: the fraction means the same thing whatever the planet's size.
|
||||
sign := 1.0
|
||||
if s.Float() < 0.5 {
|
||||
sign = -1
|
||||
}
|
||||
if spacing > 0 {
|
||||
ps[i].OmegaRadYr = sign * cfg.Spin() * speed / spacing
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// partition rasterises the plates onto the tectonic grid.
|
||||
//
|
||||
// A multiplicatively weighted Voronoi - nearest site by distance/weight - through a warped query point. The
|
||||
// warp is what stops the result being a polygon net: it is sampled from a lattice in world coordinates, so
|
||||
// two decompositions of the same planet warp the same point the same way, and its wavelength is deliberately
|
||||
// long compared with the plate spacing, because a boundary that wiggled at a ten-kilometre wavelength would
|
||||
// be a coastline rather than a plate margin.
|
||||
func partition(m *Model, seed int64) []int16 {
|
||||
p := m.P
|
||||
circ := p.CircumferenceM()
|
||||
spacing := spacingM(circ, p.HeightM(), m.Cfg.Count)
|
||||
|
||||
ws := noise.NewSource(seed, srcWarp)
|
||||
// Two octaves. Both cell counts are whole numbers of the noise period, because noise.Lattice.Sample wraps
|
||||
// modulo its own count and anything else is a discontinuity down one meridian.
|
||||
coarse := int(p.NoisePeriodM/spacing + 0.5)
|
||||
if coarse < 1 {
|
||||
coarse = 1
|
||||
}
|
||||
fine := coarse * 3
|
||||
wx := noise.NewLattice(coarse, ws)
|
||||
wy := noise.NewLattice(coarse, ws)
|
||||
fx := noise.NewLattice(fine, ws)
|
||||
fy := noise.NewLattice(fine, ws)
|
||||
amp := m.Cfg.WarpFraction * spacing
|
||||
|
||||
out := make([]int16, m.GW*m.GH)
|
||||
for gy := 0; gy < m.GH; gy++ {
|
||||
yM := m.GridYM(gy)
|
||||
v := yM / p.NoisePeriodM * float64(coarse)
|
||||
fv := yM / p.NoisePeriodM * float64(fine)
|
||||
row := gy * m.GW
|
||||
for gx := 0; gx < m.GW; gx++ {
|
||||
xM := m.GridXM(gx)
|
||||
u := xM / p.NoisePeriodM * float64(coarse)
|
||||
fu := xM / p.NoisePeriodM * float64(fine)
|
||||
qx := xM + ((float64(wx.Sample(u, v))*2-1)+(float64(fx.Sample(fu, fv))*2-1)*warpFineGain)*amp
|
||||
qy := yM + ((float64(wy.Sample(u, v))*2-1)+(float64(fy.Sample(fu, fv))*2-1)*warpFineGain)*amp
|
||||
|
||||
best, bestID := math.Inf(1), 0
|
||||
for i := range m.Plates {
|
||||
pl := &m.Plates[i]
|
||||
dx := wrapDelta(qx-pl.SiteXM, circ)
|
||||
dy := qy - pl.SiteYM
|
||||
d := math.Hypot(dx, dy) / pl.Weight
|
||||
if d < best {
|
||||
best, bestID = d, pl.ID
|
||||
}
|
||||
}
|
||||
out[row+gx] = int16(bestID)
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
// measure walks the partition once and fills in everything that can only be known after it exists: each
|
||||
// plate's area, how much of it the author painted as land, and where its centre is.
|
||||
//
|
||||
// Painted rows only, for the land fraction. The polar pad is synthetic ocean that no class was ever painted
|
||||
// on, so counting it would drag every plate that reaches a pole towards oceanic for a reason that is
|
||||
// scaffolding rather than geography. The area and the centre do count the pad, because a plate really does
|
||||
// extend over it.
|
||||
//
|
||||
// **The centre is a circular mean in X.** A plate painted or drawn across the meridian has cells at both ends
|
||||
// of the raster, and an arithmetic mean of those columns puts its centre on the far side of the planet - and
|
||||
// with it the pole the whole plate rotates about, which would make its velocity field nonsense and every
|
||||
// margin around it wrong. This is the same rule as world.WrapX and Plate.VelocityAt's lever arm: the short
|
||||
// way round is the only way round.
|
||||
func (m *Model) measure(land func(xM, yM float64) bool) {
|
||||
n := len(m.Plates)
|
||||
landCells := make([]int, n)
|
||||
paintedCells := make([]int, n)
|
||||
sumSin := make([]float64, n)
|
||||
sumCos := make([]float64, n)
|
||||
sumY := make([]float64, n)
|
||||
|
||||
circ := m.P.CircumferenceM()
|
||||
for gy := range m.GH {
|
||||
yM := m.GridYM(gy)
|
||||
painted := yM >= 0 && yM < m.P.HeightM()
|
||||
row := gy * m.GW
|
||||
for gx := range m.GW {
|
||||
id := int(m.Cell[row+gx])
|
||||
pl := &m.Plates[id]
|
||||
pl.AreaCells++
|
||||
|
||||
xM := m.GridXM(gx)
|
||||
ang := 2 * math.Pi * xM / circ
|
||||
sumSin[id] += math.Sin(ang)
|
||||
sumCos[id] += math.Cos(ang)
|
||||
sumY[id] += yM
|
||||
|
||||
if !painted {
|
||||
continue
|
||||
}
|
||||
paintedCells[id]++
|
||||
if land != nil && land(xM, yM) {
|
||||
landCells[id]++
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for i := range m.Plates {
|
||||
pl := &m.Plates[i]
|
||||
if paintedCells[i] > 0 {
|
||||
pl.LandFraction = float64(landCells[i]) / float64(paintedCells[i])
|
||||
}
|
||||
pl.Continental = pl.LandFraction >= m.Cfg.ContinentalFraction
|
||||
if pl.AreaCells > 0 {
|
||||
pl.CentroidXM, pl.CentroidYM = centroid(sumSin[i], sumCos[i], sumY[i], pl.AreaCells, circ)
|
||||
}
|
||||
// Every plate turns about its own centre of area. See giveMotion for why it is not somewhere else.
|
||||
pl.PoleXM, pl.PoleYM = pl.CentroidXM, pl.CentroidYM
|
||||
}
|
||||
}
|
||||
|
||||
// centroid turns the accumulated sums into a position, taking X the short way round the cylinder.
|
||||
func centroid(sumSin, sumCos, sumY float64, cells int, circ float64) (xM, yM float64) {
|
||||
ang := math.Atan2(sumSin, sumCos)
|
||||
if ang < 0 {
|
||||
ang += 2 * math.Pi
|
||||
}
|
||||
return ang / (2 * math.Pi) * circ, sumY / float64(cells)
|
||||
}
|
||||
|
||||
// wrapDelta brings a difference in X into -circ/2 .. +circ/2: the short way round the cylinder.
|
||||
func wrapDelta(d, circ float64) float64 {
|
||||
if circ <= 0 {
|
||||
return d
|
||||
}
|
||||
d = math.Mod(d, circ)
|
||||
if d > circ/2 {
|
||||
d -= circ
|
||||
} else if d < -circ/2 {
|
||||
d += circ
|
||||
}
|
||||
return d
|
||||
}
|
||||
Reference in New Issue
Block a user