We are reverting commit b926e1b7 because now there are two SHPC input
directories for visible eddies, two SHPC for interpolated eddies and
edgelists in differents directories for the two orientations. Handling
the command line arguments would be awkward.

Move functions `in_window` and `open_shpt` from
`plot_eddy_contours.py` to `util_detect_eddies.py` since these
functions are also used, or will also be used, elsewhere.

Required since commit 1eca0742.

This can happen with Matlab data, if a node present in the edge list
is absent in the shapefiles.

Print time measurements only when time option is
activated. Motivation: we need reproducibility for the automated test.

For the test of the script in `tests.json`. Normally, we would save to
pdf, but pdf format includes a date stamp. So pdf is not convenient
for testing. So we include the format value in argument save and we
save to png for the automated test.

Read only the graph containg specified node. The orientation of the
corresponding eddy must be specified on the command line.

Adapt the central longitude of the projection, depending on window or
position of chosen node. Else we can have arrows crossing the whole projection.

With window option, the script used to plot all components in the
subgraph containing the nodes in the window. So the components stopped
at nodes inside the window. Now we do better: we plot all the
components intersecting the window. These components may extend beyond
the window. This is in particular better if a component has a
connecting part outside of the window. In the old script, this
component would have been plotted as two components.

We achieve this by adding components intersecting the window in the
`component_list` attribute of the graph. And we modify the function
`plot_all_components`: it no longer calls
`nx.weakly_connected_components`: it just plots all the components in
`component_list`.

We only call `nx.weakly_connected_components` through the function
`assign_all_components` if the script is run without the window or
node options.

Rename `get_component` to `add_component`. This function now adds a
component to the graph attribute `component_list` instead of returning
the component as a separate object. The function also adds the
component attribute to each node in the added component.

The idea is that we may want to add components in successive steps if
we study successive windows.

Rename `assign_components` to `assign_all_components`. Move this
function from file `report_graph.py` to file `plot_traj.py` because we
are going to use it there (it is as yet not used
anywhere). `assign_all_components` stores `component_list` as a graph
attribute instead of returning it as a separate object. More robust
and convenient.

Also, in the node attribute component, store the component instead of
its index in `component_list`. More robust and convenient. This does
not use more storage space since component is just a reference to the
set object.

This is necessary for a global domain and a plot on a region crossing
the first longitude in the input SSH files. Plotting with Cartopy
requires giving up the function `nx.draw_networkx`, since this
function does not pass through the transform keyword. So we have to
call the Matplotlib functions directly: scatter,
`patches.FancyArrowPatch` and annotate.

This is necessary for a global domain: plotting the global domain is
too long.

Instead of finding all weakly-connected components and using only
one. As in `report_graph.py`, commit cb1701d0.

By default, we want to reset ticks.

This requires extending the functionality of function `is_node_type`:
label nodes with a given date.

Add options: plot a single component; label the leafs, the splits or
the merges, or all eddies, instead of the roots. Add functions for
easier hacking.

The previous version annotated a single ancestor, and it was not
necessarily the ancestor with the oldest date. Moreover, this revision
is probably quicker: no need for subgraph and topological sort.

Now useless.

Define attribute `coordinates` of nodes instead of separated
dictionary pos. Use function `report_graph.read_eddy_graph` to define
the attributes of nodes. So we do not need the functions
`compute_ishape` and `get_coord` any longer. Note that, for visible
eddies, `plot_traj.py` used to loop on nodes of the graph and access
corresponding shapes, while `report_graph.read_eddy_graph` loops on
the shapes and accesses corresponding nodes. This is probably quicker.

Because, in hacking mode, we want to be able to import `report_graph`
and use function `report_graph.read_eddy_graph` from any directory.

I encountered the case where `n[0] < k1` with the result of
`test_overlap`. The results were silently wrong: Python does not
complain that `ishape_last` is indexed with a negative value.

The position for interpolated eddies is not in `shp_tr_dir`. We have
to read it from `SHP_triplet` in the current directory.

The shapefile reader does not abort with ishape == - 1. So use None instead.

Plot trajectories using the Networkx graph instead of directly from
the CSV file. This allows grouping of edges by connected component,
with a different color for each component, and labeling each component
with its ancestor.