Is there a way to quickly filter the loaded Hipparcos dataframe by proximity to coordinate (ra, dec)?

[ursomniac]

So I have a bunch of routines that generate maps. But the part that plunks down stars for any of them is REALLY inefficient:

def map_hipparcos(ax, earth, t, mag_limit, projection, mag_offset=0.25, reversed=False):
    """
    Put down sized points for stars.
    While this DOES pre-filter by mag_limit it does NOT filter
    by proximity to the center of the map and its scale!
    """
    with load.open(hipparcos.URL) as f:
        stars = hipparcos.load_dataframe(f)
    # Compute the X,Y coordinates of stars on the plot
    star_positions = earth.at(t).observe(Star.from_dataframe(stars))
    stars['x'], stars['y'] = projection(star_positions)
    bright_stars = (stars.magnitude <= mag_limit)
    magnitude = stars['magnitude'][bright_stars]
    marker_size = (mag_offset + mag_limit - magnitude) **2.0 
    ##### background stars
    star_color = 'w' if reversed else 'k'
    scatter = ax.scatter(
        stars['x'][bright_stars], stars['y'][bright_stars], 
        s=marker_size, color=star_color
    )
    return ax, stars

So - the problem is the `scatter = ax.scatter( things... ) call since it's basically plotting the entire sky even if the scale of the actual plotting window is only a few degrees. So this slows things down (not an insane amount but I'm trying to make things more efficient overall).

Can anyone suggest how I might add code, along the lines of:

1. Given a central (ra,dec), and a somewhat-unstrict FOV (e.g., 10° is fine if my real FOV is 8° or even 5°)
2. return a dataframe that only includes those proximate stars?

I know I could deliberately send an ra_range and dec_range but that stuff gets really messy (crossing 0h, over the poles, etc.) - generating some kind of angular_distance_from_coords column would be ideal because then it's just

proximate_stars = (stars.angular_distance_from_coords < whatever_my_desired_radius_is) :-)

Note: I'm SLOWLY ramping up on a github repo that has the whole kitchen sink for setting up and logging observing (both SSOs and DSOs) that I've been using for about 3 years (gee - since I discovered Skyfield!). It uses quite a bit of this library's features (thank you thank you thank you for aiding me in NOT reinventing the wheel!).

[ursomniac]

And some of the sample maps that I generate...

1. overall sky plot (there's a simpler version option) (red dots = brightest asteroids; yellow hexagons = brightest comets; green clovers, orange stars, and blue diamonds, TBD :-) )

2. Atlas plate (258 in all)

3. Narrow field for a DSO showing other DSOs in the field

4. Wide field showing other nearby DSOs

5. Custom based on a user-provided list of DSOs (basically "what's on the observing list for tonight?")

The overlay rectangles on the DSO field plots are for my wide eyepiece, and the Unistellar eQuinox2, Seestar S50, and Seestar S30 (the "fleet").

[brandon-rhodes]

These are amazing! The Atlas plate reminds me of the Uranometria 2000.0, it looks very usable while carrying a lot of information.

[brandon-rhodes]

All right, I'm starting a new thread, separate from your nice images, to discuss the efficiency issue. My first question is about this line:

stars['x'], stars['y'] = projection(star_positions)

Is it running in a reasonable amount of time? If so then you could do the filtering as the next step, because that line of code is doing the computation you want: it's figuring out how far every star is from the RA and dec of the center position. But instead of returning the distance from the target as a single angle, it's returning it decomposed into x and y.

So I can imaging two approaches.

First, you could use Pythagoras to compute a distance from x and y, and then filter out stars where that distance was too great.

Or you could be even more direct. If you know the x width of your image, and y height of your image, then something like this could be the filter:

(abs(x) < plot_half_width) and (abs(y) < plot_half_height)

That would select only the stars that will fit within the bounding box of the plot, so your call to Matplotlib wouldn't be given any stars that would wind up off of the plot.