rouggy
7d33379fe1
The store shipped without its main source. Locators came only from this station's own WSJT-X decodes, which is what the whole MQTT discussion was about. PSK Reporter now feeds it through a new OnGrid callback, fired before any geographic filtering: what the store wants is "which square is this callsign in", and that is true whoever happened to hear the report. The subscription filters on the RECEIVER's square, a level the v2 topic exposes. Measured on the live feed: the four opening bands unfiltered are 83 messages a second, of which roughly one in a hundred survived the NearKm test that already existed here — the rest was received, TLS-decrypted, JSON-parsed and discarded. One ring of squares is 0.2 to 1.2 a second. By square rather than by DXCC, which was the obvious alternative: one country measured 1.2 messages a second (OH) against 72.5 (K) on a single band, because a DXCC can be a continent. By square the same measurement is 0.2 to 1.2, so the load follows distance — what the feed is actually about — and is the same for every operator. Grid chasing subscribes with the "+" band wildcard, so one subscription per square covers every band instead of one per band per square. The store gains a source column (decode | mqtt), migrated in place on an existing file.
121 lines
3.5 KiB
Go
121 lines
3.5 KiB
Go
// Package geo is the one place that turns Maidenhead locators into positions,
|
|
// and positions into distances and bearings.
|
|
//
|
|
// It exists because there were about to be three copies. These functions lived
|
|
// in package main, which the internal packages cannot import, so the PSK
|
|
// Reporter watcher had its geometry injected from main and the web publisher
|
|
// was about to grow its own. A bearing that disagrees with itself between two
|
|
// panels is the kind of fault nobody reports, because each screen looks
|
|
// plausible on its own.
|
|
package geo
|
|
|
|
import (
|
|
"math"
|
|
"strings"
|
|
)
|
|
|
|
// GridToLatLon parses a Maidenhead locator (4 or 6 characters) and returns the
|
|
// centre of that square in degrees. ok=false on malformed input.
|
|
func GridToLatLon(grid string) (lat, lon float64, ok bool) {
|
|
g := strings.ToUpper(strings.TrimSpace(grid))
|
|
if len(g) < 4 {
|
|
return 0, 0, false
|
|
}
|
|
A := g[0] - 'A'
|
|
B := g[1] - 'A'
|
|
C := g[2] - '0'
|
|
D := g[3] - '0'
|
|
if A > 17 || B > 17 || C > 9 || D > 9 {
|
|
return 0, 0, false
|
|
}
|
|
lon = -180 + float64(A)*20 + float64(C)*2
|
|
lat = -90 + float64(B)*10 + float64(D)*1
|
|
if len(g) >= 6 {
|
|
E := g[4] - 'A'
|
|
F := g[5] - 'A'
|
|
if E <= 23 && F <= 23 {
|
|
lon += float64(E)*(5.0/60.0) + 2.5/60.0
|
|
lat += float64(F)*(2.5/60.0) + 1.25/60.0
|
|
return lat, lon, true
|
|
}
|
|
}
|
|
// 4-character locator: aim at the centre of the square.
|
|
lon += 1
|
|
lat += 0.5
|
|
return lat, lon, true
|
|
}
|
|
|
|
// HaversineKm returns the great-circle distance between two positions in
|
|
// kilometres. Mean Earth radius 6371 km.
|
|
func HaversineKm(lat1, lon1, lat2, lon2 float64) float64 {
|
|
const R = 6371.0
|
|
rad := math.Pi / 180.0
|
|
dLat := (lat2 - lat1) * rad
|
|
dLon := (lon2 - lon1) * rad
|
|
a := math.Sin(dLat/2)*math.Sin(dLat/2) +
|
|
math.Cos(lat1*rad)*math.Cos(lat2*rad)*math.Sin(dLon/2)*math.Sin(dLon/2)
|
|
return R * 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
|
|
}
|
|
|
|
// DistanceBetweenGrids is the distance in kilometres between two locators,
|
|
// ok=false when either cannot be parsed.
|
|
func DistanceBetweenGrids(a, b string) (km float64, ok bool) {
|
|
lat1, lon1, ok1 := GridToLatLon(a)
|
|
lat2, lon2, ok2 := GridToLatLon(b)
|
|
if !ok1 || !ok2 {
|
|
return 0, false
|
|
}
|
|
return HaversineKm(lat1, lon1, lat2, lon2), true
|
|
}
|
|
|
|
// LatLonToGrid returns the 4-character Maidenhead square for a position.
|
|
func LatLonToGrid(lat, lon float64) string {
|
|
lon = math.Mod(lon+180, 360)
|
|
if lon < 0 {
|
|
lon += 360
|
|
}
|
|
lat = lat + 90
|
|
if lat < 0 {
|
|
lat = 0
|
|
} else if lat > 180 {
|
|
lat = 180
|
|
}
|
|
return string([]byte{
|
|
byte('A' + int(lon/20)),
|
|
byte('A' + int(lat/10)),
|
|
byte('0' + int(math.Mod(lon, 20)/2)),
|
|
byte('0' + int(math.Mod(lat, 10)/1)),
|
|
})
|
|
}
|
|
|
|
// NeighbourGrids returns the square holding (lat, lon) and the ring of squares
|
|
// around it — 9 squares for ring 1, 25 for ring 2.
|
|
//
|
|
// Used to filter the PSK Reporter feed at the BROKER rather than in OpsLog. A
|
|
// square is about 111 km tall and 150 km wide at mid latitudes, so one ring is
|
|
// roughly the 300 km "around here" the feed already meant, and the traffic that
|
|
// used to be received and discarded is never sent.
|
|
func NeighbourGrids(lat, lon float64, ring int) []string {
|
|
if ring < 0 {
|
|
ring = 0
|
|
}
|
|
seen := map[string]bool{}
|
|
out := []string{}
|
|
for dLat := -ring; dLat <= ring; dLat++ {
|
|
for dLon := -ring; dLon <= ring; dLon++ {
|
|
// One square step: 1° of latitude, 2° of longitude.
|
|
la := lat + float64(dLat)
|
|
lo := lon + float64(dLon)*2
|
|
if la > 90 || la < -90 {
|
|
continue // past a pole there is no square, not a wrapped one
|
|
}
|
|
g := LatLonToGrid(la, lo)
|
|
if !seen[g] {
|
|
seen[g] = true
|
|
out = append(out, g)
|
|
}
|
|
}
|
|
}
|
|
return out
|
|
}
|