Cas d'utilisation : Récupération et affichage de données hydrométriques¶

# Création d'un graphique interactif avec Matplotlib

# Station hydrométrique à afficher sur le graphique
station_displayed_p = stations[1]

# Fonction pour créer un graphique pour la station sélectionnée
def interactive_plot(station):
    # Ajustement de la taille des caractères et de la figure
    params = {
        "legend.fontsize": "14",
        "figure.figsize": (9, 5),
        "axes.labelsize": "14",
        "axes.titlesize": "16",
        "xtick.labelsize": "12",
        "ytick.labelsize": "12",
    }
    plt.rcParams.update(params)
    
    # Création du graphique
    fig, ax = plt.subplots()
    line, = plt.plot(
        hydrometric_data[station].index,
        hydrometric_data[station]["LEVEL"],
        marker="o",
        label="Moyenne journalière",
    )
    plt.legend()
    plt.grid(True, which="both")
    ax.set_title(
        fill(
            "Niveaux d'eau de la station {} ({})".format(
                hydrometric_data[station]["STATION_NAME"][0], station
            ), 60
        )
    )
    ax.set_ylabel("Niveau d'eau (m)")
    ax.set_xlabel("Date")

    # Modification de la graduation et des étiquettes de l'axe des x
    locator = mdates.AutoDateLocator()
    ax.xaxis.set_major_locator(locator)
    plt.gcf().autofmt_xdate()
    
    # Création des annotations à afficher au passage de la souris
    annot = ax.annotate(
        "",
        xy=(0, 0),
        xytext=(-60, -40),
        textcoords="offset points",
        bbox=dict(boxstyle="round", fc="w"),
        arrowprops=dict(arrowstyle="->"),
    )
    annot.set_visible(False)

    return line, annot, ax, fig


# Création de la figure
line, annot, ax, fig = interactive_plot(station_displayed_p)


# Mise à jour des annotations avec les informations du point de donnée
def update_annot(ind):
    # Identification des annotations à afficher
    x, y = line.get_data()
    annot.xy = (x[ind["ind"][0]], y[ind["ind"][0]])
    
    # Ajout de texte à l'annotation (date et niveau d'eau)
    date_x = x[ind["ind"]][0]
    level_y = round(y[ind["ind"]][0], 2)
    text = "{}\nMoyenne journalière: {} m".format(date_x, level_y)
    annot.set_text(text)
    
    # Sélection du niveau de transparence de l'annotation
    annot.get_bbox_patch().set_alpha(0.8)


# Affichage des annotations au passage de la souris
def hover(event):
    vis = annot.get_visible()
    if event.inaxes == ax:
        cont, ind = line.contains(event)
        if cont:
            update_annot(ind)
            annot.set_visible(True)
            fig.canvas.draw_idle()
        else:
            if vis:
                annot.set_visible(False)
                fig.canvas.draw_idle()


# Ajout de la fonction d'affichage des annotations au 
# passage de la souris à la figure               
fig.canvas.mpl_connect("motion_notify_event", hover)

plt.show()

# Création du tableau

# Station hydrométrique à afficher dans le tableau
station_displayed_t = stations[1]

# Option pour afficher toutes les lignes du tableau
pd.options.display.max_rows


# Fonction pour afficher le tableau de la station sélectionnée
def data_table(station):
    # Impression du titre de la table
    print(
        "Niveaux d'eau de la station "
        + f"{hydrometric_data[station]['STATION_NAME'][0]}"
        + f" ({station})"
    )
    # Sélection des colonnes désirées et modification de leur nom
    displayed_df = hydrometric_data[station][["LEVEL"]].round(2).rename(
        columns={
            "LEVEL": "Moyenne journalière du niveau d'eau (m)",
        }
    )
    displayed_df.index = displayed_df.index.rename("Date")
    return displayed_df

print(tabulate(data_table(station_displayed_t),
               headers='keys',
               tablefmt='pretty'))

# Création de la carte interactive

# Liste des coordonnées et des étiquettes
labels = []
all_lat = []
all_lon = []
for station in stations:
    latest_data = hydrometric_data[station].iloc[-1]
    labels.append(
        f"{hydrometric_data[station]['STATION_NAME'][0]}\n"
        + f"ID de la station: {latest_data.STATION_NUMBER}\n"
        + f"Date: {latest_data.name}\n"
        + f"Niveau d'eau: {round(latest_data.LEVEL, 2)} m"
    )
    all_lat.append(latest_data.LATITUDE)
    all_lon.append(latest_data.LONGITUDE)

# Liste pour garder une trace de toute les annotations
annotations = [None for label in labels]

# Définition de la taille des marqueurs
markersize = 8
markersize_inches = markersize / 72.0

# Création de la figure
tiler = OSM()
fig = plt.figure(figsize=(7, 7))
ax = plt.axes(projection=tiler.crs)
ax.set_title(fill(
    "Moyenne journalière du niveau d'eau la plus récente pour "
    + f"la période se terminant le {end_date}", 45)
)

# Définition de l'étendue pour bien voir toutes les stations
ax.set_extent(
    [
        min(all_lon) * 1.001,
        max(all_lon) * 0.999,
        min(all_lat) * 0.999,
        max(all_lat) * 1.001,
    ]
)

# Ajout d'un fond de carte d'Open Street Map
ax.add_image(tiler, 9)

# Ajout des points de données
ax.plot(
    all_lon,
    all_lat,
    "bo",
    marker="o",
    mec="k",
    color="RoyalBlue",
    ms=markersize,
    transform=ccrs.Geodetic(),
)

# Coordonnées de la figure en pouces
trans = ax.transData + fig.dpi_scale_trans.inverted()


# Fonction pour suivre les coordonnées de la souris et annoter
def on_move(event):
    if event.inaxes:
        # Transformation des coordonnées dans la même projection que la figure
        xproj, yproj = zip(
            *[
                ax.projection.transform_point(x, y, src_crs=ccrs.Geodetic())
                for x, y in zip(all_lon, all_lat)
            ]
        )
        # Coordonnées des événements en pouces
        x0, y0 = trans.transform((event.xdata, event.ydata))
        # Coordonnées des stations hydrométriques en pouces
        xfig, yfig = zip(
            *[trans.transform((x, y)) for x, y in zip(xproj, yproj)]
        )
        # Distance entre la souris et la position exacte du point de donnée
        dists = [math.sqrt((x - x0) ** 2 + (y - y0) ** 2) for x, y in zip(
            xfig, yfig
        )]
        
        # Affichage des annotations lors du passage de la souris
        for n, (x, y, dist, label) in enumerate(
                zip(xproj, yproj, dists, labels)
        ):
            if dist < markersize_inches and annotations[n] is None:
                annotations[n] = ax.annotate(
                    label,
                    [x, y],
                    xycoords="data",
                    xytext=(10, 10),
                    textcoords="offset points",
                    ha="center",
                    va="bottom",
                    bbox=dict(
                        facecolor="white",
                        edgecolor="black",
                        boxstyle="round"
                    ),
                    zorder=10,
                )
                fig.canvas.draw()

            elif dist > markersize_inches and annotations[n] is not None:
                annotations[n].remove()
                annotations[n] = None
                fig.canvas.draw()


# Connection du gestionnaire d'événements
cid = fig.canvas.mpl_connect("motion_notify_event", on_move)

plt.show()