Solving very wide FOV images (86 deg)

[StijnHandgraaf]

Hello everyone,

For a thesis project I am building a very low-cost star tracker based on a Raspberry Pi camera. This camera has an FOV between 85-90 degrees diagonally and is thus very wide. Previously, I have used the Astrometry.net code to solve my images, but these took around 10 seconds each to solve. Ideally, I would like to go down to below 1 second. Hence, I tried running the tetra3 code, but I could not get the program to solve my images. I would like to know if the cedar-solve is able to solve them, or that the very wide FOV is too much of a hassle for the program.

My situation is the following:

1. The FOV of the images are rougly 86x48.
2. The images are screenshots from Stellarium, where each star has been lowered in size to a single pixel.
3. I was able to tune the centroid finder of tetra3 to such a degree that almost all stars were detected.
4. The star magnitude is at best 5. Therefore I created a database with 'bsc5' with a maximum magnitude of 5.
5. I did not get an error message when solving from centroids, just an empty dictionary with {RA: None, Dec: None}

Let me know if you think very wide FOV images can be solved with cedar-solve, or what steps I need to do in order to make it work. Thanks!

[smroid]

At max mag=5, how many stars do your images have? What projection method is Stellarium using to create its images?

I have been able to solve large FOV images from my Pixel 6, around 80deg. Can you post one of your images so that we can investigate?

Thanks!

[smroid]

Also, do you have any star images from your Rpi camera? Those might be better than synthesized images because the real camera images will (by definition) be properly projected and will preserve the relative brightness of stars.

[StijnHandgraaf]

Gnomonic projection is equal to the 'Perspective' setting from Stellarium, so then that should be fine. I think that the fact that all stars are a single pixel and roughly equal in intensity is what is causing the issues then.

I do not have star images yet since I live in the most light polluted city of Europe. Therefore, I decided I could use a monitor setup similar to what star tracker companies use. I will make star images with the camera next month and hope that it is able to solve the images then.

[smroid]

If you can generate perspective-projected images with intensity preserved, and still are not able to solve them, please post an example and I'll take a look. Also please give the parameters you used to generate your pattern database.

Light pollution might not be an insurmountable obstacle. The images don't need to look great, they just need reasonably focused stars and you only need 20-50 discernible stars across the field.

(Please note: I'm busy for the next couple of weeks so can only provide drive-by advice...)

[StijnHandgraaf]

I tried to solve the perspective-projected images with clear differences in brightness between the stars, but it still yielded no successes. Again, the centroids were easily found, but it failed to solve the patterns and returned 'None'. I will post all my settings here

Database generation

t3.generate_database(star_catalog='bsc5', max_fov=86, star_max_magnitude=5, pattern_max_error=0.005, multiscale_step=1.1, save_as='personaldatabasename')

Centroid estimation

t3_test_image_path = "stellarium-Relative-10.png"
t3_test_image = Image.open(t3_test_image_path).convert("L")

centroids = get_centroids_from_image(t3_test_image,
                                     image_th=20, 
                                     sigma=2, 
                                     min_area=1, 
                                     max_area=100,
                                     filtsize=25,
                                     bg_sub_mode='local_mean',
                                     sigma_mode='local_median_abs',
                                     crop=1,
                                     downsample=1,
                                     binary_open=False,
                                     return_moments=False, 
                                     return_images=False)
# print(centroids)
# print(type(centroids))
# print(centroids[-1])
# last_key, last_image = list(centroids[-1].items())[-1]
# last_image.show()  # to show, uncomment these lines and set return_images=True

Solve from centroids

result = t3.solve_from_centroids(centroids, 
                                 size=(t3_test_image.size[1], t3_test_image.size[0]), 
                                 fov_estimate=86, 
                                 fov_max_error=5,
                                 match_radius=0.01,
                                 distortion=(0,10),
                                #  match_threshold=0.01,
                                #  solve_timeout=10000,
                                 return_matches=True, 
                                 return_visual=True)
print(result)

Input files

Database will follow in the next comment. EDIT: it appears I cannot add database files here since those are not supported by github?

[smroid]

These latest images look good. No need to post the database file, I can generate one using your parameters (but as I mentioned I won't be able to spend time on this for a couple of weeks).

For the solve call, try dropping the fov arguments and the distortion arg. Also verify that you're passing (height, width) and not (width, height).

Also, look at your 'centroids' list and verify that it makes sense w.r.t. the image, and in particular that brightest stars are coming first.

[jscheidtmann]

If you've got a Windows PC and ASCOM/Alpaca there's also https://sourceforge.net/projects/sky-simulator/ from the Author of HNSKY and ASTAP (another platesolver). Seems that also has a linux version. Maybe you can convince that program to create such a large image as you want.