79 lines
3.3 KiB
Go
79 lines
3.3 KiB
Go
|
package basic
|
||
|
|
|
||
|
|
import (
|
||
|
|
"math"
|
||
|
|
"time"
|
||
|
|
)
|
||
|
|
|
||
|
|
// occultationStationDensifyContours applies the map's projection metric after
|
||
|
|
// station correction. The correction can move adjacent geocentric samples by
|
||
|
|
// tens of kilometres, so a contour that was dense before correction can still
|
||
|
|
// contain a long Web Mercator chord. A spatial arclength plane selects the
|
||
|
|
// midpoint branch even where time reverses and a fixed-time solve is singular.
|
||
|
|
// The refined curve is split again at time folds for the public time contract.
|
||
|
|
func occultationStationDensifyContours(
|
||
|
|
contours [][]OccultationPathPoint,
|
||
|
|
cache *occultationRiseSetEvaluationCache,
|
||
|
|
location *time.Location,
|
||
|
|
) [][]OccultationPathPoint {
|
||
|
|
if len(contours) == 0 || cache == nil {
|
||
|
|
return contours
|
||
|
|
}
|
||
|
|
const (
|
||
|
|
targetSpacingKM = 30.0
|
||
|
|
maxDepth = 10
|
||
|
|
)
|
||
|
|
result := make([][]OccultationPathPoint, 0, len(contours))
|
||
|
|
for _, contour := range contours {
|
||
|
|
if len(contour) < 2 {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
var refine func(OccultationPathPoint, OccultationPathPoint, int, *[]OccultationPathPoint)
|
||
|
|
refine = func(start, end OccultationPathPoint, depth int, output *[]OccultationPathPoint) {
|
||
|
|
if depth >= maxDepth || occultationStationProjectedSpacingKM(start, end) <= targetSpacingKM {
|
||
|
|
*output = append(*output, end)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
startTT, endTT := centerTimeTT(start.Time), centerTimeTT(end.Time)
|
||
|
|
chord := [3]float64{math.Remainder(end.Longitude-start.Longitude, 360), end.Latitude - start.Latitude,
|
||
|
|
(endTT - startTT) * occultationStationEnvelopeTimeScale}
|
||
|
|
length := math.Sqrt(dotSolarEclipse3(chord, chord))
|
||
|
|
if length <= 1e-12 {
|
||
|
|
*output = append(*output, end)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
predictor := [3]float64{start.Longitude + chord[0]/2, start.Latitude + chord[1]/2, chord[2] / 2}
|
||
|
|
for index := range chord {
|
||
|
|
chord[index] /= length
|
||
|
|
}
|
||
|
|
midpoint, _, ok := occultationStationCorrectEnvelopeArc(predictor, chord, startTT, cache,
|
||
|
|
occultationStationEnvelopeModel{kind: occultationStationContactEnvelope}, (start.WidthKM+end.WidthKM)/2, location)
|
||
|
|
if ok && occultationPathDistanceKM(start, midpoint.point) < occultationPathDistanceKM(start, end) &&
|
||
|
|
occultationPathDistanceKM(midpoint.point, end) < occultationPathDistanceKM(start, end) {
|
||
|
|
refine(start, midpoint.point, depth+1, output)
|
||
|
|
refine(midpoint.point, end, depth+1, output)
|
||
|
|
return
|
||
|
|
}
|
||
|
|
// Leave a failed local solve untouched. Retrying with an unrelated
|
||
|
|
// branch would be less accurate than retaining the source sample.
|
||
|
|
*output = append(*output, end)
|
||
|
|
}
|
||
|
|
refined := []OccultationPathPoint{contour[0]}
|
||
|
|
for index := 1; index < len(contour); index++ {
|
||
|
|
refine(refined[len(refined)-1], contour[index], 0, &refined)
|
||
|
|
}
|
||
|
|
result = append(result, occultationStationSplitEnvelopeAtTimeFolds(refined)...)
|
||
|
|
}
|
||
|
|
return result
|
||
|
|
}
|
||
|
|
|
||
|
|
func occultationStationProjectedSpacingKM(first, second OccultationPathPoint) float64 {
|
||
|
|
const maxLatitude = 85.05112878
|
||
|
|
firstLatitude := math.Max(-maxLatitude, math.Min(maxLatitude, first.Latitude)) * rad
|
||
|
|
secondLatitude := math.Max(-maxLatitude, math.Min(maxLatitude, second.Latitude)) * rad
|
||
|
|
longitudeDelta := math.Remainder(second.Longitude-first.Longitude, 360) * rad
|
||
|
|
firstY := math.Log(math.Tan(math.Pi/4 + firstLatitude/2))
|
||
|
|
secondY := math.Log(math.Tan(math.Pi/4 + secondLatitude/2))
|
||
|
|
return 6378.1366 * math.Hypot(longitudeDelta, secondY-firstY)
|
||
|
|
}
|