(Show & Tell) telrad field of views for Messier objects

[bathoorn]

Currently in am working on creating little telrad views to help me in finding Messier objects.
I am also building a new telrad that projects a bigger circle (telrad max circle is 4 degrees) of 16 degrees.

The code below selects a messier objects and shows it in the middle of a 16 degree wide image of the sky
with all the telrad circles shown in red around it.

Here are some examples of M42 and M13

And the code to generate them

import numpy as np
from matplotlib import pyplot as plt
from matplotlib.collections import LineCollection, PatchCollection
from matplotlib.patches import Circle

from skyfield.api import Star, load, wgs84, N, S, W, E
from skyfield.data import hipparcos, mpc, stellarium
import dsos
from skyfield.projections import build_stereographic_projection
from datetime import datetime
from pytz import timezone

# time `t` we use for everything else.

AMS = timezone('Europe/Amsterdam')
ts = load.timescale()
t = ts.from_datetime(AMS.localize(datetime(2022, 1, 19, 22, 0, 0)))
# 180 = South 0 = North
degrees = 0.0


amsterdam = wgs84.latlon(52.377956*N, 4.897070*E, elevation_m=28).at(t)
position = amsterdam.from_altaz(alt_degrees=90, az_degrees=degrees)

# An ephemeris from the JPL provides Sun and Earth positions.

eph = load('de421.bsp')
sun = eph['sun']
earth = eph['earth']

# The Hipparcos mission provides our star catalog.

with load.open(hipparcos.URL) as f:
    stardata = hipparcos.load_dataframe(f)

# DSO's from stellarium

with open('catalog.txt') as f:
    dsodata = dsos.load_dataframe(f)

# And the constellation outlines come from Stellarium.  We make a list
# of the stars at which each edge stars, and the star at which each edge
# ends.

url = ('https://raw.githubusercontent.com/Stellarium/stellarium/master'
       '/skycultures/modern_st/constellationship.fab')

with load.open(url) as f:
    consdata = stellarium.parse_constellations(f)

url2 = ('https://raw.githubusercontent.com/Stellarium/stellarium/master'
       '/skycultures/modern_st/star_names.fab')

with load.open(url2) as f2:
    star_names = stellarium.parse_star_names(f2)


def generate_constellation_lines(data, polygon=False):
    edges = [edge for name, edges in data for edge in edges]
    edges_star1 = [star1 for star1, star2 in edges]
    edges_star2 = [star2 for star1, star2 in edges]
    xy1 = stardata[['x', 'y']].loc[edges_star1].values
    xy2 = stardata[['x', 'y']].loc[edges_star2].values

    if polygon:
        return [xy1]
    else:

        # The constellation lines will each begin at the x,y of one star and end
        # at the x,y of another.  We have to "rollaxis" the resulting coordinate
        # array into the shape that matplotlib expects.

        return np.rollaxis(np.array([xy1, xy2]), 1)


# Center on Orion nebula as an example
# select the DSO you want centered in the view
target = (dsodata.label == "M13")
for i, d in dsodata[target].iterrows():
    hip = i
    target_dso = d

center = earth.at(t).observe(Star.from_dataframe(dsodata[target]))
projection = build_stereographic_projection(center)
field_of_view_degrees = 16.0
limiting_magnitude = 4.0
dso_limit_magnitude = 6.0

# Now that we have constructed our projection, compute the x and y
# coordinates that each star will have on the plot.

star_positions = earth.at(t).observe(Star.from_dataframe(stardata))
stardata['x'], stardata['y'] = projection(star_positions)

# Create a True/False mask marking the stars bright enough to be
# included in our plot.  And go ahead and compute how large their
# markers will be on the plot.

bright_stars = (stardata.magnitude <= limiting_magnitude)
magnitude = stardata['magnitude'][bright_stars]
marker_size = (5.0 + limiting_magnitude - magnitude) ** 2.0

# Time to build the figure!

fig, ax = plt.subplots(figsize=[12, 12])

# Draw telrad circles

def telrad_radius(degrees):
    telrad_angle = np.pi - degrees / 360.0 * np.pi
    telrad_radius = np.sin(telrad_angle) / (1.0 - np.cos(telrad_angle))
    return telrad_radius

telrad = []
for deg in [16, 8, 4, 2, 0.2]:
    telrad.append(Circle((0, 0), telrad_radius(deg)))
ax.add_collection(PatchCollection(telrad, edgecolors='red', facecolors='white', zorder=-2))


# Draw the constellation lines.

constellations = LineCollection(generate_constellation_lines(consdata),
                                colors='#00f2', linewidths=1, zorder=-1, alpha=0.5)
ax.add_collection(constellations)


# Draw the stars.

ax.scatter(stardata['x'][bright_stars], stardata['y'][bright_stars],
           s=marker_size, color='k')

# Finally, title the plot and set some final parameters.

angle = np.pi - field_of_view_degrees / 360.0 * np.pi
limit = np.sin(angle) / (1.0 - np.cos(angle))

for i, s in stardata[bright_stars].iterrows():
    if -limit < s['x'] < limit and -limit < s['y'] < limit:
        star = [star for star in star_names if star.hip == i]
        if len(star) == 1:
            print(f"star {star[0].name} mag {s['magnitude']}")
            ax.text(s['x'] + 0.002, s['y'] - 0.002, star[0].name, color='k',
                    ha='left', va='top', fontsize=9, weight='bold', zorder=1).set_alpha(0.5)


print(f"dso {target_dso}")
ax.text(0, -0.06, target_dso['label'], color='red',
        ha='center', va='top', fontsize=16, weight='bold', zorder=1).set_alpha(0.5)


ax.set_xlim(-limit, limit)
ax.set_ylim(-limit, limit)
ax.xaxis.set_visible(True)
ax.yaxis.set_visible(True)
ax.set_aspect(1.0)
ax.set_title(f"{target_dso['label']} on {t.utc_strftime('%Y %B %d %H:%M')}")

# Save.

fig.savefig(f"{target_dso['label']}.png", bbox_inches='tight')