325 lines
9.9 KiB
Go
325 lines
9.9 KiB
Go
|
package occultationgeo
|
||
|
|
|
||
|
|
// 本文件保存改动前的参考实现，仅用于差分对照：新实现必须在相同随机输入上给出逐点相同的输出。
|
||
|
|
|
||
|
|
import (
|
||
|
|
"fmt"
|
||
|
|
"math"
|
||
|
|
|
||
|
|
"b612.me/astro/basic"
|
||
|
|
"b612.me/astro/internal/geodata"
|
||
|
|
)
|
||
|
|
|
||
|
|
func mergeTouchingVisiblePolygonsReference(polygons [][]geodata.GeoPoint) [][]geodata.GeoPoint {
|
||
|
|
const (
|
||
|
|
touchingDistanceKM = 60.0
|
||
|
|
minimumBridgeHalfDeg = 0.01
|
||
|
|
)
|
||
|
|
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++ {
|
||
|
|
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)
|
||
|
|
for index, polygon := range polygons {
|
||
|
|
if index == firstIndex {
|
||
|
|
next = append(next, pair[0])
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if index == secondIndex {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
next = append(next, polygon)
|
||
|
|
}
|
||
|
|
polygons = next
|
||
|
|
}
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
|
||
|
|
func removeTinyPolygonComponentsReference(polygons [][]geodata.GeoPoint) [][]geodata.GeoPoint {
|
||
|
|
if len(polygons) < 2 {
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
areas := make([]float64, len(polygons))
|
||
|
|
maximum := 0.0
|
||
|
|
for index, polygon := range polygons {
|
||
|
|
areas[index] = math.Abs(geoRingArea(polygon))
|
||
|
|
if areas[index] > maximum {
|
||
|
|
maximum = areas[index]
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if maximum <= 0 || !finiteGeo(maximum) {
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
threshold := maximum * 1e-4
|
||
|
|
filtered := make([][]geodata.GeoPoint, 0, len(polygons))
|
||
|
|
for index, polygon := range polygons {
|
||
|
|
if areas[index] >= threshold {
|
||
|
|
filtered = append(filtered, polygon)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if len(filtered) == 0 {
|
||
|
|
return polygons[:1]
|
||
|
|
}
|
||
|
|
return filtered
|
||
|
|
}
|
||
|
|
|
||
|
|
func pairedBoundaryPolygonsReference(
|
||
|
|
first, second []basic.OccultationPathPoint,
|
||
|
|
) [][]geodata.GeoPoint {
|
||
|
|
count := len(first)
|
||
|
|
if len(second) < count {
|
||
|
|
count = len(second)
|
||
|
|
}
|
||
|
|
polygons := make([][]geodata.GeoPoint, 0, count)
|
||
|
|
pendingBranch := false
|
||
|
|
for index := 1; index < count; index++ {
|
||
|
|
firstChanged := BoundaryBranchChanged(first[index-1], first[index])
|
||
|
|
secondChanged := BoundaryBranchChanged(second[index-1], second[index])
|
||
|
|
if pendingBranch {
|
||
|
|
if firstChanged || secondChanged {
|
||
|
|
pendingBranch = false
|
||
|
|
}
|
||
|
|
if firstChanged || secondChanged || pendingBranch {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if firstChanged != secondChanged {
|
||
|
|
pendingBranch = true
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
if firstChanged { // both sides changed at the same transition
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
previousFirst, currentFirst := first[index-1], first[index]
|
||
|
|
previousSecond, currentSecond := second[index-1], second[index]
|
||
|
|
polygons = append(polygons, []geodata.GeoPoint{
|
||
|
|
{Longitude: previousFirst.Longitude, Latitude: previousFirst.Latitude},
|
||
|
|
{Longitude: currentFirst.Longitude, Latitude: currentFirst.Latitude},
|
||
|
|
{Longitude: currentSecond.Longitude, Latitude: currentSecond.Latitude},
|
||
|
|
{Longitude: previousSecond.Longitude, Latitude: previousSecond.Latitude},
|
||
|
|
})
|
||
|
|
}
|
||
|
|
return polygons
|
||
|
|
}
|
||
|
|
|
||
|
|
func constrainPolygonsWithinReference(
|
||
|
|
parent, child [][]geodata.GeoPoint,
|
||
|
|
) [][]geodata.GeoPoint {
|
||
|
|
if len(parent) == 0 || len(child) == 0 {
|
||
|
|
return child
|
||
|
|
}
|
||
|
|
initialMissDistance := geodata.SphericalPolygonsPathMissDistanceKM(parent, child, true)
|
||
|
|
if initialMissDistance <= 0 {
|
||
|
|
return child
|
||
|
|
}
|
||
|
|
const maximumRepairDistanceKM = 100.0
|
||
|
|
const maximumResidualMissDistanceKM = 10.0
|
||
|
|
if initialMissDistance > maximumRepairDistanceKM {
|
||
|
|
return child
|
||
|
|
}
|
||
|
|
result := make([][]geodata.GeoPoint, len(child))
|
||
|
|
for index, source := range child {
|
||
|
|
if len(source) < 4 {
|
||
|
|
if len(openFootprintRing(source)) >= 3 && math.Abs(geoRingArea(source)) > 1e-12 {
|
||
|
|
result[index] = append([]geodata.GeoPoint(nil), source...)
|
||
|
|
}
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
ring := append([]geodata.GeoPoint(nil), source...)
|
||
|
|
closed := geodata.SameGeoPoint(ring[0], ring[len(ring)-1])
|
||
|
|
limit := len(ring)
|
||
|
|
if closed {
|
||
|
|
limit--
|
||
|
|
}
|
||
|
|
containment := geodata.SphericalPolygonsContainPoints(parent, ring[:limit])
|
||
|
|
for pointIndex := 0; pointIndex < limit; pointIndex++ {
|
||
|
|
point := ring[pointIndex]
|
||
|
|
if containment[pointIndex] {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
nearest, distance := nearestPolygonBoundaryPoint(parent, point)
|
||
|
|
if distance <= maximumRepairDistanceKM {
|
||
|
|
ring[pointIndex] = nearest
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if closed {
|
||
|
|
ring[len(ring)-1] = ring[0]
|
||
|
|
}
|
||
|
|
result[index] = ring
|
||
|
|
}
|
||
|
|
result = usableOccultationPolygons(result)
|
||
|
|
if geodata.SphericalPolygonsPathMissDistanceKM(parent, result, true) <= 0 {
|
||
|
|
return result
|
||
|
|
}
|
||
|
|
// Vertex-only repair cannot see a child edge whose endpoints are both
|
||
|
|
// inside the parent while its great-circle midpoint crosses outside. Split
|
||
|
|
// the repaired ring at the same projected spacing used by output geometry,
|
||
|
|
// then apply the local vertex snap to those newly exposed edge probes.
|
||
|
|
densified := densifyOccultationPolygons(result, 10)
|
||
|
|
for pass := 0; pass < 6; pass++ {
|
||
|
|
changed := false
|
||
|
|
for index, source := range densified {
|
||
|
|
ring := append([]geodata.GeoPoint(nil), source...)
|
||
|
|
closed := len(ring) > 1 && geodata.SameGeoPoint(ring[0], ring[len(ring)-1])
|
||
|
|
limit := len(ring)
|
||
|
|
if closed {
|
||
|
|
limit--
|
||
|
|
}
|
||
|
|
containment := geodata.SphericalPolygonsContainPoints(parent, ring[:limit])
|
||
|
|
for pointIndex := 0; pointIndex < limit; pointIndex++ {
|
||
|
|
point := ring[pointIndex]
|
||
|
|
if containment[pointIndex] {
|
||
|
|
continue
|
||
|
|
}
|
||
|
|
nearest, distance := nearestPolygonBoundaryPoint(parent, point)
|
||
|
|
if distance <= maximumRepairDistanceKM {
|
||
|
|
ring[pointIndex] = nearest
|
||
|
|
changed = true
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if closed {
|
||
|
|
ring[len(ring)-1] = ring[0]
|
||
|
|
}
|
||
|
|
for {
|
||
|
|
cleaned := removeDirectProjectedSharpCorners(ring, 20, 30)
|
||
|
|
cleaned = removeOccultationSharpCorners(cleaned, 20, 30)
|
||
|
|
if len(cleaned) == len(ring) {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
ring = cleaned
|
||
|
|
}
|
||
|
|
if closed && len(ring) > 1 && !geodata.SameGeoPoint(ring[0], ring[len(ring)-1]) {
|
||
|
|
ring = append(ring, ring[0])
|
||
|
|
}
|
||
|
|
densified[index] = ring
|
||
|
|
}
|
||
|
|
densified = usableOccultationPolygons(densified)
|
||
|
|
if geodata.SphericalPolygonsPathMissDistanceKM(parent, densified, true) <= maximumResidualMissDistanceKM {
|
||
|
|
return densified
|
||
|
|
}
|
||
|
|
if !changed {
|
||
|
|
break
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return child
|
||
|
|
}
|
||
|
|
|
||
|
|
func footprintOpenSweepPolygonsWithTransitionsReference(
|
||
|
|
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
|
||
|
|
}
|