Marte si sta avvicinando velocemente all’opposizione del 2016, la migliore dell’ultimo decennio, essendo molto vicino alla terra.
Il meteo a milano non è stato clemente in questi giorni a Milano, quindi io ed Alessia abbiamo cercato di approfittare della prima serata che offrisse un cielo sereno, possibilmente con un buon seeing.

Siamo stati abbastanza fortunati: il seeing non era il massimo, sopratutto con marte così basso sull’orizzonte, ma era sufficientemente buono per avere un primo sguardo e distinguere alcune caratteristiche evidenti, sopratutto dopo che si è alzato di poco sopra i 20°.
Ho anche effettuato alcune riprese, questo è il miglior risultato, mostrato qui di fianco a una simulazione di Stellarium per quella data e ora.

Mars, first 2016 shot
Mars, first 2016 shot

simulazione Stellarium, per confronto

Abbiamo anche osservato Saturno, che si avvicina anch’esso alla sua opposizione, anche se ancora più basso di Marte, e Giove, ancora molto brillante ed alto nel cielo.
All’oculare era davvero impressionante: la Grande Macchia Rossa era evidentissima, ed un satellite (successivamente lo abbiamo identificato come Europa) si avvicinava al disco del pianeta.
Quando ho iniziato le riprese con la mia camera aveva già cominciato a transitare sopra Giove, ed è ancora ben visibile come un punto chiaro sulla parte destra del pianeta.

Jupiter with Europa transiting

Anche se le riprese non sono buone come avessi sperato è stata una bella serata, abbiamo finalmente potuto goderci un buon paio d’ore di astronomia fatta bene, ed è stato un sollievo dopo così tanto tempo di inattività a causa del maltempo.

Lo scorso agosto ho avuto l’occasione di poter osservare la Stazione Spaziale Internazionale passare di fronte alla luna direttamente da casa mia. La ISS è spesso ben visibile, ed a seconda della propria posizione sulla terra, potrebbe risultare allineata con qualche oggetto celeste.

In questi giorni, riorganizzando la mia gallery, ho trovato il video originale, quindi, dopo un po’ di riprocessamento, ho deciso di ripubblicarlo.

La ISS è davvero veloce: infatti il video è leggermente rallentato. Ricordo di non aver visto la stazione durante il transito, ed ho dovuto attendere qualche minuto perchè non potevo sapere se era già avvenuto o meno, anche perchè era ancora giorno, e nei frames originali la stazione è a malapena visibile. Solo dopo aver riguardato il video ho potuto finalmente intravedere quel piccolo punto bianco passare di fronte alla luna.

ISS transits over the Moon

Per questa ripresa ho usato il mio vecchio Celestron Astromaster 130, su montatura altazimutale, e la mia QHY5L-IIm come camera di ripresa. Ho dovuto inseguire manualmente la luna, dato che ovviamente non avevo tracking automatico. Ho scelto di usare il 130mm invece del mio solito 8″ proprio per la lunghezza focale più corta: in questo modo ho potuto assicurarmi di non mancare la ISS, potendo riprendere la luna quasi per intero.

La primavera è tornata, e qui a Milano abbiamo finalmente avuto una manciata di giorni (e notti) di bel tempo.

Ho anche comprato una batteria leggera e trasportabile per alimentare la mia montatura HEQ5, al posto della pesante batteria d’auto che ho usato finora, quindi con un setup veramente molto alleggerito mi sono piazzato a Parco Nord per effettuare alcune osservazioni e riprese.

Il seeing non era perfetto, ma era comunque sufficientemente buono da riprendere alcuni dettagli di una luna quasi piena.

Ma sopratutto, Giove è stato all’opposizione poche settimane fa, ed è quindi ancora in una posizione molto favorevole.

Jupiter with satellites

Stessa immagine con nomi dei satelliti

Jupiter

Tutte le riprese sono state effettuate usando il mio Planetary Imager.
Il processing delle immagini è stato fatto usando Autostakkert (stacking), Registax (wavelets), e GIMP (post processing).

Dopo aver appena scoperto Siril, programma di preprocessing di immagini astronomiche per GNU/Linux, ho deciso di ridare una spolverata a delle immagini di prova riprese quest’estate.

Non è certo un capolavoro, ma non mi dispiace affatto quanto è venuto fuori, sopratutto considerato che si tratta solo di prove, con una mezz’ora scarsa di riprese.

M42

Postprocessing effettuato con DarkTable.

Altre due immagini ad alta risoluzione, riprese in montagna, con un seeing piuttosto fortunato.
Giove sorge ormai in prima serata, ed è stata una piacevolissima anteprima alla nottata osservativa.

Ho provato a riprenderlo dapprima al fuoco diretto (quindi ad ingrandimenti più bassi), poi con una barlow 2.5x. La ripresa al fuoco diretto doveva essere un “tanto per provare”, si è invece rivelata quella migliore, dato che con la barlow ho avuto molte difficoltà di messa a fuoco (erano riprese un po’ improvvisate, inoltre eravamo già in modalità “notturna” con lo schermo del notebook oscurato).

Questa è l’elaborazione della ripresa al fuoco diretto.

Jupiter

Saturno comincia a sorgere in orari di buona osservabilità, e già verso le 4 di notte cominciava ad essere sufficientemente alto da essere ripreso.

Dato che stavamo già smontando tutto ho potuto togliere la schermatura del notebook, e mettere a fuoco un po’ meglio con la barlow 2.5x.

Early Saturn

È stata una gran bella nottata anche per le osservazioni deep sky, che in effetti erano lo scopo principale dell’uscita.

Le costellazioni del cielo primaverile permettono di andare veramente “in profondità”, con ammassi di galassie molto lontani e suggestivi.

Ancora una ripresa, di qualità decisamente migliore delle precedenti: le bande sono ben delineate e ricche di dettagli, molti di più rispetto alle immagini di quindici giorni fa, merito di un seeing un po’ migliore, ma sopratutto dell’aver tolto il filtro passa IR, cosa che permette di catturare molta più luce.

Jupiter, with Io shadow

L’ospite accennato nel titolo è quel punto nero quasi al centro del pianeta: non si tratta di un difetto dell’immagine, ma dell’ombra del satellite Io proiettata sul pianeta. Un’eclissi solare, in pratica.

Il satellite Io nella foto non è visibile, dato che è dentro il disco del pianeta, se ne vede solo l’ombra. Gli altri due satelliti visibili sono, in ordine di distanza, Europa e Ganimede.

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

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

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.

Field of View Menu
Field of View 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.

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: https://github.com/GuLinux/SkyPlanner.

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!

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;
 return;
 }

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

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;
      gp_api{ {
        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));
      }).run_last([&]{
        d->summary = QString(camera_summary.text);
        d->about = QString(camera_about.text);
        emit connected();    
      });  
      // TODO d->reloadSettings();
      gp_port_info_list_free(portInfoList);
      gp_abilities_list_free(abilities_list);
}

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 {
public:
  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);
    return;
      }
    };
    _run_last();
  }
  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); }
private:
  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:

gp_api{ {
  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_last([&]{
    // run when everything runned smoothly
  });