873 lines
28 KiB
Go
873 lines
28 KiB
Go
|
package occultationgeo
|
||
|
|
|
||
|
|
import (
|
||
|
|
"fmt"
|
||
|
|
"math"
|
||
|
|
|
||
|
|
"b612.me/astro/basic"
|
||
|
|
"b612.me/astro/internal/geodata"
|
||
|
|
)
|
||
|
|
|
||
|
|
func footprintClosedSweepPolygons(
|
||
|
|
footprints []basic.OccultationFootprint,
|
||
|
|
) [][]geodata.GeoPoint {
|
||
|
|
polygons := make([][]geodata.GeoPoint, 0, len(footprints))
|
||
|
|
var previous []geodata.GeoPoint
|
||
|
|
for _, footprint := range footprints {
|
||
|
|
if !footprint.Closed {
|
||
|
|
previous = nil
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
ring, ok := footprintClosedSweepRing(footprint)
|
||
|
|
if !ok {
|
||
|
|
previous = nil
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
ring = resampleClosedFootprintRing(ring, closedFootprintSweepPoints)
|
||
|
|
if len(ring) < 4 {
|
||
|
|
previous = nil
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if len(previous) == 0 {
|
||
|
|
previous = ring
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
ring = alignClosedFootprintRing(previous, ring)
|
||
|
|
if footprintClosedSweepMaximumStep(previous, ring) > closedFootprintSweepMaxStepKM {
|
||
|
|
previous = ring
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
polygons = append(polygons, footprintClosedSweepCells(previous, ring)...)
|
||
|
|
previous = ring
|
||
|
|
}
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintClosedSweepRing(
|
||
|
|
footprint basic.OccultationFootprint,
|
||
|
|
) ([]geodata.GeoPoint, bool) {
|
||
|
|
boundary := openFootprintRing(geodata.JoinPolylineSegments(footprintGeoBoundaries(footprint)))
|
||
|
|
if len(boundary) >= 4 {
|
||
|
|
return boundary, true
|
||
|
|
}
|
||
|
|
for _, source := range footprint.Polygons {
|
||
|
|
if len(source) < 4 || occultationInteriorPolygon(source, footprint.InteriorPolygons) {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
ring := make([]geodata.GeoPoint, len(source))
|
||
|
|
for index, point := range source {
|
||
|
|
ring[index] = geodata.GeoPoint{Longitude: point.Longitude, Latitude: point.Latitude}
|
||
|
|
}
|
||
|
|
ring = openFootprintRing(ring)
|
||
|
|
if len(ring) >= 4 {
|
||
|
|
return ring, true
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return nil, false
|
||
|
|
}
|
||
|
|
|
||
|
|
func resampleClosedFootprintRing(
|
||
|
|
ring []geodata.GeoPoint,
|
||
|
|
count int,
|
||
|
|
) []geodata.GeoPoint {
|
||
|
|
ring = openFootprintRing(ring)
|
||
|
|
if count <= 0 || len(ring) <= count {
|
||
|
|
return append([]geodata.GeoPoint(nil), ring...)
|
||
|
|
}
|
||
|
|
result := make([]geodata.GeoPoint, count)
|
||
|
|
for index := range result {
|
||
|
|
result[index] = ring[index*len(ring)/count]
|
||
|
|
}
|
||
|
|
return result
|
||
|
|
}
|
||
|
|
|
||
|
|
func alignClosedFootprintRing(
|
||
|
|
previous, current []geodata.GeoPoint,
|
||
|
|
) []geodata.GeoPoint {
|
||
|
|
if len(previous) == 0 || len(current) == 0 || len(previous) != len(current) {
|
||
|
|
return append([]geodata.GeoPoint(nil), current...)
|
||
|
|
}
|
||
|
|
bestShift := 0
|
||
|
|
bestReversed := false
|
||
|
|
bestScore := math.Inf(1)
|
||
|
|
for _, reversed := range []bool{false, true} {
|
||
|
|
candidate := append([]geodata.GeoPoint(nil), current...)
|
||
|
|
if reversed {
|
||
|
|
reverseGeoPointRing(candidate)
|
||
|
|
}
|
||
|
|
for shift := 0; shift < len(candidate); shift++ {
|
||
|
|
score := closedFootprintRingAlignmentScore(previous, candidate, shift)
|
||
|
|
if score < bestScore {
|
||
|
|
bestScore = score
|
||
|
|
bestShift = shift
|
||
|
|
bestReversed = reversed
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
aligned := append([]geodata.GeoPoint(nil), current...)
|
||
|
|
if bestReversed {
|
||
|
|
reverseGeoPointRing(aligned)
|
||
|
|
}
|
||
|
|
return rotateClosedFootprintRing(aligned, bestShift)
|
||
|
|
}
|
||
|
|
|
||
|
|
func reverseGeoPointRing(points []geodata.GeoPoint) {
|
||
|
|
for left, right := 0, len(points)-1; left < right; left, right = left+1, right-1 {
|
||
|
|
points[left], points[right] = points[right], points[left]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func closedFootprintRingAlignmentScore(
|
||
|
|
previous, current []geodata.GeoPoint,
|
||
|
|
shift int,
|
||
|
|
) float64 {
|
||
|
|
samples := 16
|
||
|
|
if len(previous) < samples {
|
||
|
|
samples = len(previous)
|
||
|
|
}
|
||
|
|
score := 0.0
|
||
|
|
for sample := 0; sample < samples; sample++ {
|
||
|
|
index := sample * len(previous) / samples
|
||
|
|
score += geoDistanceKM(previous[index], current[(index+shift)%len(current)])
|
||
|
|
}
|
||
|
|
return score
|
||
|
|
}
|
||
|
|
|
||
|
|
func rotateClosedFootprintRing(
|
||
|
|
points []geodata.GeoPoint,
|
||
|
|
shift int,
|
||
|
|
) []geodata.GeoPoint {
|
||
|
|
result := make([]geodata.GeoPoint, len(points))
|
||
|
|
for index := range result {
|
||
|
|
result[index] = points[(index+shift)%len(points)]
|
||
|
|
}
|
||
|
|
return result
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintClosedSweepMaximumStep(
|
||
|
|
first, second []geodata.GeoPoint,
|
||
|
|
) float64 {
|
||
|
|
count := len(first)
|
||
|
|
if len(second) < count {
|
||
|
|
count = len(second)
|
||
|
|
}
|
||
|
|
maximum := 0.0
|
||
|
|
for index := 0; index < count; index++ {
|
||
|
|
maximum = math.Max(maximum, geoDistanceKM(first[index], second[index]))
|
||
|
|
}
|
||
|
|
return maximum
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintClosedSweepCells(
|
||
|
|
first, second []geodata.GeoPoint,
|
||
|
|
) [][]geodata.GeoPoint {
|
||
|
|
count := len(first)
|
||
|
|
if len(second) < count {
|
||
|
|
count = len(second)
|
||
|
|
}
|
||
|
|
polygons := make([][]geodata.GeoPoint, 0, count)
|
||
|
|
for index := 0; index < count; index++ {
|
||
|
|
next := (index + 1) % count
|
||
|
|
polygon := []geodata.GeoPoint{
|
||
|
|
first[index],
|
||
|
|
second[index],
|
||
|
|
second[next],
|
||
|
|
first[next],
|
||
|
|
first[index],
|
||
|
|
}
|
||
|
|
if math.Abs(geoRingArea(polygon)) <= 1e-10 {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
polygons = append(polygons, polygon)
|
||
|
|
}
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
|
||
|
|
// footprintSweepSampleProbes 采样开放接触弧上的可见边界点作为覆盖见证探针。
|
||
|
|
func footprintSweepSampleProbes(footprints []basic.OccultationFootprint) [][]geodata.GeoPoint {
|
||
|
|
probes := make([][]geodata.GeoPoint, 0, len(footprints)*16)
|
||
|
|
for _, footprint := range footprints {
|
||
|
|
// Closed footprints are added separately as instantaneous caps. They do
|
||
|
|
// not belong to the open-boundary sweep, so checking them here would
|
||
|
|
// reject every valid sweep that contains a horizon-closed sample.
|
||
|
|
if footprint.Closed {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
for _, boundary := range footprint.Boundaries {
|
||
|
|
step := len(boundary) / 16
|
||
|
|
if step < 1 {
|
||
|
|
step = 1
|
||
|
|
}
|
||
|
|
for index := 0; index < len(boundary); index += step {
|
||
|
|
point := geodata.GeoPoint{Longitude: boundary[index].Longitude, Latitude: boundary[index].Latitude}
|
||
|
|
probes = append(probes, []geodata.GeoPoint{point})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return probes
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintSweepCoversSamples(
|
||
|
|
polygons [][]geodata.GeoPoint,
|
||
|
|
footprints []basic.OccultationFootprint,
|
||
|
|
) bool {
|
||
|
|
if len(polygons) == 0 {
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
probes := footprintSweepSampleProbes(footprints)
|
||
|
|
// At a high-latitude open/closed transition the sweep edge can coincide
|
||
|
|
// with a source tangent sample within floating-point error. A sub-kilometre
|
||
|
|
// tolerance accepts that shared physical edge without admitting a real
|
||
|
|
// branch gap. Ordinary-latitude stellar bands retain the strict check so a
|
||
|
|
// genuinely missing center-line segment cannot be hidden by the tolerance.
|
||
|
|
toleranceKM := 0.0
|
||
|
|
minimumAbsoluteLatitude := 90.0
|
||
|
|
allNorthern, allSouthern := true, true
|
||
|
|
for _, footprint := range footprints {
|
||
|
|
for _, boundary := range footprint.Boundaries {
|
||
|
|
for _, point := range boundary {
|
||
|
|
minimumAbsoluteLatitude = math.Min(minimumAbsoluteLatitude, math.Abs(point.Latitude))
|
||
|
|
allNorthern = allNorthern && point.Latitude >= 0
|
||
|
|
allSouthern = allSouthern && point.Latitude <= 0
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if minimumAbsoluteLatitude >= 40 && (allNorthern || allSouthern) {
|
||
|
|
toleranceKM = 1
|
||
|
|
}
|
||
|
|
return geodata.SphericalPolygonsContainPathsWithinKM(polygons, probes, true, toleranceKM)
|
||
|
|
}
|
||
|
|
|
||
|
|
// footprintVisibleUnionPolygons returns the sampled, horizon-closed visible
|
||
|
|
// area without replacing it by open contact-arc ribbons. It is used as a mask
|
||
|
|
// audit for polar sweeps: the source polygons are the only representation that
|
||
|
|
// carries the instantaneous Moon-above-horizon closure.
|
||
|
|
func footprintVisibleUnionPolygons(
|
||
|
|
footprints []basic.OccultationFootprint,
|
||
|
|
) [][]geodata.GeoPoint {
|
||
|
|
visibleFill := occultationVisibleFootprintFillOnly(footprints)
|
||
|
|
inputs := visibleFill
|
||
|
|
inputs = append(inputs, footprintStaticInteriorPolygons(footprints)...)
|
||
|
|
inputs = usableOccultationPolygons(inputs)
|
||
|
|
if len(inputs) == 0 {
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
merged, err := geodata.UnionPolygons(inputs)
|
||
|
|
if err != nil || len(merged) == 0 {
|
||
|
|
// The spherical union can reject one numerically open edge at a horizon
|
||
|
|
// transition even though the input footprints form a single temporal
|
||
|
|
// ribbon. Run the bounded touching merge on the usable source rings so a
|
||
|
|
// sub-60 km seam does not leak out as one polygon per time sample.
|
||
|
|
return mergeTouchingVisiblePolygons(inputs)
|
||
|
|
}
|
||
|
|
return mergeTouchingVisiblePolygons(merged)
|
||
|
|
}
|
||
|
|
|
||
|
|
func usableOccultationPolygons(polygons [][]geodata.GeoPoint) [][]geodata.GeoPoint {
|
||
|
|
result := make([][]geodata.GeoPoint, 0, len(polygons))
|
||
|
|
for _, polygon := range polygons {
|
||
|
|
open := openFootprintRing(polygon)
|
||
|
|
if len(open) < 3 || math.Abs(geoRingArea(open)) <= 1e-12 {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
result = append(result, polygon)
|
||
|
|
}
|
||
|
|
return result
|
||
|
|
}
|
||
|
|
|
||
|
|
// occultationUnitBounds 是环的三维单位向量包围盒（已含大圆弧外凸余量）。
|
||
|
|
type occultationUnitBounds struct {
|
||
|
|
minX, minY, minZ float64
|
||
|
|
maxX, maxY, maxZ float64
|
||
|
|
}
|
||
|
|
|
||
|
|
func occultationUnitVector(point geodata.GeoPoint) (float64, float64, float64) {
|
||
|
|
latitude := point.Latitude * math.Pi / 180
|
||
|
|
longitude := point.Longitude * math.Pi / 180
|
||
|
|
cosLatitude := math.Cos(latitude)
|
||
|
|
return cosLatitude * math.Cos(longitude), cosLatitude * math.Sin(longitude), math.Sin(latitude)
|
||
|
|
}
|
||
|
|
|
||
|
|
func occultationPolygonUnitBounds(polygon []geodata.GeoPoint) occultationUnitBounds {
|
||
|
|
bounds := occultationUnitBounds{
|
||
|
|
minX: math.Inf(1), minY: math.Inf(1), minZ: math.Inf(1),
|
||
|
|
maxX: math.Inf(-1), maxY: math.Inf(-1), maxZ: math.Inf(-1),
|
||
|
|
}
|
||
|
|
vectors := make([][3]float64, 0, len(polygon))
|
||
|
|
minimumCosine := 1.0
|
||
|
|
for _, point := range polygon {
|
||
|
|
x, y, z := occultationUnitVector(point)
|
||
|
|
vectors = append(vectors, [3]float64{x, y, z})
|
||
|
|
}
|
||
|
|
for index, vector := range vectors {
|
||
|
|
next := vectors[(index+1)%len(vectors)]
|
||
|
|
if cosine := vector[0]*next[0] + vector[1]*next[1] + vector[2]*next[2]; cosine < minimumCosine {
|
||
|
|
minimumCosine = cosine
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// 大圆弧中点会凸出端点坐标，按最长弧的半角放大包围盒，保证下界仍然成立。
|
||
|
|
scale := 1.0
|
||
|
|
if half := math.Sqrt(math.Max(0, (1+minimumCosine)/2)); half > 1e-9 {
|
||
|
|
scale = 1 / half
|
||
|
|
}
|
||
|
|
for _, vector := range vectors {
|
||
|
|
for axis, value := range vector {
|
||
|
|
high, low := value, value
|
||
|
|
if value > 0 {
|
||
|
|
high = value * scale
|
||
|
|
} else {
|
||
|
|
low = value * scale
|
||
|
|
}
|
||
|
|
switch axis {
|
||
|
|
case 0:
|
||
|
|
bounds.minX, bounds.maxX = math.Min(bounds.minX, low), math.Max(bounds.maxX, high)
|
||
|
|
case 1:
|
||
|
|
bounds.minY, bounds.maxY = math.Min(bounds.minY, low), math.Max(bounds.maxY, high)
|
||
|
|
default:
|
||
|
|
bounds.minZ, bounds.maxZ = math.Min(bounds.minZ, low), math.Max(bounds.maxZ, high)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return bounds
|
||
|
|
}
|
||
|
|
|
||
|
|
// occultationUnitBoundsNear 报告两包围盒的弦距下界是否可能小于 limitKM。
|
||
|
|
func occultationUnitBoundsNear(first, second occultationUnitBounds, limitKM float64) bool {
|
||
|
|
dx := math.Max(0, math.Max(first.minX-second.maxX, second.minX-first.maxX))
|
||
|
|
dy := math.Max(0, math.Max(first.minY-second.maxY, second.minY-first.maxY))
|
||
|
|
dz := math.Max(0, math.Max(first.minZ-second.maxZ, second.minZ-first.maxZ))
|
||
|
|
// 大圆距离不小于弦长，因此弦距下界可以作为 60 km 近邻判定的必要条件。
|
||
|
|
return EarthRadiusKM*math.Sqrt(dx*dx+dy*dy+dz*dz) <= limitKM
|
||
|
|
}
|
||
|
|
|
||
|
|
func mergeTouchingVisiblePolygons(polygons [][]geodata.GeoPoint) [][]geodata.GeoPoint {
|
||
|
|
const (
|
||
|
|
// Boolean operations on adjacent five-minute footprints can leave
|
||
|
|
// several-kilometre numerical gaps even though the temporal samples
|
||
|
|
// overlap. Keep a modest 60 km ceiling for the rare last-gap transition;
|
||
|
|
// larger separations remain disconnected physical components and are not
|
||
|
|
// bridged.
|
||
|
|
touchingDistanceKM = 60.0
|
||
|
|
minimumBridgeHalfDeg = 0.01
|
||
|
|
)
|
||
|
|
if len(polygons) < 2 {
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
bounds := make([]occultationUnitBounds, len(polygons))
|
||
|
|
for index, polygon := range polygons {
|
||
|
|
bounds[index] = occultationPolygonUnitBounds(polygon)
|
||
|
|
}
|
||
|
|
for len(polygons) > 1 {
|
||
|
|
firstIndex, secondIndex := -1, -1
|
||
|
|
var touching, leftTouch, rightTouch geodata.GeoPoint
|
||
|
|
for first := 0; first < len(polygons) && firstIndex < 0; first++ {
|
||
|
|
for second := first + 1; second < len(polygons) && firstIndex < 0; second++ {
|
||
|
|
if !occultationUnitBoundsNear(bounds[first], bounds[second], touchingDistanceKM) {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
for _, left := range polygons[first] {
|
||
|
|
for _, right := range polygons[second] {
|
||
|
|
if geoDistanceKM(left, right) > touchingDistanceKM {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
firstIndex, secondIndex = first, second
|
||
|
|
leftTouch, rightTouch = left, right
|
||
|
|
touching = geodata.GeoPoint{
|
||
|
|
Longitude: left.Longitude + math.Remainder(right.Longitude-left.Longitude, 360)/2,
|
||
|
|
Latitude: (left.Latitude + right.Latitude) / 2,
|
||
|
|
}
|
||
|
|
break
|
||
|
|
}
|
||
|
|
if firstIndex >= 0 {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if firstIndex < 0 || secondIndex < 0 {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
bridgeHalfDeg := minimumBridgeHalfDeg
|
||
|
|
if gap := geoDistanceKM(leftTouch, rightTouch) / EarthRadiusKM * 180 / math.Pi; gap/2+0.002 > bridgeHalfDeg {
|
||
|
|
bridgeHalfDeg = gap/2 + 0.002
|
||
|
|
}
|
||
|
|
bridge := []geodata.GeoPoint{
|
||
|
|
{Longitude: touching.Longitude - bridgeHalfDeg, Latitude: touching.Latitude - bridgeHalfDeg},
|
||
|
|
{Longitude: touching.Longitude + bridgeHalfDeg, Latitude: touching.Latitude - bridgeHalfDeg},
|
||
|
|
{Longitude: touching.Longitude + bridgeHalfDeg, Latitude: touching.Latitude + bridgeHalfDeg},
|
||
|
|
{Longitude: touching.Longitude - bridgeHalfDeg, Latitude: touching.Latitude + bridgeHalfDeg},
|
||
|
|
}
|
||
|
|
leftPolygon := append([]geodata.GeoPoint(nil), polygons[firstIndex]...)
|
||
|
|
rightPolygon := append([]geodata.GeoPoint(nil), polygons[secondIndex]...)
|
||
|
|
for index, point := range leftPolygon {
|
||
|
|
if point == leftTouch {
|
||
|
|
leftPolygon[index] = touching
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for index, point := range rightPolygon {
|
||
|
|
if point == rightTouch {
|
||
|
|
rightPolygon[index] = touching
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
pair, err := geodata.UnionPolygons([][]geodata.GeoPoint{
|
||
|
|
leftPolygon, rightPolygon, bridge,
|
||
|
|
})
|
||
|
|
if err != nil || len(pair) != 1 {
|
||
|
|
pair, err = geodata.UnionPolygons([][]geodata.GeoPoint{
|
||
|
|
leftPolygon, rightPolygon,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
if err != nil || len(pair) != 1 {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
next := make([][]geodata.GeoPoint, 0, len(polygons)-1)
|
||
|
|
nextBounds := make([]occultationUnitBounds, 0, len(polygons)-1)
|
||
|
|
for index, polygon := range polygons {
|
||
|
|
if index == firstIndex {
|
||
|
|
next = append(next, pair[0])
|
||
|
|
nextBounds = append(nextBounds, occultationPolygonUnitBounds(pair[0]))
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if index == secondIndex {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
next = append(next, polygon)
|
||
|
|
nextBounds = append(nextBounds, bounds[index])
|
||
|
|
}
|
||
|
|
polygons, bounds = next, nextBounds
|
||
|
|
}
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintSweepNeedsHorizonClipping(
|
||
|
|
swept, visibleUnion [][]geodata.GeoPoint,
|
||
|
|
footprints []basic.OccultationFootprint,
|
||
|
|
) bool {
|
||
|
|
if len(swept) == 0 || len(visibleUnion) == 0 {
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
// A single continuous open sweep against a fragmented horizon union is a
|
||
|
|
// topological disagreement, not a small metric residual. The caller must
|
||
|
|
// use the continuous contact/phase linework in this case; avoid measuring
|
||
|
|
// every edge of all sampled fragments against the sweep because that exact
|
||
|
|
// spherical distance check dominates compact polar events.
|
||
|
|
if len(swept) == 1 && len(visibleUnion) > 1 {
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
// A disconnected open sweep is the common polar-fold failure mode: its
|
||
|
|
// endpoint ribbons can bridge across a cap even though the horizon-closed
|
||
|
|
// source remains split into separate visible faces.
|
||
|
|
if len(swept) > 1 && len(visibleUnion) > len(swept) {
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
if len(swept) > 1 {
|
||
|
|
for _, footprint := range footprints {
|
||
|
|
for _, boundary := range footprint.Boundaries {
|
||
|
|
for _, point := range boundary {
|
||
|
|
if math.Abs(point.Latitude) >= 70 {
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Probe vertices and edge midpoints of the smooth sweep against the
|
||
|
|
// horizon-closed union. A miss larger than a small numerical tolerance means
|
||
|
|
// the ribbon has crossed into the below-horizon complement.
|
||
|
|
if !geodata.SphericalPolygonsContainPathsWithinKM(visibleUnion, swept, true, 20) {
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
probes := make([][]geodata.GeoPoint, 0, 2048)
|
||
|
|
for _, footprint := range footprints {
|
||
|
|
for _, source := range footprint.Polygons {
|
||
|
|
if len(source) < 3 {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
ring := make([]geodata.GeoPoint, len(source))
|
||
|
|
for index, point := range source {
|
||
|
|
ring[index] = geodata.GeoPoint{Longitude: point.Longitude, Latitude: point.Latitude}
|
||
|
|
}
|
||
|
|
for _, probe := range occultationVisibleFootprintProbes(source, ring) {
|
||
|
|
probes = append(probes, []geodata.GeoPoint{probe})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
probes = limitOccultationCoveragePaths(probes, 2048)
|
||
|
|
if len(probes) > 0 && !geodata.SphericalPolygonsContainPathsWithinKM(swept, probes, false, 25) {
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
// The opposite miss means the open ribbon dropped a legitimate visible
|
||
|
|
// footprint lobe. Keep the horizon-closed union in that case as well; a
|
||
|
|
// static band must contain every sampled instantaneous witness.
|
||
|
|
return !geodata.SphericalPolygonsContainPathsWithinKM(swept, visibleUnion, true, 25)
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintBoundariesAvailable(footprints []basic.OccultationFootprint) bool {
|
||
|
|
if len(footprints) == 0 {
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
for _, footprint := range footprints {
|
||
|
|
if len(footprint.Boundaries) == 0 {
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintOpenSweepPolygons(footprints []basic.OccultationFootprint) ([][]geodata.GeoPoint, error) {
|
||
|
|
return footprintOpenSweepPolygonsWithTransitions(footprints, true)
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintOpenSweepPolygonsWithoutTransitions(
|
||
|
|
footprints []basic.OccultationFootprint,
|
||
|
|
) ([][]geodata.GeoPoint, error) {
|
||
|
|
return footprintOpenSweepPolygonsWithTransitions(footprints, false)
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintOpenSweepPolygonsWithTransitions(
|
||
|
|
footprints []basic.OccultationFootprint,
|
||
|
|
includeTransitions bool,
|
||
|
|
) ([][]geodata.GeoPoint, error) {
|
||
|
|
polygons := make([][]geodata.GeoPoint, 0, 2)
|
||
|
|
for start := 0; start < len(footprints); {
|
||
|
|
for start < len(footprints) && footprints[start].Closed {
|
||
|
|
start++
|
||
|
|
}
|
||
|
|
if start == len(footprints) {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
end := start
|
||
|
|
for end < len(footprints) && !footprints[end].Closed {
|
||
|
|
end++
|
||
|
|
}
|
||
|
|
|
||
|
|
samples := make([]geodata.OpenBoundarySweepSample, 0, end-start+2)
|
||
|
|
if includeTransitions && start > 0 {
|
||
|
|
boundary, ok := footprintTransitionBoundary(footprints[start-1], footprints[start])
|
||
|
|
if ok {
|
||
|
|
samples = append(samples, geodata.OpenBoundarySweepSample{Boundaries: [][]geodata.GeoPoint{boundary}})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
for index := start; index < end; index++ {
|
||
|
|
samples = append(samples, geodata.OpenBoundarySweepSample{
|
||
|
|
Boundaries: footprintGeoBoundaries(footprints[index]),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
if includeTransitions && end < len(footprints) {
|
||
|
|
boundary, ok := footprintTransitionBoundary(footprints[end], footprints[end-1])
|
||
|
|
if ok {
|
||
|
|
samples = append(samples, geodata.OpenBoundarySweepSample{Boundaries: [][]geodata.GeoPoint{boundary}})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
group, err := geodata.OpenBoundarySweep(samples)
|
||
|
|
if err != nil && includeTransitions {
|
||
|
|
// At an open/closed transition the exact transition arc can be
|
||
|
|
// numerically coincident with the first ribbon edge. Retry the same
|
||
|
|
// physical run without that synthetic endpoint; the sampled open arcs
|
||
|
|
// still provide both endpoint tracks and avoid a false diagonal cap.
|
||
|
|
bareSamples := make([]geodata.OpenBoundarySweepSample, 0, end-start)
|
||
|
|
for index := start; index < end; index++ {
|
||
|
|
bareSamples = append(bareSamples, geodata.OpenBoundarySweepSample{
|
||
|
|
Boundaries: footprintGeoBoundaries(footprints[index]),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
group, err = geodata.OpenBoundarySweep(bareSamples)
|
||
|
|
}
|
||
|
|
if err != nil {
|
||
|
|
return nil, err
|
||
|
|
}
|
||
|
|
polygons = append(polygons, group...)
|
||
|
|
start = end
|
||
|
|
}
|
||
|
|
if len(polygons) == 0 {
|
||
|
|
return nil, fmt.Errorf("open footprint samples contain no usable sweep")
|
||
|
|
}
|
||
|
|
return polygons, nil
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintGeoBoundaries(footprint basic.OccultationFootprint) [][]geodata.GeoPoint {
|
||
|
|
boundaries := make([][]geodata.GeoPoint, len(footprint.Boundaries))
|
||
|
|
for boundaryIndex, source := range footprint.Boundaries {
|
||
|
|
boundary := make([]geodata.GeoPoint, len(source))
|
||
|
|
for pointIndex, point := range source {
|
||
|
|
boundary[pointIndex] = geodata.GeoPoint{Longitude: point.Longitude, Latitude: point.Latitude}
|
||
|
|
}
|
||
|
|
boundaries[boundaryIndex] = boundary
|
||
|
|
}
|
||
|
|
return boundaries
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintTransitionBoundary(
|
||
|
|
closed, adjacent basic.OccultationFootprint,
|
||
|
|
) ([]geodata.GeoPoint, bool) {
|
||
|
|
closedRing := openFootprintRing(geodata.JoinPolylineSegments(footprintGeoBoundaries(closed)))
|
||
|
|
adjacentArc := openFootprintRing(geodata.JoinPolylineSegments(footprintGeoBoundaries(adjacent)))
|
||
|
|
if len(closedRing) < 3 || len(adjacentArc) < 2 {
|
||
|
|
return nil, false
|
||
|
|
}
|
||
|
|
start := nearestFootprintPointIndex(closedRing, adjacentArc[0])
|
||
|
|
end := nearestFootprintPointIndex(closedRing, adjacentArc[len(adjacentArc)-1])
|
||
|
|
if start == end {
|
||
|
|
forward := footprintOpenedRing(closedRing, start, 1)
|
||
|
|
backward := footprintOpenedRing(closedRing, start, -1)
|
||
|
|
if footprintArcMatchScore(backward, adjacentArc) < footprintArcMatchScore(forward, adjacentArc) {
|
||
|
|
return backward, true
|
||
|
|
}
|
||
|
|
return forward, true
|
||
|
|
}
|
||
|
|
forward := footprintRingArc(closedRing, start, end, 1)
|
||
|
|
backward := footprintRingArc(closedRing, start, end, -1)
|
||
|
|
if footprintArcMatchScore(backward, adjacentArc) < footprintArcMatchScore(forward, adjacentArc) {
|
||
|
|
return backward, true
|
||
|
|
}
|
||
|
|
return forward, true
|
||
|
|
}
|
||
|
|
|
||
|
|
func nearestFootprintPointIndex(points []geodata.GeoPoint, target geodata.GeoPoint) int {
|
||
|
|
nearest := 0
|
||
|
|
distance := math.Inf(1)
|
||
|
|
for index, point := range points {
|
||
|
|
candidate := geoDistanceKM(point, target)
|
||
|
|
if candidate < distance {
|
||
|
|
nearest, distance = index, candidate
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return nearest
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintOpenedRing(points []geodata.GeoPoint, start, direction int) []geodata.GeoPoint {
|
||
|
|
result := make([]geodata.GeoPoint, len(points))
|
||
|
|
for index := range result {
|
||
|
|
position := (start + direction*index) % len(points)
|
||
|
|
if position < 0 {
|
||
|
|
position += len(points)
|
||
|
|
}
|
||
|
|
result[index] = points[position]
|
||
|
|
}
|
||
|
|
return result
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintRingArc(points []geodata.GeoPoint, start, end, direction int) []geodata.GeoPoint {
|
||
|
|
arc := make([]geodata.GeoPoint, 1, len(points)+1)
|
||
|
|
arc[0] = points[start]
|
||
|
|
index := start
|
||
|
|
for step := 1; step <= len(points); step++ {
|
||
|
|
index = (index + direction + len(points)) % len(points)
|
||
|
|
arc = append(arc, points[index])
|
||
|
|
if index == end {
|
||
|
|
return arc
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return arc
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintArcMatchScore(candidate, reference []geodata.GeoPoint) float64 {
|
||
|
|
if len(candidate) < 2 || len(reference) < 2 {
|
||
|
|
return math.Inf(1)
|
||
|
|
}
|
||
|
|
const samples = 17
|
||
|
|
score := 0.0
|
||
|
|
for index := 0; index < samples; index++ {
|
||
|
|
candidateIndex := index * (len(candidate) - 1) / (samples - 1)
|
||
|
|
referenceIndex := index * (len(reference) - 1) / (samples - 1)
|
||
|
|
score += geoDistanceKM(candidate[candidateIndex], reference[referenceIndex])
|
||
|
|
}
|
||
|
|
return score
|
||
|
|
}
|
||
|
|
|
||
|
|
func openFootprintRing(points []geodata.GeoPoint) []geodata.GeoPoint {
|
||
|
|
if len(points) > 1 && geodata.SameGeoPoint(points[0], points[len(points)-1]) {
|
||
|
|
return points[:len(points)-1]
|
||
|
|
}
|
||
|
|
return points
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintClosedPolygons(footprints []basic.OccultationFootprint) [][]geodata.GeoPoint {
|
||
|
|
var polygons [][]geodata.GeoPoint
|
||
|
|
for _, footprint := range footprints {
|
||
|
|
if !footprint.Closed || len(footprint.Boundaries) == 0 {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
polygons = append(polygons, footprintPolygons([]basic.OccultationFootprint{footprint})...)
|
||
|
|
}
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintStaticInteriorPolygons(footprints []basic.OccultationFootprint) [][]geodata.GeoPoint {
|
||
|
|
var polygons [][]geodata.GeoPoint
|
||
|
|
for _, footprint := range footprints {
|
||
|
|
if footprint.Closed {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
for _, source := range footprint.InteriorPolygons {
|
||
|
|
if len(source) < 3 || !occultationStaticInteriorPolygon(source, footprint.InteriorPolygons) {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
center := geodata.GeoPoint{Longitude: source[0].Longitude, Latitude: source[0].Latitude}
|
||
|
|
polygon, ok := footprintStaticBoundaryBridge(center, footprint.Boundaries)
|
||
|
|
if !ok {
|
||
|
|
polygon = make([]geodata.GeoPoint, len(source))
|
||
|
|
for index, point := range source {
|
||
|
|
polygon[index] = geodata.GeoPoint{Longitude: point.Longitude, Latitude: point.Latitude}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// A footprint can briefly collapse to a tangent point at a
|
||
|
|
// visibility transition. Its bridge then repeats the same vertex and
|
||
|
|
// is not a polygon; passing it to UnionPolygons aborts the entire band.
|
||
|
|
if len(polygon) >= 3 && math.Abs(geoRingArea(polygon)) > 1e-12 {
|
||
|
|
polygons = append(polygons, polygon)
|
||
|
|
}
|
||
|
|
centerCap := geodata.SphericalCircle(
|
||
|
|
center,
|
||
|
|
staticCenterCapRadiusKM/EarthRadiusKM*180/math.Pi,
|
||
|
|
staticCenterCapPoints,
|
||
|
|
)
|
||
|
|
if len(centerCap) >= 3 {
|
||
|
|
centerCap = append(centerCap, centerCap[0])
|
||
|
|
polygons = append(polygons, centerCap)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintStaticBoundaryBridge(
|
||
|
|
center geodata.GeoPoint,
|
||
|
|
boundaries [][]basic.OccultationPathPoint,
|
||
|
|
) ([]geodata.GeoPoint, bool) {
|
||
|
|
nearestDistance := math.Inf(1)
|
||
|
|
var nearestStart, nearestEnd geodata.GeoPoint
|
||
|
|
for _, boundary := range boundaries {
|
||
|
|
for index := 1; index < len(boundary); index++ {
|
||
|
|
start := geodata.GeoPoint{
|
||
|
|
Longitude: boundary[index-1].Longitude,
|
||
|
|
Latitude: boundary[index-1].Latitude,
|
||
|
|
}
|
||
|
|
end := geodata.GeoPoint{
|
||
|
|
Longitude: boundary[index].Longitude,
|
||
|
|
Latitude: boundary[index].Latitude,
|
||
|
|
}
|
||
|
|
distance := geoPointSegmentDistanceKM(center, start, end)
|
||
|
|
if distance < nearestDistance {
|
||
|
|
nearestDistance = distance
|
||
|
|
nearestStart = start
|
||
|
|
nearestEnd = end
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if !finiteGeo(nearestDistance) {
|
||
|
|
return nil, false
|
||
|
|
}
|
||
|
|
return []geodata.GeoPoint{center, nearestStart, nearestEnd, center}, true
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintPolygons(footprints []basic.OccultationFootprint) [][]geodata.GeoPoint {
|
||
|
|
var polygons [][]geodata.GeoPoint
|
||
|
|
for _, footprint := range footprints {
|
||
|
|
for _, source := range footprint.Polygons {
|
||
|
|
if occultationInteriorPolygon(source, footprint.InteriorPolygons) {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
polygon := make([]geodata.GeoPoint, len(source))
|
||
|
|
for index, point := range source {
|
||
|
|
polygon[index] = geodata.GeoPoint{Longitude: point.Longitude, Latitude: point.Latitude}
|
||
|
|
}
|
||
|
|
polygons = append(polygons, polygon)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
|
||
|
|
func geoPointSegmentDistanceKM(point, start, end geodata.GeoPoint) float64 {
|
||
|
|
latitude := point.Latitude * math.Pi / 180
|
||
|
|
scaleX := math.Cos(latitude) * EarthRadiusKM * math.Pi / 180
|
||
|
|
scaleY := EarthRadiusKM * math.Pi / 180
|
||
|
|
x := func(value geodata.GeoPoint) float64 {
|
||
|
|
return math.Remainder(value.Longitude-point.Longitude, 360) * scaleX
|
||
|
|
}
|
||
|
|
y := func(value geodata.GeoPoint) float64 {
|
||
|
|
return (value.Latitude - point.Latitude) * scaleY
|
||
|
|
}
|
||
|
|
startX, startY := x(start), y(start)
|
||
|
|
endX, endY := x(end), y(end)
|
||
|
|
deltaX, deltaY := endX-startX, endY-startY
|
||
|
|
fraction := 0.0
|
||
|
|
if lengthSquared := deltaX*deltaX + deltaY*deltaY; lengthSquared > 0 {
|
||
|
|
fraction = math.Max(0, math.Min(1,
|
||
|
|
-(startX*deltaX+startY*deltaY)/lengthSquared,
|
||
|
|
))
|
||
|
|
}
|
||
|
|
return math.Hypot(startX+fraction*deltaX, startY+fraction*deltaY)
|
||
|
|
}
|
||
|
|
|
||
|
|
func geoRingArea(polygon []geodata.GeoPoint) float64 {
|
||
|
|
if len(polygon) < 3 {
|
||
|
|
return 0
|
||
|
|
}
|
||
|
|
longitudes := make([]float64, len(polygon))
|
||
|
|
longitudes[0] = polygon[0].Longitude
|
||
|
|
for index := 1; index < len(polygon); index++ {
|
||
|
|
longitudes[index] = longitudes[index-1] + math.Remainder(
|
||
|
|
polygon[index].Longitude-longitudes[index-1], 360,
|
||
|
|
)
|
||
|
|
}
|
||
|
|
area := 0.0
|
||
|
|
for index, point := range polygon {
|
||
|
|
next := polygon[(index+1)%len(polygon)]
|
||
|
|
area += longitudes[index]*next.Latitude - longitudes[(index+1)%len(polygon)]*point.Latitude
|
||
|
|
}
|
||
|
|
return area / 2
|
||
|
|
}
|
||
|
|
|
||
|
|
func finiteGeo(value float64) bool {
|
||
|
|
return !math.IsNaN(value) && !math.IsInf(value, 0)
|
||
|
|
}
|
||
|
|
|
||
|
|
func continuousRanges(count int, changed func(int) bool) []SampleRange {
|
||
|
|
if count == 0 {
|
||
|
|
return nil
|
||
|
|
}
|
||
|
|
ranges := make([]SampleRange, 0, 2)
|
||
|
|
start := 0
|
||
|
|
for index := 1; index < count; index++ {
|
||
|
|
if !changed(index) {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
ranges = append(ranges, SampleRange{Start: start, End: index})
|
||
|
|
start = index
|
||
|
|
}
|
||
|
|
return append(ranges, SampleRange{Start: start, End: count})
|
||
|
|
}
|
||
|
|
|
||
|
|
// BoundaryBranchChanged 判断两个相邻样本是否距离过大，无法属于同一物理支路。
|
||
|
|
// BoundaryBranchChanged reports whether two adjacent samples are too far apart to be one physical branch.
|
||
|
|
func BoundaryBranchChanged(first, second basic.OccultationPathPoint) bool {
|
||
|
|
distance := DistanceKM(first, second)
|
||
|
|
if distance <= BoundaryBranchJumpKM {
|
||
|
|
return false
|
||
|
|
}
|
||
|
|
duration := math.Abs(second.Time.Sub(first.Time).Seconds())
|
||
|
|
return duration == 0 || distance/duration > BoundaryBranchSpeedKMPerSecond
|
||
|
|
}
|
||
|
|
|
||
|
|
// DistanceKM 返回两个边界样本之间的最短球面距离。
|
||
|
|
// DistanceKM returns the shortest spherical surface distance between two boundary samples.
|
||
|
|
func DistanceKM(first, second basic.OccultationPathPoint) float64 {
|
||
|
|
return geoDistanceKM(
|
||
|
|
geodata.GeoPoint{Longitude: first.Longitude, Latitude: first.Latitude},
|
||
|
|
geodata.GeoPoint{Longitude: second.Longitude, Latitude: second.Latitude},
|
||
|
|
)
|
||
|
|
}
|
||
|
|
|
||
|
|
func geoDistanceKM(first, second geodata.GeoPoint) float64 {
|
||
|
|
firstLatitude := first.Latitude * math.Pi / 180
|
||
|
|
secondLatitude := second.Latitude * math.Pi / 180
|
||
|
|
deltaLatitude := secondLatitude - firstLatitude
|
||
|
|
deltaLongitude := math.Remainder((second.Longitude-first.Longitude)*math.Pi/180, 2*math.Pi)
|
||
|
|
haversine := math.Sin(deltaLatitude/2)*math.Sin(deltaLatitude/2) +
|
||
|
|
math.Cos(firstLatitude)*math.Cos(secondLatitude)*math.Sin(deltaLongitude/2)*math.Sin(deltaLongitude/2)
|
||
|
|
return 2 * EarthRadiusKM * math.Asin(math.Sqrt(math.Min(1, haversine)))
|
||
|
|
}
|