This article is about a new piece of software I developed over the past few years: A telescope focus finder software for Linux (and maybe later Windows).
At the time of publication this project is not even in ALPHA state. However, I feel now is the right time to publish it since it reached a state where at least the source code could be useful to others. You can find the source code on github here.
The software aims to support the amateur astronomer (and especially astrophotographer) with one of the most critical but also most annoying tasks: Finding the best focus position for the camera. The main goal is to provide a free and easy to use software that just does the job – automatically.
With a given configuration it should also be possible to execute “FoFi” from the command-line without requiring any user interaction. This way you can include a call to the Focus Finder into a script. This might be useful if the entire observation process should be automated and you want to re-focus from time to time to compensate the temperature drift.
Continue reading →
In this article I shown a C++ implementation of the “max entropy” threshold algorithm using the CImg library. This implementation also performs for 16 and 32 bit / float images.
First, a little bit of context: Some time ago I implemented the OTSU threshold algorithm as a pre-processing step for image binarization. I used that threshold algorithm to distinguish the noise pixels from the potential “star” pixels. This worked quite well for the high contrast input images at that time. However, for weak stars it unfortunately failed badly.
Continue reading →
Calculation of a SNR for stars
This article shows how to calculate the 2D signal-to-noise ratio (SNR). Furthermore, it demonstrates how the $SNR$ can be used to decide if there is a potential star in the image.
Long story short – I was looking for a way to detect more or less reliably if a user selected a region which contains a star. I wanted to be able to clearly distinguish between the following two images:
Solution with the CImg library
After a long journey I finally ended up with the following solution. It is based on the CImg library which in a way calculates the Signal-to-noise ratio (SNR):
CImg <uint16_t> image;
double q = image.variance(0) / image.variance_noise(0);
double qClip = (q > 1 ? q : 1);
double snr = std::sqrt(qClip - 1);
For the two images above the code gives the following results:
~/snr$ ./snr no_star.fits
~snr$ ./snr test_star.fits
For many people this is where the journey ends. But for some of you it may just begin :). Follow me into the rabbit hole and find out why the solution shown above actually works…
Continue reading →
This article is about finding the best possible telescope focus by approximating a V-Curve with a hyperbolic function.
What is a V-Curve?
A V-Curve is the result of moving the focus of a telescope from an outside focus position into the focus and then further into the same direction out of focus again. This way a V-Curve comes into existence where the focus position is on the x-axis and the focus measure on the y-axis (right figure). Probably not surprising this curve is called V-Curve since it is similar to a V. There are different ways to measure the focus – for example the “Half-Flux Diameter” (HFD) and the “Full width at half maximum” (FWHM). In this case the I use the HFD measure.
Continue reading →
End of last year me and my colleagues had the chance to submit a paper to the 19th “Methods and Description Languages for Modelling and Verification of Circuits and Systems” workshop (in German “Methoden und Beschreibungssprachen zur Modellierung und Verifikation von Schaltungen und Systemen” – in short MBMV). This year the conference took place at the University of Freiburg.
In principle we avoid exporting any data from the C++ process to a database since archiving data in this context is not important. Instead we need direct insight into certain data of the process while the C++ application is still running. In our case we use data from the C++ application to present an electrical circuit to the user directly in the browser (using SVG). The rendering of the circuit itself is done by the C++ application. The generated SVG is then returned to the browser (see figure).
One important idea behind the concept is that the interface between PHP and the C++ process is automatically generated using SWIG – the so called “Simple Wrapper and Interface Generator”. SWIG is an open source tool which currently supports the mapping from C/C++ to about 24 different scripting languages (c.f. www.swig.org). Therefore, in principle the usage of PHP could be replaced by any other supported scripting language like Python or Perl.
In the end, the only thing left to the developer is writing the SWIG interface file which lists the classes and functions which should be available from the scripting language. The syntax of this file is very close to the C++ syntax. The concept allows a web developer to write common PHP/Python code to model the front-end. If data or functionality from the C++ process is required the developer simply uses the generated PHP interface.
Note that SWIG supports access to most STL containers out of the box (depending on the scripting language). Hence, it is for example very simple to iterate over an STL vector in PHP and the further process the content in the scripting language – for example returning it in JSON format.
Last updated: June 16, 2022 at 14:17 pm