Mars is getting really close to 2016 opposition, the best in the last 10 years, since it’s very close to earth.
Weather in Milan wasn’t great these days, so me and Alessia tried to catch the first night offering a clear sky and a possibly good seeing.

We were pretty much lucky: seeing wasn’t the top, with mars being very low on the horizon, but it was good enough to get a proper look: we were able to distinguish a few major features, particularly when it began to rise a little bit over 20°.
I also took a few pictures, this is the best result, shown here with a Stellarium simulation for that day and hour.

Mars, first 2016 shot
Stellarium image, for comparison
Stellarium image, for comparison

We observed also Saturn, getting close to its own opposition too, although even lower in the horizon than Mars, and Jupiter, still quite high and bright in the sky.
At the eyepiece, it was impressive: the great read spot was particularly evident, and a satellite (we later identified it being Europa) was getting closer and closer to the planet disk.
When I started shooting with my camera it was already over Jupiter, and it’s visible as the bright spot in the left part of the planet.

Jupiter with Europa transiting

Although the images are not as good as I was hoping, it was a very nice evening, we could finally have a good couple of hours doing astronomy, and it was a relief after a long time being unable to observe due to bad weather.

Continue reading...

Last august I had the chance to see the International Space Station passing in front of the moon right from my home.
The ISS is clearly visible many nights, and depending on the user position on Earth, it might align with some object in the sky.

These days I was reorganizing my gallery, and I found the original video.
So, after reprocessing it a while, I decided to republish it.

The ISS is really fast: the video is slightly slowed down. I remember that during the transit I couldn’t see the station, and I waited a few minutes because I couldn’t know if the transit already happened or not: it was still daylight, and in the original frames is barely visible.
Only after watching the video I could finally notice that tiny dot passing right in front of the moon.

ISS transits over the Moon (video on youtube)

For this shot, I used my old Celestron Astromaster 130, in an alt-azimuth mount, and my QHY5L-IIm as shooting camera. I had to try following manually the moon, since I obviously had no motorized tracking.
I had to use the 130mm scope instead of my main 8″ scope because of the shorter focal length: this way I could shoot almost the whole moon, so I could be sure that I didn’t miss the ISS.

Continue reading...

Spring is back, and here in Milan we finally had a few days (and nights) of very nice weather.

I also bought a new lightweight battery for my HEQ5 mount, instead of the usual heavy car battery I’ve been using until now, so I took a minimal setup and placed myself in a local park.

Seeing wasn’t perfect, but it was fine enough to shoot a few nice details of an almost full moon.

Gassendi, Mare Humorum
Crater Gassendi

More importantly, Jupiter was at opposition a few weeks ago, so it’s still in a very favourable position.

Jupiter with satellites
Jupiter - 19/03/2016

All these shots were done using my own Planetary Imager.
Image processing was done using Autostakkert (stacking), Registax (wavelets), and GIMP (post processing).

Continue reading...

After rediscovering Siril, a nice astronomical images preprocessing tool for GNU/Linux, I wanted to give another try at processing a few test images taken this summer.

It’s surely not a masterpieces, but I’m not too disappointed either by what I could make of them, given that it was just a basic attempt, with no more than half hour total shoot time.

M 42

Postrocessing was done using DarkTable.

Continue reading...

Another couple of high resolution images, taken on the Appennines, with quite a lucky seeing.
Jupiter is now rising earlier, and it was a welcome preview to the observing night.

Firstly I tried shooting on prime focus, using small magnification, and then I used a 2.5 barlow lens. The prime focus shooting should have been just a test, but it proved to be the better one, as I had troubles focusing with the barlow lens (we were already in “night” mode, and I had to darken a lot my monitor, so focusing was really difficult).

This is the prime focus shooting elaboration.

Jupiter with the Great Red Spot - April 11, 2015

Saturn is starting to rise earlier, and around 4am is starting to be fairly hight for a few shots.

Since we already finished observing I could remove my notebook darkening panel, and focus quite better with the 2.5x barlow.

Early Saturn - April 12, 2015

It was also a very satisfying deep sky stargazing night (which was actually the main purpouse of our trip to the Appennines).

Spring constellations enable us to go really “deep”, with very far and suggestive galaxy clusters.

Continue reading...

Another shooting, much improved in quality compared to the previous ones: Jupiter bands are very well defined, rich of details, much more compared to the images of fifteen days ago: probably both because of the better seeing, and of the removal of the IR-pass filter, replaced with a more classical IR-Block, gathering much more light.

Jupiter, with Io shadow

The “guest” of the title is the dark dot almost at the center of the planet: it’s not an image artifact, but it’s the shadow of the Io satellite projected on the planet. Basically, a solar eclipse on Jupiter.

The satellite itself is not visible on the picture, submerged in the planet disk. The other two satellites are, from closest to farthest, Europa e Ganimede.

Continue reading...

Notice: this article is currently available in italian only.
I will translate it soon. You may contact me via comments if you want me to “prioritize” this article first.

Per una serie di vicissitudini (e per il maltempo che l’ha fatta da padrone) non ho potuto osservare molto Giove, in opposizione proprio nei prossimi giorni, e quindi nel periodo di migliore osservabilità.

Ieri sera comunque sono riuscito ad effettuare qualche osservazione e qualche ripresa, approfittando di un seeing stranamente non cattivo come solitamente da casa mia: purtroppo non ho balconi o terrazzi, e mi tocca riprendere ed osservare dalla finestra aperta, cosa che alza di parecchio la turbolenza per il continuo passaggio d’aria tra interno ed esterno.

Jupiter - 2015-01-30

In visuale era piuttosto evidente la Grande Macchia Rossa, che nelle riprese invece sembra quasi invisibile. Non è infatti il globulo scuro che si vede nella banda in alto a sinistra. Questo perchè la ripresa è stata effettuata nel vicino infrarosso e non nel visuale, per ridurre l’interferenza atmosferica, quindi i dettagli visibili nella ripresa sono un po’ diversi da quelli che si vedono ad occhio nudo.

Si vedono molto bene anche due dei satelliti galileiani, Io ed Europa.

Ripresa effettuata al fuoco diretto di un Meade ACF 8″, 2000mm di focale, con filtro IR “Planet IR Pro 807“, camera QHY5II-L. Sommati circa 800 frames (di 2000 totali).

Aggiornamento, 02/02/2015
Giusto una manciata di giorni dopo ho potuto ripetere il tentativo, con una messa a fuoco un po’ più fortunata.
Non è visibile la macchia rossa, in questo caso, ma sono riuscito a tenere nel campo tutti e quattro i satelliti galileiani.

Jupiter and galileian satellites - 2015-02-02

Continue reading...

It’s been a long time since I last wrote about SkyPlanner development, but I still kept working on it, enabling lots of new features.
The Telescopes page has been redesigned to include also eyepieces and barlow/focal reduces, and therefore has also been renamed to “Optical Instruments” in your settings menu.

Instruments Page
Instruments Page

Adding at least a telescope and an eyepiece will show a new panel in the session pages, with all possible combinations, calculating magnification and field of view.
It will also add a new menu when clicking on a DSS preview image, that will show you field of view circles overlay.

Filters have been heavly improved. We have now lots of new filters, and the existing ones were redesigned to offer a better experience.

Now you can filter by object type, by magnitude, time of transit, altitude, constellation, previously observed objects, angular size, catalogue. Filters are available both in the main objects list and in the “Suggested Objects” panel, allowing you to fine tune SkyPlanner suggestions for planning your stargazing night.

The “Suggested Objects” list can now be sorted also by magnitude and time.

A new interesting feature is the post-session report: when reviewing a past session, you can mark as observer each object in your list.

After doing so, a “report” button will appear for that object, allowing you to write an extended description of your observation.

Finally, clicking the “Report” button on the top toolbar will display your report almost ready to be printed. You may wish to click the “Write report” button to write some notes about the whole session, instead of single objects.

Additionally, you can share your report. By default this is disabled, but clicking the “Share” button will make it publicly available.

You can share it with a few options: first, a web address, that you can embedd on your blog/website, or send via email. But you can also one of the predefined buttons for social sharing, on Google+, Facebook, Twitter.

But sharing is now enabled also for the regular session planning: in the “preview with images” section of a planned session you’ll see the same “Share” button.

Lastly, there were a few additions to the objects catalogues, most notably the Barnard catalogue of dark objects.

These were just a few highlights, to find out more just go to SkyPlanner home page and try it.

Continue reading...

I’ve been long waiting for sharing SkyPlanner source code in a public repository.

Problem is, I had to fix a few copyright headers, cleanup some stuff, and, you know, laziness.

Now I finally published them on my GitHub account:

It’s still missing a README file for compiling and all, but if someone is curious about how SkyPlanner works, this is a huge start for poking it.

Happy hacking!

Continue reading...

When programming in C++ it can often happen to be using C-style API.
These usually come in the form:

int some_api_call(char *inputParameter, char **outputParameter);

where the return value is never a real output value, but instead an exit code, and usually 0 means success.

To handle such API in a sequence of operations, one is then usually blinded to do something like this:

 int result = first_c_api_call();
 if(result != 0) {
 cerr << "Error executing first_c_api_call: " << result << endl;

result = second_c_api_call();
if(result != 0) {
cerr << "Error executing second_c_api_call: " << result << endl;

result = third_c_api_call();

and so on, which is kinda boring when you have to call lots of API functions in one method.

I have been trying to write some kind of wrapper that can help making this a bit easier.
In a real life example, I’ve been trying to use gphoto2 api in a c++11 application.
Using c++11 lambdas and RAII this is what I’ve been able to do:

 void GPhotoCamera::connect() {
      CameraAbilities abilities;
      GPPortInfo portInfo;
      CameraAbilitiesList *abilities_list = nullptr;
      GPPortInfoList *portInfoList = nullptr;
      CameraText camera_summary;
      CameraText camera_about;
      int model, port;
        sequence_run( [&]{ return gp_abilities_list_new (&abilities_list); } ),
        sequence_run( [&]{ return gp_abilities_list_load(abilities_list, d->context); } ),
        sequence_run( [&]{ model = gp_abilities_list_lookup_model(abilities_list, d->model.toLocal8Bit()); return model; } ),
        sequence_run( [&]{ return gp_abilities_list_get_abilities(abilities_list, model, &abilities); } ),
        sequence_run( [&]{ return gp_camera_set_abilities(d->camera, abilities); } ),
        sequence_run( [&]{ return gp_port_info_list_new(&portInfoList); } ),
        sequence_run( [&]{ return gp_port_info_list_load(portInfoList); } ),
        sequence_run( [&]{ return gp_port_info_list_count(portInfoList); } ),
        sequence_run( [&]{ port = gp_port_info_list_lookup_path(portInfoList, d->port.c_str()); return port; } ),
        sequence_run( [&]{ return gp_port_info_list_get_info(portInfoList, port, &portInfo); return port; } ),
        sequence_run( [&]{ return gp_camera_set_port_info(d->camera, portInfo); } ),
        sequence_run( [&]{ return gp_camera_get_summary(d->camera, &camera_summary, d->context); } ),
        sequence_run( [&]{ return gp_camera_get_about(d->camera, &camera_about, d->context); } ),
      }, make_shared<QMutexLocker>(&d->mutex)}
      .on_error([=](int errorCode, const std::string &label) {
        qDebug() << "on " << label << ": " << gphoto_error(errorCode);
        emit error(this, gphoto_error(errorCode));
        d->summary = QString(camera_summary.text);
        d->about = QString(camera_about.text);
        emit connected();    
      // TODO d->reloadSettings();

I can then declare some variables in the first part of the method, and inside the “gp_api” block i can execute a sequence of operation, each one returning an int value. This value is automatically checked for an error, and if it it’s a success exit code, the next sequence block is executed.
run_last is finally executed if all steps are completed successfully. An optional mutex locker (QMutexLocker) is passed to the gp_api block as the last constructor argument, to automatically lock the c api for multithreading.

How have I accomplished this?

This is the main class so far:

#include <functional>
#include <list>
#include <mutex>

typedef std::shared_ptr<std::unique_lock<std::mutex>> default_lock;
template<typename T, T defaultValue, typename check_operator = std::equal_to<T>, typename RAII_Object = default_lock>
class sequence {
  typedef std::function<T()> run_function;
  typedef std::function<void(const T &, const std::string &)> on_error_f;
  struct run {
    run_function f;
    std::string label;
    T check;
    run(run_function f, const std::string &label = {}, T check = defaultValue) : f(f), label(label), check(check) {}
  sequence(const std::list<run> &runs, const RAII_Object &raii_object = {}) : runs(runs), _check_operator(check_operator{}), raii_object(raii_object) {}
  ~sequence() {
    for(auto r: runs) {
      T result = r.f();
      if(! _check_operator(result, r.check)) {
    _run_on_error(result, r.label);
  sequence &on_error(on_error_f run_on_error) { _run_on_error = run_on_error; return *this; }
  sequence &run_last(std::function<void()> run_last) { _run_last = run_last; return *this; }
  sequence &add(run r) { runs.push_back(r); }
  std::list<run> runs;
  on_error_f _run_on_error = [](const T&, const std::string&) {};
  check_operator _check_operator;
  std::function<void()> _run_last = []{};
  RAII_Object raii_object;
#define sequence_run(...) { __VA_ARGS__ , #__VA_ARGS__}

The sequence class accepts a list of runs as construction parameters. These are stored as a class field, and sequentially executed at class destruction.
Sequence is a template class: you can define the return value type, the success value, a comparison operator to check each function result code against the success value, and finally a generic RAII_Object, which can be as previously told a mutex locker, or some other kind of resource to unlock after API executions.

The define directive at the end of the code is used to automatically create a run object which already contains a description of the code being executed (stringified).
You get this description in the on_error callback.

Near my gphoto class I also added a typedef to conveniently call the proper sequence template class with correct template parameters:

typedef sequence<int, GP_OK, std::greater_equal<int>, std::shared_ptr<QMutexLocker>> gp_api;

Which means that gp_api accepts code blocks returning int values, that the “ok” value is GP_OK (0), and that the returned value must be equal or greater than GP_OK to be considered a success run.
It also accepts a QMutexLocker shared pointer for thread locking.
As you can see in my first example I didn’t assign the gp_api object to any variable; this means that it is immediatly created, executed and destructed, for synchronous run.

So this is a simplified usage example:

  sequence_run([&]{ return first_c_api_call(); }),
  sequence_run([&]{ return second_c_api_call(); }),
}, std::make_shared<QMutexLocker>(&&;mutex)}
  .on_error([=](int errorCode, const std::string &label) {
      std::cerr << "Error at code block " << label << ": " << errorCode << std::endl;
    // run when everything runned smoothly

Continue reading...