671 lines
21 KiB
Go
671 lines
21 KiB
Go
|
package svg
|
|||
|
|
|
|||
|
|
import (
|
|||
|
|
"errors"
|
|||
|
|
"fmt"
|
|||
|
|
"math"
|
|||
|
|
"strings"
|
|||
|
|
"time"
|
|||
|
|
"unicode"
|
|||
|
|
"unicode/utf8"
|
|||
|
|
|
|||
|
|
"b612.me/astro/internal/svgmap"
|
|||
|
|
"b612.me/astro/moon"
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
// ErrInvalidStarOccultationPath 表示传入 SVG 渲染器的掩带数据无效。
|
|||
|
|
// ErrInvalidStarOccultationPath reports malformed path data passed to the SVG renderer.
|
|||
|
|
var ErrInvalidStarOccultationPath = errors.New("invalid stellar occultation path")
|
|||
|
|
|
|||
|
|
type starOccultationSVGLayout struct {
|
|||
|
|
width float64
|
|||
|
|
height float64
|
|||
|
|
margin float64
|
|||
|
|
mapX float64
|
|||
|
|
mapY float64
|
|||
|
|
mapWidth float64
|
|||
|
|
mapHeight float64
|
|||
|
|
panelX float64
|
|||
|
|
panelY float64
|
|||
|
|
panelWidth float64
|
|||
|
|
footerY float64
|
|||
|
|
projection svgmap.Projection
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
type starOccultationGeoPoint struct {
|
|||
|
|
longitude float64
|
|||
|
|
latitude float64
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
type starOccultationEventRow struct {
|
|||
|
|
name string
|
|||
|
|
point moon.OccultationPathPoint
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func validateStarOccultationPath(path moon.StarOccultationPath) error {
|
|||
|
|
if !path.Complete {
|
|||
|
|
return fmt.Errorf("%w: global path is incomplete", ErrInvalidStarOccultationPath)
|
|||
|
|
}
|
|||
|
|
if err := validateStarOccultationPathPoint("start", path.Start); err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
if err := validateStarOccultationPathPoint("greatest", path.Greatest); err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
if err := validateStarOccultationPathPoint("end", path.End); err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
if path.Greatest.Time.Before(path.Start.Time) || path.End.Time.Before(path.Greatest.Time) {
|
|||
|
|
return fmt.Errorf("%w: event times must be ordered start, greatest, end", ErrInvalidStarOccultationPath)
|
|||
|
|
}
|
|||
|
|
if err := (moon.OccultationPathOptions{Step: path.Step, TargetSpacingKM: path.TargetSpacingKM}).Validate(); err != nil {
|
|||
|
|
return fmt.Errorf("%w: invalid path sampling metadata: %v", ErrInvalidStarOccultationPath, err)
|
|||
|
|
}
|
|||
|
|
series := []struct {
|
|||
|
|
name string
|
|||
|
|
points []moon.OccultationPathPoint
|
|||
|
|
}{
|
|||
|
|
{"center line", path.CenterLine},
|
|||
|
|
{"northern limit", path.NorthernLimit},
|
|||
|
|
{"southern limit", path.SouthernLimit},
|
|||
|
|
}
|
|||
|
|
for _, current := range series {
|
|||
|
|
name, points := current.name, current.points
|
|||
|
|
for index, point := range points {
|
|||
|
|
if err := validateStarOccultationPathPoint(fmt.Sprintf("%s[%d]", name, index), point); err != nil {
|
|||
|
|
return err
|
|||
|
|
}
|
|||
|
|
if index > 0 && !point.Time.After(points[index-1].Time) {
|
|||
|
|
return fmt.Errorf("%w: %s times must be strictly increasing", ErrInvalidStarOccultationPath, name)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if len(path.NorthernLimit) != len(path.SouthernLimit) {
|
|||
|
|
return fmt.Errorf("%w: northern and southern limits must have the same sample count", ErrInvalidStarOccultationPath)
|
|||
|
|
}
|
|||
|
|
if len(path.NorthernLimit) < 2 {
|
|||
|
|
return fmt.Errorf("%w: global limits must contain start and end", ErrInvalidStarOccultationPath)
|
|||
|
|
}
|
|||
|
|
for index := range path.NorthernLimit {
|
|||
|
|
if !path.NorthernLimit[index].Time.Equal(path.SouthernLimit[index].Time) {
|
|||
|
|
return fmt.Errorf("%w: northern and southern limit sample %d times must match", ErrInvalidStarOccultationPath, index)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
last := len(path.NorthernLimit) - 1
|
|||
|
|
if !path.NorthernLimit[0].Time.Equal(path.Start.Time) || !path.SouthernLimit[0].Time.Equal(path.Start.Time) ||
|
|||
|
|
!path.NorthernLimit[last].Time.Equal(path.End.Time) || !path.SouthernLimit[last].Time.Equal(path.End.Time) {
|
|||
|
|
return fmt.Errorf("%w: global limits must span start through end", ErrInvalidStarOccultationPath)
|
|||
|
|
}
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func validateStarOccultationPathPoint(name string, point moon.OccultationPathPoint) error {
|
|||
|
|
if point.Time.IsZero() {
|
|||
|
|
return fmt.Errorf("%w: %s time is required", ErrInvalidStarOccultationPath, name)
|
|||
|
|
}
|
|||
|
|
if !starOccultationFinite(point.Longitude) || point.Longitude < -180 || point.Longitude > 180 {
|
|||
|
|
return fmt.Errorf("%w: %s longitude must be in [-180, 180]", ErrInvalidStarOccultationPath, name)
|
|||
|
|
}
|
|||
|
|
if !starOccultationFinite(point.Latitude) || point.Latitude < -90 || point.Latitude > 90 {
|
|||
|
|
return fmt.Errorf("%w: %s latitude must be in [-90, 90]", ErrInvalidStarOccultationPath, name)
|
|||
|
|
}
|
|||
|
|
if !starOccultationFinite(point.MoonAltitude) || point.MoonAltitude < -90 || point.MoonAltitude > 90 {
|
|||
|
|
return fmt.Errorf("%w: %s Moon altitude must be in [-90, 90]", ErrInvalidStarOccultationPath, name)
|
|||
|
|
}
|
|||
|
|
if !starOccultationFinite(point.WidthKM) || point.WidthKM < 0 {
|
|||
|
|
return fmt.Errorf("%w: %s width must be finite and non-negative", ErrInvalidStarOccultationPath, name)
|
|||
|
|
}
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSVGLayoutFor(
|
|||
|
|
options StarOccultationSVGOptions,
|
|||
|
|
headerBottom float64,
|
|||
|
|
projection svgmap.Projection,
|
|||
|
|
) starOccultationSVGLayout {
|
|||
|
|
width := float64(options.Width)
|
|||
|
|
height := float64(options.Height)
|
|||
|
|
margin := math.Max(22, math.Min(42, width*0.04))
|
|||
|
|
gap := math.Max(16, math.Min(24, width*0.025))
|
|||
|
|
panelWidth := math.Max(148, math.Min(238, width*0.23))
|
|||
|
|
mapWidth := width - 2*margin - gap - panelWidth
|
|||
|
|
if mapWidth < 220 {
|
|||
|
|
panelWidth = math.Max(126, width*0.21)
|
|||
|
|
mapWidth = width - 2*margin - gap - panelWidth
|
|||
|
|
}
|
|||
|
|
contentTop := headerBottom + 28
|
|||
|
|
footerSpace := 82.0
|
|||
|
|
if projection != svgmap.ProjectionEquirectangular {
|
|||
|
|
footerSpace = 116
|
|||
|
|
}
|
|||
|
|
availableHeight := math.Max(110, height-contentTop-footerSpace)
|
|||
|
|
mapHeight := math.Min(mapWidth/2, availableHeight)
|
|||
|
|
if projection != svgmap.ProjectionEquirectangular {
|
|||
|
|
mapHeight = math.Min(mapWidth, availableHeight)
|
|||
|
|
mapWidth = mapHeight
|
|||
|
|
}
|
|||
|
|
if mapHeight < 110 {
|
|||
|
|
mapHeight = 110
|
|||
|
|
mapWidth = math.Min(mapWidth, 2*mapHeight)
|
|||
|
|
}
|
|||
|
|
mapY := contentTop + math.Max(0, (availableHeight-mapHeight)/2)
|
|||
|
|
return starOccultationSVGLayout{
|
|||
|
|
width: width,
|
|||
|
|
height: height,
|
|||
|
|
margin: margin,
|
|||
|
|
mapX: margin,
|
|||
|
|
mapY: mapY,
|
|||
|
|
mapWidth: mapWidth,
|
|||
|
|
mapHeight: mapHeight,
|
|||
|
|
panelX: margin + mapWidth + gap,
|
|||
|
|
panelY: mapY,
|
|||
|
|
panelWidth: panelWidth,
|
|||
|
|
footerY: height - 54,
|
|||
|
|
projection: projection,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (layout starOccultationSVGLayout) project(longitude, latitude float64) (float64, float64) {
|
|||
|
|
x, y, _ := layout.mapFrame().Project(longitude, latitude)
|
|||
|
|
return x, y
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func (layout starOccultationSVGLayout) mapFrame() svgmap.Frame {
|
|||
|
|
return svgmap.Frame{
|
|||
|
|
X: layout.mapX,
|
|||
|
|
Y: layout.mapY,
|
|||
|
|
Width: layout.mapWidth,
|
|||
|
|
Height: layout.mapHeight,
|
|||
|
|
Projection: layout.projection,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func resolveStarOccultationMapProjection(path moon.StarOccultationPath, requested MapProjection) svgmap.Projection {
|
|||
|
|
minimumLatitude := path.Greatest.Latitude
|
|||
|
|
maximumLatitude := path.Greatest.Latitude
|
|||
|
|
for _, series := range [][]moon.OccultationPathPoint{path.CenterLine, path.NorthernLimit, path.SouthernLimit} {
|
|||
|
|
for _, point := range series {
|
|||
|
|
minimumLatitude = math.Min(minimumLatitude, point.Latitude)
|
|||
|
|
maximumLatitude = math.Max(maximumLatitude, point.Latitude)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return svgmap.ResolveProjection(internalMapProjection(requested), path.Greatest.Latitude, minimumLatitude, maximumLatitude)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationPathSegments(points []moon.OccultationPathPoint) [][]moon.OccultationPathPoint {
|
|||
|
|
if len(points) == 0 {
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
segments := make([][]moon.OccultationPathPoint, 0, 2)
|
|||
|
|
current := []moon.OccultationPathPoint{points[0]}
|
|||
|
|
for index := 1; index < len(points); index++ {
|
|||
|
|
if math.Abs(points[index].Longitude-points[index-1].Longitude) <= 180 {
|
|||
|
|
current = append(current, points[index])
|
|||
|
|
continue
|
|||
|
|
}
|
|||
|
|
boundary, fraction, ok := starOccultationAntimeridianCrossing(points[index-1], points[index])
|
|||
|
|
if !ok {
|
|||
|
|
current = append(current, points[index])
|
|||
|
|
continue
|
|||
|
|
}
|
|||
|
|
crossing := starOccultationInterpolatePathPoint(points[index-1], points[index], fraction, boundary)
|
|||
|
|
current = append(current, crossing)
|
|||
|
|
if len(current) >= 2 {
|
|||
|
|
segments = append(segments, current)
|
|||
|
|
}
|
|||
|
|
wrapped := crossing
|
|||
|
|
wrapped.Longitude = -boundary
|
|||
|
|
current = []moon.OccultationPathPoint{wrapped, points[index]}
|
|||
|
|
}
|
|||
|
|
if len(current) >= 2 {
|
|||
|
|
segments = append(segments, current)
|
|||
|
|
}
|
|||
|
|
return segments
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationPathSegmentsForProjection(
|
|||
|
|
points []moon.OccultationPathPoint,
|
|||
|
|
projection svgmap.Projection,
|
|||
|
|
) [][]moon.OccultationPathPoint {
|
|||
|
|
if projection == svgmap.ProjectionEquirectangular {
|
|||
|
|
return starOccultationPathSegments(points)
|
|||
|
|
}
|
|||
|
|
geographic := make([]svgmap.GeoPoint, len(points))
|
|||
|
|
for index, point := range points {
|
|||
|
|
geographic[index] = svgmap.GeoPoint{Longitude: point.Longitude, Latitude: point.Latitude}
|
|||
|
|
}
|
|||
|
|
clipped := svgmap.PolylineSegments(geographic, projection)
|
|||
|
|
result := make([][]moon.OccultationPathPoint, 0, len(clipped))
|
|||
|
|
for _, segment := range clipped {
|
|||
|
|
converted := make([]moon.OccultationPathPoint, len(segment))
|
|||
|
|
for index, point := range segment {
|
|||
|
|
converted[index] = moon.OccultationPathPoint{Longitude: point.Longitude, Latitude: point.Latitude}
|
|||
|
|
}
|
|||
|
|
result = append(result, converted)
|
|||
|
|
}
|
|||
|
|
return result
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationAntimeridianCrossing(a, b moon.OccultationPathPoint) (float64, float64, bool) {
|
|||
|
|
if math.Abs(b.Longitude-a.Longitude) <= 180 {
|
|||
|
|
return 0, 0, false
|
|||
|
|
}
|
|||
|
|
boundary := 180.0
|
|||
|
|
adjustedB := b.Longitude
|
|||
|
|
if a.Longitude < 0 {
|
|||
|
|
boundary = -180
|
|||
|
|
adjustedB -= 360
|
|||
|
|
} else {
|
|||
|
|
adjustedB += 360
|
|||
|
|
}
|
|||
|
|
denominator := adjustedB - a.Longitude
|
|||
|
|
if math.Abs(denominator) < 1e-12 {
|
|||
|
|
return 0, 0, false
|
|||
|
|
}
|
|||
|
|
fraction := (boundary - a.Longitude) / denominator
|
|||
|
|
if fraction <= 0 || fraction >= 1 {
|
|||
|
|
return 0, 0, false
|
|||
|
|
}
|
|||
|
|
return boundary, fraction, true
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationInterpolatePathPoint(a, b moon.OccultationPathPoint, fraction, longitude float64) moon.OccultationPathPoint {
|
|||
|
|
if fraction < 0 {
|
|||
|
|
fraction = 0
|
|||
|
|
}
|
|||
|
|
if fraction > 1 {
|
|||
|
|
fraction = 1
|
|||
|
|
}
|
|||
|
|
duration := b.Time.Sub(a.Time)
|
|||
|
|
return moon.OccultationPathPoint{
|
|||
|
|
Time: a.Time.Add(time.Duration(float64(duration) * fraction)),
|
|||
|
|
Longitude: longitude,
|
|||
|
|
Latitude: a.Latitude + (b.Latitude-a.Latitude)*fraction,
|
|||
|
|
MoonAltitude: a.MoonAltitude + (b.MoonAltitude-a.MoonAltitude)*fraction,
|
|||
|
|
WidthKM: a.WidthKM + (b.WidthKM-a.WidthKM)*fraction,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationBandSegments(
|
|||
|
|
northern, southern []moon.OccultationPathPoint,
|
|||
|
|
) [][]starOccultationGeoPoint {
|
|||
|
|
return starOccultationBandFragments(northern, southern, svgmap.ProjectionEquirectangular)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationBandFragments(
|
|||
|
|
northern, southern []moon.OccultationPathPoint,
|
|||
|
|
projection svgmap.Projection,
|
|||
|
|
) [][]starOccultationGeoPoint {
|
|||
|
|
count := len(northern)
|
|||
|
|
if len(southern) < count {
|
|||
|
|
count = len(southern)
|
|||
|
|
}
|
|||
|
|
if count < 2 {
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
polygon := make([]starOccultationGeoPoint, 0, 2*count)
|
|||
|
|
for _, point := range northern[:count] {
|
|||
|
|
polygon = append(polygon, starOccultationGeoPoint{point.Longitude, point.Latitude})
|
|||
|
|
}
|
|||
|
|
for index := count - 1; index >= 0; index-- {
|
|||
|
|
point := southern[index]
|
|||
|
|
polygon = append(polygon, starOccultationGeoPoint{point.Longitude, point.Latitude})
|
|||
|
|
}
|
|||
|
|
geographic := make([]svgmap.GeoPoint, len(polygon))
|
|||
|
|
for index, point := range polygon {
|
|||
|
|
geographic[index] = svgmap.GeoPoint{Longitude: point.longitude, Latitude: point.latitude}
|
|||
|
|
}
|
|||
|
|
fragments := svgmap.PolygonFragments(geographic, projection)
|
|||
|
|
segments := make([][]starOccultationGeoPoint, 0, len(fragments))
|
|||
|
|
for _, fragment := range fragments {
|
|||
|
|
converted := make([]starOccultationGeoPoint, len(fragment))
|
|||
|
|
for index, point := range fragment {
|
|||
|
|
converted[index] = starOccultationGeoPoint{longitude: point.Longitude, latitude: point.Latitude}
|
|||
|
|
}
|
|||
|
|
if math.Abs(starOccultationPolygonArea(converted)) > 1e-9 {
|
|||
|
|
segments = append(segments, converted)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return segments
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func legacyStarOccultationBandSegments(polygon []starOccultationGeoPoint) [][]starOccultationGeoPoint {
|
|||
|
|
polygon = starOccultationUnwrapPolygon(polygon)
|
|||
|
|
minimumLongitude, maximumLongitude := polygon[0].longitude, polygon[0].longitude
|
|||
|
|
for _, point := range polygon[1:] {
|
|||
|
|
minimumLongitude = math.Min(minimumLongitude, point.longitude)
|
|||
|
|
maximumLongitude = math.Max(maximumLongitude, point.longitude)
|
|||
|
|
}
|
|||
|
|
firstWorld := int(math.Floor((minimumLongitude + 180) / 360))
|
|||
|
|
lastWorld := int(math.Floor((maximumLongitude + 180) / 360))
|
|||
|
|
segments := make([][]starOccultationGeoPoint, 0, lastWorld-firstWorld+1)
|
|||
|
|
for world := firstWorld; world <= lastWorld; world++ {
|
|||
|
|
left := -180.0 + 360*float64(world)
|
|||
|
|
right := 180.0 + 360*float64(world)
|
|||
|
|
clipped := starOccultationClipPolygonLongitude(polygon, left, true)
|
|||
|
|
clipped = starOccultationClipPolygonLongitude(clipped, right, false)
|
|||
|
|
if len(clipped) < 3 {
|
|||
|
|
continue
|
|||
|
|
}
|
|||
|
|
for index := range clipped {
|
|||
|
|
clipped[index].longitude -= 360 * float64(world)
|
|||
|
|
}
|
|||
|
|
if math.Abs(starOccultationPolygonArea(clipped)) > 1e-9 {
|
|||
|
|
segments = append(segments, clipped)
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return segments
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationUnwrapPolygon(points []starOccultationGeoPoint) []starOccultationGeoPoint {
|
|||
|
|
if len(points) < 2 {
|
|||
|
|
return points
|
|||
|
|
}
|
|||
|
|
unwrapped := make([]starOccultationGeoPoint, len(points))
|
|||
|
|
unwrapped[0] = points[0]
|
|||
|
|
for index := 1; index < len(points); index++ {
|
|||
|
|
point := points[index]
|
|||
|
|
previous := unwrapped[index-1].longitude
|
|||
|
|
for point.longitude-previous > 180 {
|
|||
|
|
point.longitude -= 360
|
|||
|
|
}
|
|||
|
|
for point.longitude-previous < -180 {
|
|||
|
|
point.longitude += 360
|
|||
|
|
}
|
|||
|
|
unwrapped[index] = point
|
|||
|
|
}
|
|||
|
|
return unwrapped
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationClipPolygonLongitude(
|
|||
|
|
points []starOccultationGeoPoint,
|
|||
|
|
boundary float64,
|
|||
|
|
keepGreater bool,
|
|||
|
|
) []starOccultationGeoPoint {
|
|||
|
|
if len(points) == 0 {
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
inside := func(point starOccultationGeoPoint) bool {
|
|||
|
|
if keepGreater {
|
|||
|
|
return point.longitude >= boundary
|
|||
|
|
}
|
|||
|
|
return point.longitude <= boundary
|
|||
|
|
}
|
|||
|
|
intersect := func(a, b starOccultationGeoPoint) starOccultationGeoPoint {
|
|||
|
|
fraction := (boundary - a.longitude) / (b.longitude - a.longitude)
|
|||
|
|
return starOccultationGeoPoint{
|
|||
|
|
longitude: boundary,
|
|||
|
|
latitude: a.latitude + (b.latitude-a.latitude)*fraction,
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
clipped := make([]starOccultationGeoPoint, 0, len(points)+2)
|
|||
|
|
previous := points[len(points)-1]
|
|||
|
|
previousInside := inside(previous)
|
|||
|
|
for _, current := range points {
|
|||
|
|
currentInside := inside(current)
|
|||
|
|
if currentInside != previousInside {
|
|||
|
|
clipped = append(clipped, intersect(previous, current))
|
|||
|
|
}
|
|||
|
|
if currentInside {
|
|||
|
|
clipped = append(clipped, current)
|
|||
|
|
}
|
|||
|
|
previous = current
|
|||
|
|
previousInside = currentInside
|
|||
|
|
}
|
|||
|
|
return clipped
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationPolygonArea(points []starOccultationGeoPoint) float64 {
|
|||
|
|
area := 0.0
|
|||
|
|
for index, point := range points {
|
|||
|
|
next := points[(index+1)%len(points)]
|
|||
|
|
area += point.longitude*next.latitude - next.longitude*point.latitude
|
|||
|
|
}
|
|||
|
|
return area / 2
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSVGHeaderLines(path moon.StarOccultationPath, options StarOccultationSVGOptions) []string {
|
|||
|
|
lines := make([]string, 0, 4)
|
|||
|
|
for _, item := range []struct {
|
|||
|
|
text string
|
|||
|
|
fontSize float64
|
|||
|
|
}{
|
|||
|
|
{starOccultationSVGSummaryText(path, options), 14},
|
|||
|
|
{starOccultationSVGGreatestText(path, options), 13},
|
|||
|
|
} {
|
|||
|
|
lines = append(lines, starOccultationWrapText(item.text, float64(options.Width)-80, item.fontSize)...)
|
|||
|
|
}
|
|||
|
|
return lines
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSVGTitle(path moon.StarOccultationPath, options StarOccultationSVGOptions) string {
|
|||
|
|
if options.Title != "" {
|
|||
|
|
return options.Title
|
|||
|
|
}
|
|||
|
|
target := path.TargetID
|
|||
|
|
if target == "" {
|
|||
|
|
if options.Language == starOccultationSVGLanguageEnglish {
|
|||
|
|
target = "star"
|
|||
|
|
} else {
|
|||
|
|
target = "恒星"
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
date := path.Greatest.Time.In(options.Location).Format("2006-01-02")
|
|||
|
|
if options.Language == starOccultationSVGLanguageEnglish {
|
|||
|
|
return fmt.Sprintf("%s Lunar Occultation of %s", date, target)
|
|||
|
|
}
|
|||
|
|
return fmt.Sprintf("%s 月掩%s全球掩带", date, target)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSVGSummaryText(path moon.StarOccultationPath, options StarOccultationSVGOptions) string {
|
|||
|
|
if options.SummaryText != "" {
|
|||
|
|
return options.SummaryText
|
|||
|
|
}
|
|||
|
|
start := path.Start.Time.In(options.Location)
|
|||
|
|
greatest := path.Greatest.Time.In(options.Location)
|
|||
|
|
end := path.End.Time.In(options.Location)
|
|||
|
|
zone := starOccultationLocationLabel(greatest, options.Location)
|
|||
|
|
if options.Language == starOccultationSVGLanguageEnglish {
|
|||
|
|
return fmt.Sprintf("Start %s | Greatest %s | End %s (%s)",
|
|||
|
|
starOccultationFormatEventTime(start, true),
|
|||
|
|
starOccultationFormatEventTime(greatest, !starOccultationSameDate(start, greatest)),
|
|||
|
|
starOccultationFormatEventTime(end, !starOccultationSameDate(start, end)), zone)
|
|||
|
|
}
|
|||
|
|
return fmt.Sprintf("掩始 %s | 掩甚 %s | 掩终 %s (%s)",
|
|||
|
|
starOccultationFormatEventTime(start, true),
|
|||
|
|
starOccultationFormatEventTime(greatest, !starOccultationSameDate(start, greatest)),
|
|||
|
|
starOccultationFormatEventTime(end, !starOccultationSameDate(start, end)), zone)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSVGGreatestText(path moon.StarOccultationPath, options StarOccultationSVGOptions) string {
|
|||
|
|
if options.GreatestText != "" {
|
|||
|
|
return options.GreatestText
|
|||
|
|
}
|
|||
|
|
coordinates := starOccultationFormatCoordinates(path.Greatest.Longitude, path.Greatest.Latitude)
|
|||
|
|
altitude := starOccultationFormatSignedDegree(path.Greatest.MoonAltitude)
|
|||
|
|
if options.Language == starOccultationSVGLanguageEnglish {
|
|||
|
|
return fmt.Sprintf("Greatest point %s | path width %.1f km | Moon altitude %s", coordinates, path.Greatest.WidthKM, altitude)
|
|||
|
|
}
|
|||
|
|
return fmt.Sprintf("掩甚点 %s | 掩带宽 %.1f km | 月球高度 %s", coordinates, path.Greatest.WidthKM, altitude)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSVGMapTitle(options StarOccultationSVGOptions) string {
|
|||
|
|
if options.MapTitle != "" {
|
|||
|
|
return options.MapTitle
|
|||
|
|
}
|
|||
|
|
if options.Language == starOccultationSVGLanguageEnglish {
|
|||
|
|
return "Global center line and occultation limits"
|
|||
|
|
}
|
|||
|
|
return "全球中心线与掩带边界"
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSVGContactsTitle(options StarOccultationSVGOptions) string {
|
|||
|
|
if options.ContactsTitle != "" {
|
|||
|
|
return options.ContactsTitle
|
|||
|
|
}
|
|||
|
|
if options.Language == starOccultationSVGLanguageEnglish {
|
|||
|
|
return "Global events"
|
|||
|
|
}
|
|||
|
|
return "全球事件"
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSVGFooter(options StarOccultationSVGOptions) string {
|
|||
|
|
if options.FooterNote != "" {
|
|||
|
|
return options.FooterNote
|
|||
|
|
}
|
|||
|
|
projection := starOccultationProjectionLabel(options.Projection, options.Language)
|
|||
|
|
if options.Language == starOccultationSVGLanguageEnglish {
|
|||
|
|
return fmt.Sprintf("%s with Natural Earth 1:50m physical land and no administrative boundaries. Limits use the outer lunar limb on the Earth ellipsoid.", projection)
|
|||
|
|
}
|
|||
|
|
return fmt.Sprintf("%s；Natural Earth 1:50m 物理陆地底图，不含行政边界；掩带边界为地球椭球上的月球外缘投影。", projection)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationProjectionLabel(projection MapProjection, language string) string {
|
|||
|
|
if language == starOccultationSVGLanguageEnglish {
|
|||
|
|
switch projection {
|
|||
|
|
case MapProjectionNorthPolar:
|
|||
|
|
return "North-polar azimuthal equidistant projection"
|
|||
|
|
case MapProjectionSouthPolar:
|
|||
|
|
return "South-polar azimuthal equidistant projection"
|
|||
|
|
default:
|
|||
|
|
return "Equirectangular projection"
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
switch projection {
|
|||
|
|
case MapProjectionNorthPolar:
|
|||
|
|
return "北极方位等距投影"
|
|||
|
|
case MapProjectionSouthPolar:
|
|||
|
|
return "南极方位等距投影"
|
|||
|
|
default:
|
|||
|
|
return "等经纬投影"
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSVGEventRows(path moon.StarOccultationPath, language string) []starOccultationEventRow {
|
|||
|
|
names := []string{"掩始", "掩甚", "掩终"}
|
|||
|
|
if language == starOccultationSVGLanguageEnglish {
|
|||
|
|
names = []string{"Start", "Greatest", "End"}
|
|||
|
|
}
|
|||
|
|
return []starOccultationEventRow{
|
|||
|
|
{name: names[0], point: path.Start},
|
|||
|
|
{name: names[1], point: path.Greatest},
|
|||
|
|
{name: names[2], point: path.End},
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationFormatEventTime(value time.Time, withDate bool) string {
|
|||
|
|
layout := "15:04:05.0"
|
|||
|
|
if withDate {
|
|||
|
|
layout = "2006-01-02 15:04:05.0"
|
|||
|
|
}
|
|||
|
|
return value.Format(layout)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationFormatCoordinates(longitude, latitude float64) string {
|
|||
|
|
longitudeSuffix := "E"
|
|||
|
|
if longitude < 0 {
|
|||
|
|
longitudeSuffix = "W"
|
|||
|
|
}
|
|||
|
|
latitudeSuffix := "N"
|
|||
|
|
if latitude < 0 {
|
|||
|
|
latitudeSuffix = "S"
|
|||
|
|
}
|
|||
|
|
return fmt.Sprintf("%.4f°%s, %.4f°%s", math.Abs(longitude), longitudeSuffix, math.Abs(latitude), latitudeSuffix)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationFormatSignedDegree(value float64) string {
|
|||
|
|
return fmt.Sprintf("%+.1f°", value)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationLocationLabel(value time.Time, location *time.Location) string {
|
|||
|
|
if location == time.UTC {
|
|||
|
|
return "UTC"
|
|||
|
|
}
|
|||
|
|
name, offset := value.Zone()
|
|||
|
|
if name != "" && name != "Local" {
|
|||
|
|
return name
|
|||
|
|
}
|
|||
|
|
hours := float64(offset) / 3600
|
|||
|
|
return fmt.Sprintf("UTC%+.1f", hours)
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationSameDate(first, second time.Time) bool {
|
|||
|
|
y1, m1, d1 := first.Date()
|
|||
|
|
y2, m2, d2 := second.Date()
|
|||
|
|
return y1 == y2 && m1 == m2 && d1 == d2
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationWrapText(value string, maxWidth, fontSize float64) []string {
|
|||
|
|
value = strings.TrimSpace(value)
|
|||
|
|
if value == "" {
|
|||
|
|
return nil
|
|||
|
|
}
|
|||
|
|
if starOccultationTextWidth(value, fontSize) <= maxWidth {
|
|||
|
|
return []string{value}
|
|||
|
|
}
|
|||
|
|
runes := []rune(value)
|
|||
|
|
lines := make([]string, 0, 2)
|
|||
|
|
for len(runes) > 0 {
|
|||
|
|
width := 0.0
|
|||
|
|
end := 0
|
|||
|
|
lastSpace := -1
|
|||
|
|
for end < len(runes) {
|
|||
|
|
nextWidth := width + starOccultationRuneWidth(runes[end], fontSize)
|
|||
|
|
if nextWidth > maxWidth && end > 0 {
|
|||
|
|
break
|
|||
|
|
}
|
|||
|
|
width = nextWidth
|
|||
|
|
if unicode.IsSpace(runes[end]) {
|
|||
|
|
lastSpace = end
|
|||
|
|
}
|
|||
|
|
end++
|
|||
|
|
}
|
|||
|
|
if end < len(runes) && lastSpace > 0 {
|
|||
|
|
end = lastSpace
|
|||
|
|
}
|
|||
|
|
if end == 0 {
|
|||
|
|
end = 1
|
|||
|
|
}
|
|||
|
|
line := strings.TrimSpace(string(runes[:end]))
|
|||
|
|
if line != "" {
|
|||
|
|
lines = append(lines, line)
|
|||
|
|
}
|
|||
|
|
runes = runes[end:]
|
|||
|
|
for len(runes) > 0 && unicode.IsSpace(runes[0]) {
|
|||
|
|
runes = runes[1:]
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return lines
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationTitleFontSize(title string, width float64) int {
|
|||
|
|
for size := 26; size >= 16; size-- {
|
|||
|
|
if starOccultationTextWidth(title, float64(size)) <= width-80 {
|
|||
|
|
return size
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return 16
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationTextWidth(value string, fontSize float64) float64 {
|
|||
|
|
width := 0.0
|
|||
|
|
for _, current := range value {
|
|||
|
|
width += starOccultationRuneWidth(current, fontSize)
|
|||
|
|
}
|
|||
|
|
return width
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationRuneWidth(value rune, fontSize float64) float64 {
|
|||
|
|
if unicode.Is(unicode.Han, value) || value > utf8.RuneSelf {
|
|||
|
|
return fontSize
|
|||
|
|
}
|
|||
|
|
if unicode.IsSpace(value) {
|
|||
|
|
return fontSize * 0.34
|
|||
|
|
}
|
|||
|
|
return fontSize * 0.58
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
func starOccultationFinite(value float64) bool {
|
|||
|
|
return !math.IsNaN(value) && !math.IsInf(value, 0)
|
|||
|
|
}
|