smashbox 1.0__py2.py3-none-any.whl

smashbox/plot/plot.py

@@ -0,0 +1,1662 @@
+# -*- coding: utf-8 -*-
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib
+from matplotlib.colors import ListedColormap
+import pandas as pd
+from pandas import DataFrame
+from smashbox.stats import stats
+from smashbox.tools import geo_toolbox
+import datetime
+from smash import Model
+
+import matplotlib.colors as mcolors
+from matplotlib import cm
+import colorsys
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+
+import os
+import pandas as pd
+from smashbox.init.param import param
+
+from smashbox.tools import tools
+
+
+class plot_properties:
+    """Class which handle differents properties of the matplotlib plot function.
+    All attributes can be defined by the user and the object plot_properties can be
+     passed to any smashbox plot function.
+    """
+
+    def __init__(
+        self,
+        ls="-",
+        lw=1.5,
+        marker="",
+        markersize=4,
+        color="black",
+        label="",
+    ):
+        self.ls = ls
+        """The style of the line (see matplotlib documentation)"""
+        self.lw = lw
+        """The linewidth of the line (see matplotlib documentation)"""
+        self.marker = marker
+        """The style of the marker (see matplotlib documentation)"""
+        self.markersize = markersize
+        """The size of the marker (see matplotlib documentation)"""
+        self.color = color
+        """The color of the line (see matplotlib documentation)"""
+        self.label = label
+        """The label of the line (see matplotlib documentation)"""
+
+    def update(self, **kwargs):
+        """Update the class attributes using kwarg (dictionnary)"""
+        for key, values in kwargs.items():
+            setattr(self, key, values)
+
+
+class ax_properties:
+    """Class which handle differents properties of the matplotlib ax object
+    (see matplotlib documentation). All attributes can be defined by the user and the
+     object ax_properties can be passed to any smashbox plot function.
+    """
+
+    def __init__(
+        self,
+        title: str = None,
+        xlabel: str = None,
+        ylabel: str = None,
+        clabel: str = None,
+        font_ratio: int = 1,
+        title_fontsize: int = 12,
+        label_fontsize: int = 10,
+        annotate_fontsize: int = 6,
+        grid: bool = True,
+        xscale: str | None = None,
+        yscale: str | None = None,
+        legend: bool = True,
+        legend_loc: str = None,
+        legend_fontsize: int = 8,
+        xtics_fontsize: int = 8,
+        ytics_fontsize: int = 8,
+        cmap: str | None = None,
+        xlim: tuple | list | None = (None, None),
+        ylim: tuple | list | None = (None, None),
+        xticklabels_rotation: int = 0,
+        barlabel_fontsize=6,
+    ):
+
+        self.title = title
+        """The title of the graphic"""
+        self.xlabel = xlabel
+        """The label of the x axis"""
+        self.ylabel = ylabel
+        """The label of the y axis"""
+        self.clabel = clabel
+        """The label of the colorbar"""
+        self.font_ratio = font_ratio
+        """Ratio of the global fontsize"""
+        self.title_fontsize = title_fontsize
+        """The fontsize of the title"""
+        self.label_fontsize = label_fontsize
+        """The label fontsize"""
+        self.annotate_fontsize = annotate_fontsize
+        """The annotation fontsize in plot"""
+        self.grid = grid
+        """Set the grid (boolean), default True"""
+        self.xscale = xscale
+        """Scale of the x axis (see matplotlib documentation)"""
+        self.yscale = yscale
+        """Scale of the x axis (see matplotlib documentation)"""
+        self.legend = legend
+        """Set the legend, boolean, default is True"""
+        self.legend_loc = legend_loc
+        """Localisation of the legend"""
+        self.legend_fontsize = legend_fontsize
+        """The fontsize of the legend"""
+        self.xtics_fontsize = xtics_fontsize
+        """The fontsize of the xtics"""
+        self.ytics_fontsize = ytics_fontsize
+        """The fontsize of the ytics"""
+        self.cmap = cmap
+        """The name of the used colormap"""
+        self.xlim = xlim
+        """The limit of the x axis, tuple or list, default is (None,None)"""
+        self.ylim = ylim
+        """The limit of the y axis, tuple or list, default is (None,None)"""
+        self.xticklabels_rotation = xticklabels_rotation
+        """Angle of the xtics labels, float, default is 0."""
+        self.barlabel_fontsize = barlabel_fontsize * self.font_ratio
+        "Fontsize of the bar top label"
+
+    def update(self, **kwargs):
+        """Update the class attributes using kwarg (dictionnary)"""
+        for key, values in kwargs.items():
+            setattr(self, key, values)
+
+    def change(self, figure):
+        """Apply change to the current figure `figure`
+        Parameter:
+        ----------
+        figure : list or tuple
+            list of (fig, ax), figure and ax of a matplotlib subplot.
+        Return:
+        -------
+            a tuple of the modified (fig,ax)
+        """
+        fig, ax = figure
+
+        plt.rcParams.update(plt.rcParamsDefault)
+
+        plt.rcParams.update(
+            {
+                "axes.labelsize": self.label_fontsize * self.font_ratio,
+                "axes.titlesize": self.title_fontsize * self.font_ratio,
+                "legend.fontsize": self.legend_fontsize * self.font_ratio,
+                "figure.titlesize": self.title_fontsize * self.font_ratio,
+                "xtick.labelsize": self.xtics_fontsize * self.font_ratio,
+                "ytick.labelsize": self.ytics_fontsize * self.font_ratio,
+            }
+        )
+
+        if self.title is not None:
+
+            ax.set_title(self.title, fontsize=self.title_fontsize * self.font_ratio)
+
+        if self.xlabel is not None:
+            ax.set_xlabel(self.xlabel, fontsize=self.label_fontsize * self.font_ratio)
+
+        if self.ylabel is not None:
+            ax.set_ylabel(self.ylabel, fontsize=self.label_fontsize * self.font_ratio)
+
+        if self.grid:
+            ax.grid(True, which="both", linestyle="--", alpha=0.5)
+
+        if self.xscale is not None:
+            ax.set_xscale(self.xscale)
+
+        if self.yscale is not None:
+            ax.set_xyscale(self.yscale)
+
+        if self.legend:
+            ax.legend(
+                loc=self.legend_loc, fontsize=self.legend_fontsize * self.font_ratio
+            )
+
+        if self.cmap is not None:
+            plt.rc("image", cmap=self.cmap)
+
+        if self.ylim[0] is not None:
+            ax.set_ylim(bottom=self.ylim[0])
+
+        if self.ylim[1] is not None:
+            ax.set_ylim(top=self.ylim[1])
+
+        if self.xlim[0] is not None:
+            ax.set_xlim(left=self.xlim[0])
+
+        if self.xlim[1] is not None:
+            ax.set_xlim(right=self.xlim[1])
+
+        if self.xticklabels_rotation > 0:
+            ax.set_xticklabels(
+                ax.get_xticklabels(), rotation=self.xticklabels_rotation, ha="right"
+            )
+
+        return fig, ax
+
+
+class fig_properties:
+    """Class which handle differents properties of the matplotlib fig object
+    (see matplotlib documentation). All attributes can be defined by the user and the
+     object ax_properties can be passed to any smashbox plot function.
+    """
+
+    def __init__(
+        self,
+        figname=None,
+        xsize=8,
+        ysize=6,
+        transparent=False,
+        dpi=160,
+        font_ratio=1,
+        bbox_inches="tight",
+    ):
+
+        self.figname = figname
+        """Path to the figure name to be saved"""
+        self.xsize = xsize
+        """Width of the figure in inch"""
+        self.ysize = ysize
+        """Height of the figure in inch"""
+        self.transparent = transparent
+        """Use transparency when exporting the figure, default is False"""
+        self.dpi = dpi
+        """Résolution (dpi), int, default is 80"""
+        self.font_ratio = font_ratio
+        """Global font ratio"""
+        self.bbox_inches = bbox_inches
+        """Constraint of the boundingbox of each ax (see matplotlib docuentation)"""
+
+    def update(self, **kwargs):
+        """Update the class attributes using kwarg (dictionnary)"""
+
+        for key, values in kwargs.items():
+            setattr(self, key, values)
+
+    def change(self, figure):
+        """Apply change to the current figure `figure`
+        Parameter:
+        ----------
+        figure : list or tuple
+            list of (fig, ax), figure and ax of a matplotlib subplot.
+        Return:
+        -------
+            a tuple of the modified (fig,ax)
+        """
+
+        fig, ax = figure
+
+        fig.set_figheight(self.ysize)
+        fig.set_figwidth(self.xsize)
+
+        plt.rc(
+            "font", size=plt.rcParams["font.size"] * self.font_ratio
+        )  # controls default text sizes
+        plt.rc(
+            "axes", titlesize=plt.rcParams["axes.titlesize"] * self.font_ratio
+        )  # fontsize of the axes title
+        plt.rc(
+            "axes", labelsize=plt.rcParams["axes.labelsize"] * self.font_ratio
+        )  # fontsize of the x and y labels
+        plt.rc(
+            "xtick", labelsize=plt.rcParams["xtick.labelsize"] * self.font_ratio
+        )  # fontsize of the tick labels
+        plt.rc(
+            "ytick", labelsize=plt.rcParams["ytick.labelsize"] * self.font_ratio
+        )  # fontsize of the tick labels
+        plt.rc(
+            "legend", fontsize=plt.rcParams["legend.fontsize"] * self.font_ratio
+        )  # legend fontsize
+        plt.rc(
+            "figure", titlesize=plt.rcParams["figure.titlesize"] * self.font_ratio
+        )  # fontsize of the figure title
+
+        if self.figname is not None:
+
+            head_path, basename = os.path.split(self.figname)
+
+            if len(head_path) > 0 and not os.path.exists(head_path):
+                os.makedirs(head_path)
+
+            fig.savefig(
+                self.figname,
+                transparent=self.transparent,
+                dpi=self.dpi,
+                bbox_inches=self.bbox_inches,
+            )
+
+        return fig, ax
+
+
+@tools.autocast_args
+def save_figure(
+    fig=None, figname="myfigure", xsize=8, ysize=6, transparent=False, dpi=80
+):
+    """
+    Save a figure.
+    Parameters:
+    -----------
+    fig: fig object returned by matplotlib.subplot
+        the figure to save
+    figname: str
+        Path to the figure
+    xsize: int
+        width of the figure in inch
+    ysize: int
+        height of the figure in inch
+    transparent: bool, default is False
+        use transparency
+    dpi : int
+        resolution of the figure, default is 80
+    """
+    fig.set_size_inches(xsize, ysize, forward=True)
+    fig.savefig(figname, transparent=transparent, dpi=dpi, bbox_inches="tight")
+
+
+def generate_palette(base_color, n, variation="hue"):
+    """
+    Generate a palette of colors from a base color.
+    Parameter:
+    ---------
+    base_color: str
+        matplotlib color string
+    n: int
+        number of color to generate
+    variation: 'hue' | 'brightness'
+        how to generate the color palette, by changing the hue or the brighness of the base color.
+    Return: a list of colors
+    """
+    # Convertir la couleur de base en format RGB normalisé (0-1)
+    rgb = mcolors.to_rgb(base_color)
+
+    # Convertir en HSV
+    h, s, v = colorsys.rgb_to_hsv(*rgb)
+
+    # Générer n couleurs en modifiant la teinte ou valeur
+    palette = []
+    for i in range(n):
+        new_h = h
+        if variation == "hue":
+            new_h = (h + i / n) % 1.0  # cycle dans le cercle chromatique
+        new_v = v
+        if variation == "brightness":
+            new_v = max(0.1, min(1.0, v * (0.5 + i / (2 * n))))  # éviter le noir complet
+
+        new_rgb = colorsys.hsv_to_rgb(new_h, s, new_v)
+        palette.append(new_rgb)
+
+    return palette
+
+
+@tools.autocast_args
+def plot_chro(
+    data: np.ndarray = np.zeros(shape=(1, 10)),
+    t_axis: int = 1,
+    outlets_name: list | tuple = [],
+    columns: list | tuple = [],
+    dt: float = 0.0,
+    xtics: list | tuple = [],
+    date_range: list = None,
+    figure=None,
+    ax_settings: dict | ax_properties = ax_properties(),
+    fig_settings: dict | fig_properties = fig_properties(),
+    plot_settings: dict | plot_properties = plot_properties(),
+):
+    """
+    Plot a temporal chonic of values
+    Parameters:
+    -----------
+    data: np.ndarray of dimenion 2.
+        data to plot as a matrix of 2 dimension.
+    t_axis : int
+        the axis of the time in data, default is 1
+    outlets_name: list
+        the list of the outlets name
+    columns : list
+        the column to be plotted in t_axis direction
+    dt: float
+        the timestep
+    xtics : list
+        list of date for the xtics. The format must be automatically read by numpy.Datetime
+    date_range: list
+        list of [date_start, date_end, timedelta] to generate the xtics
+    figure: tuple
+        input figure as (fig,ax) to add a new curve
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+    plot_settings: dict or class plot_properties
+        object or dict with any attribute of class plot_settings
+
+    """
+
+    if isinstance(ax_settings, dict):
+        ax_settings = ax_properties(**ax_settings)
+    else:
+        ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    if isinstance(plot_settings, dict):
+        plot_settings = plot_properties(**plot_settings)
+    else:
+        plot_settings = plot_properties(**plot_settings.__dict__)
+
+    data = np.moveaxis(data, t_axis, 0)
+
+    if figure is not None:
+        fig, ax = figure
+    else:
+        fig, ax = plt.subplots()
+
+    fig, ax = ax_settings.change(figure=(fig, ax))
+
+    if len(xtics) == 0:
+        xtics = np.arange(0, data.shape[0])
+        if dt > 0:
+            xtics = xtics * dt
+    else:
+        for i in range(len(xtics)):
+            xtics[i] = np.datetime64(xtics[i])
+
+    if date_range is not None:
+        if len(date_range) != 3:
+            raise ValueError(
+                "date_range must have a length of 3: [date_start, date_end, step (s)]"
+            )
+        xtics = np.arange(
+            np.datetime64(date_range[0]),
+            np.datetime64(date_range[1] + pd.Timedelta(seconds=int(date_range[2]))),
+            np.timedelta64(int(date_range[2]), "s"),
+        )
+
+    if len(columns) > 0:
+
+        args = plot_settings.__dict__.copy()
+        print(args)
+        del args["label"]
+        del args["color"]
+
+        palette = generate_palette(plot_settings.color, len(columns))
+
+        for i in columns:
+            ax.plot(xtics[:], data[:, i], **args, label=outlets_name[i], color=palette[i])
+    else:
+        ax.plot(xtics[:], data[:, 0], **plot_settings.__dict__)
+
+    fig, ax = ax_settings.change(figure=(fig, ax))
+    fig, ax = fig_settings.change(figure=(fig, ax))
+
+    return fig, ax
+
+
+def plot_hydrograph(
+    model: Model | None = None,
+    columns: list | tuple = [],
+    outlets_name: list | tuple = [],
+    plot_rainfall: bool = True,
+    figure: list | tuple | None = None,
+    ax_settings: dict | ax_properties = {},
+    fig_settings: dict | fig_properties = {},
+    plot_settings_sim: dict | plot_properties = {},
+    plot_settings_obs: dict | plot_properties = {},
+):
+    """
+    Plot an hydrograph from a smash model
+    Parameters:
+    -----------
+    model: a smash model object
+        a smash model object
+    outlets_name: list
+        the list of the outlets name
+    columns : list
+        the column to be plotted in t_axis direction
+    figure: tuple
+        input figure as (fig,ax) to add a new curve
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+    plot_settings_sim: dict or class ax_properties
+        object or dict with any attribute of class plot_settings.Control the simulated curve
+    plot_settings_obs: dict or class ax_properties
+        object or dict with any attribute of class plot_settings. Control the observed curve
+
+    """
+    if model is None:
+        raise ValueError("Input smash model object is None.")
+
+    if isinstance(ax_settings, dict):
+        default_ax_settings = ax_properties(
+            xlabel="Time", ylabel="discharges m^3/s", xtics_fontsize=10, ytics_fontsize=10
+        )
+        default_ax_settings.update(**ax_settings)
+    else:
+        default_ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    if isinstance(plot_settings_sim, dict):
+        default_plot_settings_sim = plot_properties(
+            ls="-",
+            lw="2",
+            marker="",
+            markersize=4,
+            color="blue",
+            label="Sim",
+        )
+        default_plot_settings_sim.update(**plot_settings_sim)
+    else:
+        default_plot_settings_sim = plot_properties(**plot_settings_sim.__dict__)
+
+    # default color for multi curves: same color but different line type
+    if len(columns) >= 2:
+        color = "blue"
+    else:
+        color = "black"
+
+    if isinstance(plot_settings_obs, dict):
+        default_plot_settings_obs = plot_properties(
+            ls="--",
+            lw="1.5",
+            marker="",
+            markersize=4,
+            color=color,
+            label="Obs",
+        )
+        default_plot_settings_obs.update(**plot_settings_obs)
+    else:
+        default_plot_settings_obs = plot_properties()
+
+    # manage date here
+    date_deb = datetime.datetime.fromisoformat(
+        model.setup.start_time
+    ) + datetime.timedelta(seconds=int(model.setup.dt))
+    date_end = datetime.datetime.fromisoformat(model.setup.end_time)
+    date_range = [date_deb, date_end, model.setup.dt]
+
+    if figure is None:
+        if plot_rainfall:
+            fig, (ax1, ax2) = plt.subplots(2, 1, height_ratios=[1, 4])
+            fig.subplots_adjust(hspace=0)
+            figure = [fig, ax2, ax1]
+        else:
+            fig, ax2 = plt.subplots()
+            figure = [fig, ax2]
+    else:
+        if plot_rainfall:
+            fig = figure[0]
+            ax1 = figure[2]
+            ax2 = figure[1]
+        else:
+            fig = figure[0]
+            ax2 = figure[1]
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax2))
+
+    fig, ax2 = plot_chro(
+        model.response_data.q,
+        date_range=date_range,
+        columns=columns,
+        outlets_name=["obs_" + name for name in outlets_name],
+        figure=(fig, ax2),
+        ax_settings=default_ax_settings,
+        fig_settings=fig_settings,
+        plot_settings=default_plot_settings_obs,
+    )
+
+    fig, ax2 = plot_chro(
+        model.response.q,
+        date_range=date_range,
+        columns=columns,
+        outlets_name=["sim_" + name for name in outlets_name],
+        figure=(fig, ax2),
+        ax_settings=default_ax_settings,
+        fig_settings=fig_settings,
+        plot_settings=default_plot_settings_sim,
+    )
+
+    xtics = np.arange(
+        np.datetime64(date_range[0]),
+        np.datetime64(date_range[1] + datetime.timedelta(seconds=int(date_range[2]))),
+        np.timedelta64(int(date_range[2]), "s"),
+    )
+
+    if plot_rainfall:
+
+        if len(columns) > 0:
+            col = columns[0]
+        else:
+            col = 0
+
+        ax1.bar(
+            xtics[:],
+            model.atmos_data.mean_prcp[col, :],
+            label="Average rainfall (mm)",
+            width=np.timedelta64(int(date_range[2]), "s"),
+        )
+
+        ax1.invert_yaxis()
+        ax1.grid(alpha=0.7, ls="--")
+        ax1.get_xaxis().set_visible(False)
+        ax1.set_ylim(bottom=1.2 * max(model.atmos_data.mean_prcp[0, :]), top=0.0)
+        ax1.set_ylabel("Average rainfall (mm)")
+
+    fig, ax = fig_settings.change(figure=(fig, (ax1, ax2)))
+
+    return fig, ax
+
+
+def plot_catchment_surface_error(
+    mesh: dict = None,
+    ax_settings: dict | ax_properties = {},
+    fig_settings: dict | fig_properties = {},
+):
+    """
+    Plot the misfit criteria between the simulated and observed discharges.
+    Parameters:
+    -----------
+    values: np.ndarray
+        The result of the discharge misfit for all outlets.
+    names: np.ndarray
+        Outlets name or code stored in an np.ndarray.
+    columns: list | None
+        Columns of the np.ndarray to plot
+    misfit: str
+        Criteria to plot. choice are ['nse', 'nnse', 'rmse', 'nrmse', 'se', 'kge']"
+    figure: tuple
+        input figure as (fig,ax) to add a new curve
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+    """
+
+    if isinstance(ax_settings, dict):
+        default_ax_settings = ax_properties(
+            title="Catchment surface error (Ssim-Sobs)/Sobs *100",
+            ylabel="Surface error %",
+            xlabel="Outlets",
+            xticklabels_rotation=45,
+            xtics_fontsize=6,
+        )
+        default_ax_settings.update(**ax_settings)
+    else:
+        default_ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    plt.rcParams.update(plt.rcParamsDefault)
+    fig, ax = plt.subplots()
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+
+    surface_error = (mesh["area_dln"] - mesh["area"]) / mesh["area"] * 100
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+    bar_container = ax.bar(
+        mesh["code"], surface_error, color="grey", tick_label=mesh["code"]
+    )
+
+    ax.bar_label(
+        bar_container,
+        fmt=lambda x: f"{x:.2f}",
+        fontsize=default_ax_settings.barlabel_fontsize,
+    )
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+    fig, ax = fig_settings.change(figure=(fig, ax))
+
+    return fig, ax
+
+
+def plot_catchment_surface_consistency(
+    mesh: dict = None,
+    label: bool = True,
+    ax_settings: dict | ax_properties = {},
+    fig_settings: dict | fig_properties = {},
+    plot_settings: dict | plot_properties = {},
+):
+    """
+    Plot the modeled surface vs the observed surface
+    Parameters:
+    -----------
+    mesh: dict, optional
+        The mesh of the Smash model, defaults to None
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+    plot_settings: dict or class plot_properties
+        object or dict with any attribute of class plot_settings.Control the simulated curve
+    """
+
+    if isinstance(ax_settings, dict):
+        default_ax_settings = ax_properties(
+            title="Modeled and observed surface consistency",
+            ylabel="Modeled surface",
+            xlabel="Observed surface",
+        )
+        default_ax_settings.update(**ax_settings)
+    else:
+        default_ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    if isinstance(plot_settings, dict):
+        default_plot_settings = plot_properties(
+            marker="+",
+            markersize=12,
+            color="blue",
+        )
+        default_plot_settings.update(**plot_settings)
+    else:
+        default_plot_settings = plot_properties(**plot_settings.__dict__)
+
+    surface_model = mesh["area_dln"] / 1000.0**2.0
+    surface_obs = mesh["area"] / 1000.0**2.0
+
+    plt.rcParams.update(plt.rcParamsDefault)
+    fig, ax = plt.subplots()
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+
+    ax.plot(
+        surface_obs,
+        surface_model,
+        markersize=default_plot_settings.markersize,
+        marker=default_plot_settings.marker,
+        color=default_plot_settings.color,
+        linestyle="None",
+    )
+    ax.plot(
+        np.linspace(min(surface_obs), max(surface_obs), 10),
+        np.linspace(min(surface_obs), max(surface_obs), 10),
+        linewidth=2,
+        color="grey",
+    )
+
+    if label:
+        ha = ("left", "right")
+        for i, label in enumerate(mesh["code"]):
+            ax.annotate(
+                label,  # this is the text
+                (
+                    surface_obs[i],
+                    surface_model[i],
+                ),  # these are the coordinates to position the label
+                textcoords="data",  # how to position the text
+                xytext=(
+                    surface_obs[i],
+                    surface_model[i],
+                ),  # distance from text to points (x,y)
+                ha=ha[i % 2],  # horizontal alignment can be left, right or center
+                color="red",
+                fontsize=default_ax_settings.annotate_fontsize,
+            )
+
+    ax.set(xlabel=default_ax_settings.xlabel, ylabel=default_ax_settings.ylabel)
+
+    fig, ax = fig_settings.change(figure=(fig, ax))
+
+    return fig, ax
+
+
+def plot_mesh(
+    mesh: dict = None,
+    coef_hydro: float = 99.0,
+    catchment_polygon: None | DataFrame = None,
+    ax_settings: dict | ax_properties = {},
+    fig_settings: dict | fig_properties = {},
+):
+    """
+    Plot the mesh of a smash model
+    Parameters:
+    -----------
+    mesh: a smash mesh as dictionary
+        a smash model object
+    coef_hydro: float
+        the coefficient to colorize the hydrographic network accodring the cumulative
+        surface. default is 99% so that 99% of the cell will be hidden.
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+    """
+
+    if mesh is not None:
+        if isinstance(mesh, dict):
+            pass
+        else:
+            raise ValueError("mesh must be a dict")
+    else:
+        raise ValueError(
+            "model or mesh are mandatory and must be a dict or a smash Model object"
+        )
+
+    if isinstance(ax_settings, dict):
+        default_ax_settings = ax_properties(
+            title="Mesh of the Smash model",
+            xlabel="x_coords",
+            ylabel="y_coords",
+        )
+        default_ax_settings.update(**ax_settings)
+    else:
+        default_ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    # mesh["active_cell"]
+    gauge = mesh["gauge_pos"]
+    stations = mesh["code"]
+    flow_acc = mesh["flwacc"]
+    na = mesh["active_cell"] == 0
+
+    flow_accum_bv = np.where(na, 0.0, flow_acc.data / 1000000.0)
+    surfmin = (1.0 - coef_hydro / 100.0) * np.max(flow_accum_bv)
+    mask_flow = flow_accum_bv < surfmin
+    flow_plot = np.where(mask_flow, np.nan, flow_accum_bv)
+    flow_plot = np.where(na, np.nan, flow_plot)
+
+    plt.rcParams.update(plt.rcParamsDefault)
+    fig, ax = plt.subplots()
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+
+    bbox = geo_toolbox.get_bbox_from_smash_mesh(mesh)
+    extent = (bbox["left"], bbox["right"], bbox["bottom"], bbox["top"])
+
+    active_cell = np.where(na, np.nan, mesh["active_cell"])
+    cmap = ListedColormap(["lightgray"])
+    ax.imshow(active_cell, cmap=cmap, extent=extent)
+
+    myblues = matplotlib.colormaps["Blues"]
+    cmp = ListedColormap(myblues(np.linspace(0.30, 1.0, 265)))
+    im = ax.imshow(flow_plot, cmap=cmp, extent=extent)
+
+    if catchment_polygon is not None:
+        # catchment_polygon = gpd.read_file(outlets_shapefile)
+        catchment_polygon.plot(ax=ax, facecolor="none", edgecolor="black")
+
+    # create an axes on the right side of ax. The width of cax will be 5%
+    # of ax and the padding between cax and ax will be fixed at 0.05 inch.
+    divider = make_axes_locatable(ax)
+    cax = divider.append_axes("right", size="5%", pad=0.05)
+
+    fig.colorbar(
+        im, cmap="Blues", ax=ax, label="Cumulated surface (km²)", shrink=0.75, cax=cax
+    )
+
+    pos_y = -5
+    ha = "right"
+    for i in range(len(stations)):
+        if pos_y > 0:
+            pos_y = -10
+        else:
+            pos_y = 5
+        # pos_y=-1*pos_y
+
+        if ha == "right":
+            ha = "left"
+            pos_x = 5
+        else:
+            ha = "right"
+            # pos_x = -5
+
+        coord = geo_toolbox.rowcol_to_xy(
+            gauge[i][0],
+            gauge[i][1],
+            mesh["xmin"],
+            mesh["ymax"],
+            mesh["xres"],
+            mesh["yres"],
+        )
+
+        code = stations[i]
+        ax.plot(coord[0], coord[1], color="green", marker="o", markersize=6)
+        ax.annotate(
+            code,  # this is the text
+            # these are the coordinates to position the label
+            (coord[0], coord[1]),
+            # textcoords="offset points",  # how to position the text
+            # xytext=(pos_x, pos_y),  # distance from text to points (x,y)
+            textcoords="data",  # how to position the text
+            xytext=(coord[0], coord[1]),  # distance from text to points (x,y)
+            ha=ha,  # horizontal alignment can be left, right or center
+            color="red",
+            fontsize=10,
+        )
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+
+    fig, ax = fig_settings.change(figure=(fig, ax))
+
+    return fig, ax
+
+
+def plot_xy_quantile(
+    res_quantile,
+    X,
+    Y,
+    res_quantile_obs=None,
+    gauge_pos=None,
+    figure=None,
+    ax_settings: dict | ax_properties = {},
+    fig_settings: dict | fig_properties = {},
+    plot_settings: dict | plot_properties = {},
+):
+    """
+    Plot the discharges quantiles fitting at X,Y coordinates.
+    Parameters:
+    -----------
+    res_quantile: dict
+        The result of the discharge quantile computation.
+    res_quantile_obs: dict
+        The results of the observed discharges quantile. res_quantile_obs is a dict and must be computed by the function smashbox.stats.stats.quantile_obs()
+    gauge_pos: int
+        gauge_pos is the index of gauge in the Smash mesh for which the quantile_discharge are provided to the function.
+    X: int
+        Coordinates of the pixel in the row directions (X means row)
+    Y: int
+        Coordinates of the pixel in the column directions (Y means column)
+    figure: tuple
+        input figure as (fig,ax) to add a new curve
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+    """
+    if isinstance(ax_settings, dict):
+        default_ax_settings = ax_properties(
+            xscale="log",
+            xlabel=f"Return period (*{res_quantile['chunk_size']} days)",
+            ylabel="Discharges (m³/s)",
+            grid=True,
+            legend=True,
+        )
+        default_ax_settings.update(**ax_settings)
+    else:
+        default_ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    if isinstance(plot_settings, dict):
+        default_plot_settings = plot_properties(markersize=10)
+        default_plot_settings.update(**plot_settings)
+    else:
+        default_plot_settings = plot_properties(**plot_settings.__dict__)
+
+    quantile = res_quantile["Q_th"][X, Y]
+    maxima = res_quantile["maxima"][X, Y]
+    T_emp = res_quantile["T_emp"]
+    loc = res_quantile["fit_loc"][X, Y]
+    scale = res_quantile["fit_scale"][X, Y]
+    shape = res_quantile["fit_shape"][X, Y]
+    fit = res_quantile["fit"]
+
+    sorted_data = np.sort(maxima)
+
+    plt.rcParams.update(plt.rcParamsDefault)
+    if figure is None:
+        fig, ax = plt.subplots()
+    else:
+        fig, ax = figure
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+
+    if res_quantile_obs is not None and len(res_quantile_obs.keys()) > 0:
+        if gauge_pos is None:
+            raise ValueError(
+                "gauge_pos is None. gauge_pos argument must be an integer corresponding to the gauge index."
+            )
+        maxima_obs = res_quantile_obs["maxima"][gauge_pos, :]
+        T_emp_obs = res_quantile_obs["Temp"][gauge_pos, :]
+
+        ax.plot(
+            T_emp_obs,
+            maxima_obs,
+            "o",
+            label="Observed",
+            color="black",
+            markersize=default_plot_settings.markersize,
+        )
+
+    ax.plot(
+        T_emp,
+        sorted_data,
+        "o",
+        label="Empirical",
+        markersize=default_plot_settings.markersize,
+    )
+
+    ax.plot(
+        res_quantile["T"],
+        quantile,
+        "x",
+        label="Theorical",
+        markersize=default_plot_settings.markersize,
+    )
+
+    Trange = np.linspace(1.1, np.max(res_quantile["T"]), 50)
+
+    if fit == "gumbel":
+        ax.plot(
+            Trange,
+            [stats.quantile_gumbel(T, loc, scale) for T in Trange],
+            "r--",
+            label=f"{fit} fitted",
+            lw=default_plot_settings.lw,
+        )
+
+    if fit == "gev":
+        ax.plot(
+            Trange,
+            [stats.quantile_gev(T, shape, loc, scale) for T in Trange],
+            "r--",
+            label=f"{fit} fitted",
+            lw=default_plot_settings.lw,
+        )
+
+    if "Umax" in res_quantile.keys() and "Umin" in res_quantile.keys():
+        if res_quantile["Umax"] is not None and res_quantile["Umin"] is not None:
+            ax.plot(
+                res_quantile["T"],
+                res_quantile["Umax"][X, Y],
+                "r--",
+                label="Uncertainties (max)",
+                color="grey",
+                lw=default_plot_settings.lw,
+            )
+            ax.plot(
+                res_quantile["T"],
+                res_quantile["Umin"][X, Y],
+                "r--",
+                label="Uncertainties (min)",
+                color="grey",
+                lw=default_plot_settings.lw,
+            )
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+    fig, ax = fig_settings.change(figure=(fig, ax))
+
+    return fig, ax
+
+
+def plot_image(
+    matrice=np.zeros(shape=(2, 2)),
+    bbox=None,
+    vmin=None,
+    vmax=None,
+    mask=None,
+    extend=None,
+    catchment_polygon=None,
+    figure=None,
+    ax_settings: dict | ax_properties = {},
+    fig_settings: dict | fig_properties = {},
+):
+    """
+    Function for plotting a matrix as an image
+
+    Parameters
+    ----------
+    matrice : numpy array
+        Matrix to be plotted
+    bbox : list
+        ["left","right","bottom","top"] bouding box to put x and y coordinates instead
+    of the shape of the matrix
+    vmin: real,
+        minimum z value
+    vmax: real,
+        maximum z value
+    mask: integer, matrix, shape of matice, contain 0 for pixels that should not be plotted
+    catchment_polygon: dataframe containing some polygon to be plotted.
+    Ideally it must contain the boundaries of the catchment as a polygon from a shp file
+    read by geopanda.
+    figure: tuple
+        input figure as (fig,ax) to add a new curve
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+
+    Examples
+    ----------
+    smash.utils.plot_image(mesh_france['drained_area'],bbox=bbox,title="Surfaces
+                           drainées",xlabel="Longitude",ylabel="Latitude",zlabel="Surfaces drainées
+                           km^2",vmin=0.0,vmax=1000,mask=mesh_france['global_active_cell'])
+
+    """
+
+    if isinstance(ax_settings, dict):
+        ax_settings = ax_properties(**ax_settings)
+    else:
+        ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    matrice = np.float32(matrice)
+
+    if bbox is not None:
+        extent = [
+            bbox["left"],
+            bbox["right"],
+            bbox["bottom"],
+            bbox["top"],
+        ]
+    else:
+        extent = None
+
+    if mask is not None:
+        matrice[np.where(mask == 0)] = np.nan
+
+    plt.rcParams.update(plt.rcParamsDefault)
+    if figure is None:
+        fig, ax = plt.subplots()
+    else:
+        fig, ax = figure
+
+    fig, ax = ax_settings.change(figure=(fig, ax))
+
+    im = ax.imshow(matrice, extent=extent, vmin=vmin, vmax=vmax, cmap=ax_settings.cmap)
+
+    if catchment_polygon is not None:
+        catchment_polygon.plot(ax=ax, facecolor="none", edgecolor="black")
+
+    # create an axes on the right side of ax. The width of cax will be 5%
+    # of ax and the padding between cax and ax will be fixed at 0.05 inch.
+    divider = make_axes_locatable(ax)
+    cax = divider.append_axes("right", size="5%", pad=0.05)
+
+    plt.colorbar(im, label=ax_settings.clabel, cax=cax)
+
+    fig, ax = ax_settings.change(figure=(fig, ax))
+    fig, ax = fig_settings.change(figure=(fig, ax))
+
+    return (fig, ax)
+
+
+def plot_misfit(
+    values: np.ndarray = [],
+    names: np.ndarray = [],
+    columns: list | None = None,
+    misfit: str = "nse",
+    figure: list | tuple | None = None,
+    ax_settings: dict | ax_properties = {},
+    fig_settings: dict | fig_properties = {},
+):
+    """
+    Plot the misfit criteria between the simulated and observed discharges.
+    Parameters:
+    -----------
+    values: np.ndarray
+        The result of the discharge misfit for all outlets.
+    names: np.ndarray
+        Outlets name or code stored in an np.ndarray.
+    columns: list | None
+        Columns of the np.ndarray to plot
+    misfit: str
+        Criteria to plot. choice are ['nse', 'nnse', 'rmse', 'nrmse', 'se', 'kge']"
+    figure: tuple
+        input figure as (fig,ax) to add a new curve
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+    """
+
+    if isinstance(ax_settings, dict):
+        default_ax_settings = ax_properties(
+            ylabel=f"{misfit} criteria",
+            xlabel="Gauges stations",
+            grid=True,
+            legend=True,
+            xticklabels_rotation=45,
+            xtics_fontsize=8,
+        )
+        default_ax_settings.update(**ax_settings)
+    else:
+        default_ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    if len(names) == 0:
+        names = np.arange(len(values))
+
+    if columns is not None:
+        values = values[columns]
+        names = names[columns]
+
+    # remove nan from plot
+    columns = list(np.isnan(values) == False)
+    # print(columns)
+    if len(columns) > 0:
+        values = values[columns]
+        names = names[columns]
+
+    if figure is None:
+        fig, ax = plt.subplots()
+    else:
+        fig, ax = figure
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+    bar_container = ax.bar(names, values, color="grey", tick_label=names)
+
+    ax.bar_label(
+        bar_container,
+        fmt=lambda x: f"{x:.2f}",
+        fontsize=default_ax_settings.barlabel_fontsize,
+    )
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+    fig, ax = fig_settings.change(figure=(fig, ax))
+
+    return fig, ax
+
+
+def plot_outlet_stats(
+    values_sim: np.ndarray | None = None,
+    values_obs: np.ndarray | None = None,
+    names: np.ndarray = [],
+    columns: list | None = [],
+    stat: str = "max",
+    figure: list | tuple | None = None,
+    ax_settings: dict | ax_properties = {},
+    fig_settings: dict | fig_properties = {},
+):
+    """
+    Plot a statistical criteria at a given list of outlet.
+    Parameters:
+    -----------
+    values_sim: np.ndarray or None
+        The result of the simulated stat for all outlets.
+    values_obs: np.ndarray or None
+        The result of the observed stat for all outlets.
+    names: np.ndarray
+        Outlets name or code stored in an np.ndarray.
+    columns: list | None
+        Columns of the np.ndarray to plot
+    stat: str
+        Criteria to plot. choice are ['max', 'min', 'mean', 'median', 'q20', 'q80']"
+    figure: tuple
+        input figure as (fig,ax) to add a new curve
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+    """
+
+    if isinstance(ax_settings, dict):
+        default_ax_settings = ax_properties(
+            ylabel=f"{stat} criteria",
+            xlabel="Gauges stations",
+            grid=True,
+            legend=True,
+            xticklabels_rotation=45,
+            xtics_fontsize=6,
+        )
+        default_ax_settings.update(**ax_settings)
+    else:
+        default_ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    if columns is not None:
+        if values_sim is not None:
+            values_sim = values_sim[columns]
+
+        if values_obs is not None:
+            values_obs = values_obs[columns]
+
+        names = names[columns]
+
+    if np.all(values_obs == -99.0):
+        values_obs = None
+
+    if values_sim is not None and values_obs is not None:
+        if values_obs.size != values_sim.size:
+            raise ValueError("values_sim and values_obs must have the same size !")
+
+    if figure is None:
+        fig, ax = plt.subplots()
+    else:
+        fig, ax = figure
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+
+    x = np.arange(len(names))
+    width = 0.25  # the width of the bars
+
+    multiplier = 0
+
+    if values_sim is not None:
+        offset = width * multiplier
+        ax.bar(x + offset, values_sim, width, label="obs")
+        multiplier += 1
+        # ax.bar_label(rects, padding=3)
+
+    if values_obs is not None:
+        offset = width * multiplier
+        ax.bar(x + offset, values_obs, width, label="sim")
+        # ax.bar_label(rects, padding=3)
+        # multiplier += 1
+
+    ax.set_xticks(x + width, names)
+
+    # bar_container = ax.bar(names, values, color="grey", tick_label=names)
+
+    # ax.bar_label(
+    #     bar_container,
+    #     fmt=lambda x: f"{x:.2f}",
+    #     fontsize=default_ax_settings.barlabel_fontsize,
+    # )
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+    fig, ax = fig_settings.change(figure=(fig, ax))
+
+    return fig, ax
+
+
+def plot_misfit_map(
+    values: np.ndarray = [],
+    names: np.ndarray = [],
+    mesh=None,
+    misfit: str = "nse",
+    coef_hydro=99.0,
+    catchment_polygon: None | DataFrame = None,
+    ax_settings: dict | ax_properties = {},
+    fig_settings: dict | fig_properties = {},
+    plot_settings: dict | plot_properties = {},
+):
+    """
+    Map plot of the misfit criteria between the simulated and observed discharges.
+    Parameters:
+    -----------
+    values: np.ndarray
+        The result of the discharge misfit for all outlets.
+    names: np.ndarray
+        Outlets name or code stored in an np.ndarray.
+    mesh: None | dict
+        The mesh of the Smash model as dict
+    misfit: str
+        Criteria to plot. choice are ['nse', 'nnse', 'rmse', 'nrmse', 'se', 'kge']"
+    figure: tuple
+        input figure as (fig,ax) to add a new curve
+    ax_settings: dict or class ax_properties
+        object or dict with any attribute of class ax_properties
+    fig_settings: dict or class ax_properties
+        object or dict with any attribute of class fig_settings
+    plot_settings_sim: dict or class ax_properties
+        object or dict with any attribute of class plot_settings.
+    """
+    if mesh is not None:
+        if isinstance(mesh, dict):
+            pass
+        else:
+            raise ValueError("mesh must be a dict")
+    else:
+        raise ValueError(
+            "model or mesh are mandatory and must be a dict or a smash Model object"
+        )
+
+    if isinstance(ax_settings, dict):
+        default_ax_settings = ax_properties(
+            title=f"Map of {misfit} criteria over the domain.",
+            xlabel="x_coords",
+            ylabel="y_coords",
+            cmap="turbo_r",
+        )
+        default_ax_settings.update(**ax_settings)
+    else:
+        default_ax_settings = ax_properties(**ax_settings.__dict__)
+
+    if isinstance(fig_settings, dict):
+        fig_settings = fig_properties(**fig_settings)
+    else:
+        fig_settings = fig_properties(**fig_settings.__dict__)
+
+    if isinstance(plot_settings, dict):
+        default_plot_settings = plot_properties(
+            marker="o",
+            markersize=8,
+        )
+        default_plot_settings.update(**plot_settings)
+    else:
+        default_plot_settings = plot_properties(**plot_settings.__dict__)
+
+    # unset attribute color, managed separatly
+    delattr(default_plot_settings, "color")
+
+    gauge = mesh["gauge_pos"]
+    stations = mesh["code"]
+    flow_acc = mesh["flwacc"]
+    na = mesh["active_cell"] == 0
+
+    bbox = geo_toolbox.get_bbox_from_smash_mesh(mesh)
+    extent = (bbox["left"], bbox["right"], bbox["bottom"], bbox["top"])
+
+    flow_accum_bv = np.where(na, 0.0, flow_acc.data)
+    surfmin = (1.0 - coef_hydro / 100.0) * np.max(flow_accum_bv)
+    mask_flow = flow_accum_bv < surfmin
+    flow_plot = np.where(mask_flow, np.nan, flow_accum_bv.data)
+    flow_plot = np.where(na, np.nan, flow_plot)
+
+    plt.rcParams.update(plt.rcParamsDefault)
+    fig, ax = plt.subplots()
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+
+    active_cell = np.where(na, np.nan, mesh["active_cell"])
+    cmap = ListedColormap(["lightgray"])
+    ax.imshow(active_cell, cmap=cmap, extent=extent)
+
+    myblues = matplotlib.colormaps["binary"]
+    cmp = ListedColormap(myblues(np.linspace(0.20, 1.0, 265)))
+    im = ax.imshow(flow_plot, cmap=cmp, extent=extent)
+
+    if catchment_polygon is not None:
+        # catchment_polygon = gpd.read_file(outlets_shapefile)
+        catchment_polygon.plot(ax=ax, facecolor="none", edgecolor="black")
+
+    # create an axes on the right side of ax. The width of cax will be 5%
+    # of ax and the padding between cax and ax will be fixed at 0.05 inch.
+    divider = make_axes_locatable(ax)
+    cax = divider.append_axes("right", size="5%", pad=0.05)
+
+    fig.colorbar(
+        im, cmap="Blues", ax=ax, label="Cumulated surface (km²)", shrink=0.75, cax=cax
+    )
+
+    # define bounds for the colormap
+    if misfit == "nse" or misfit == "nnse":
+        vmin = 0
+        vmax = 1
+    elif misfit == "rmse" or misfit == "nrmse" or misfit == "se":
+        vmin = 0
+        vmax = np.max(values)
+    else:
+        vmin = np.min(values)
+        vmax = np.max(values)
+
+    colormap = cm.get_cmap(default_ax_settings.cmap)
+    cmp = ListedColormap(colormap(np.linspace(vmin, vmax, 256)))
+
+    ha = "right"
+    for i in range(len(stations)):
+
+        if ha == "right":
+            ha = "left"
+            str_val = str(np.round(values[i], 2)).rjust(int(len(stations[i])))
+            code = f"{stations[i]}\n {str_val}"
+
+        else:
+            ha = "right"
+            str_val = str(np.round(values[i], 2)).ljust(int(len(stations[i])))
+            code = f"{stations[i]}\n {str_val}"
+
+        coord = geo_toolbox.rowcol_to_xy(
+            gauge[i][0],
+            gauge[i][1],
+            mesh["xmin"],
+            mesh["ymax"],
+            mesh["xres"],
+            mesh["yres"],
+        )
+
+        ax.plot(
+            coord[0],
+            coord[1],
+            color=cmp(values[i]),
+            **default_plot_settings.__dict__,
+        )
+
+        ax.annotate(
+            code,  # this is the text
+            # these are the coordinates to position the label
+            (coord[0], coord[1]),
+            textcoords="data",  # how to position the text
+            xytext=(coord[0], coord[1]),  # distance from text to points (x,y)
+            ha=ha,  # horizontal alignment can be left, right or center
+            color=cmp(values[i]),
+            fontsize=default_ax_settings.annotate_fontsize
+            * default_ax_settings.font_ratio,
+        )
+
+    import matplotlib as mpl
+
+    norm = mpl.colors.Normalize(vmin=vmin, vmax=vmax)
+    # create an axes on the right side of ax. The width of cax will be 5%
+    # of ax and the padding between cax and ax will be fixed at 0.05 inch.
+    # divider = make_axes_locatable(ax)
+    cax = divider.append_axes("right", size="5%", pad=0.5)
+
+    fig.colorbar(
+        cm.ScalarMappable(norm=norm, cmap=cmp),
+        cmap=cmp,
+        ax=ax,
+        cax=cax,
+        label=misfit,
+        shrink=0.75,
+        location="right",
+    )
+
+    fig, ax = default_ax_settings.change(figure=(fig, ax))
+
+    fig, ax = fig_settings.change(figure=(fig, ax))
+
+    return fig, ax
+
+
+# def _ax_settings(
+#     figure,
+#     title: str = None,
+#     xlabel: str = None,
+#     ylabel: str = None,
+#     clabel: str = None,
+#     font_ratio: int = 1,
+#     title_fontsize: int = 12,
+#     label_fontsize: int = 10,
+#     grid: bool = True,
+#     xscale: str | None = None,
+#     yscale: str | None = None,
+#     legend: bool = True,
+#     legend_loc: str = None,
+#     legend_fontsize: int = 8,
+#     xtics_fontsize: int = 8,
+#     ytics_fontsize: int = 8,
+#     cmap: str | None = None,
+#     xlim: tuple | list | None = (None, None),
+#     ylim: tuple | list | None = (None, None),
+# ):
+
+#     fig, ax = figure
+
+#     plt.rcParams.update(plt.rcParamsDefault)
+
+#     if title is not None:
+#         ax.set_title(title, fontsize=title_fontsize * font_ratio)
+
+#     if xlabel is not None:
+#         ax.set_xlabel(xlabel)
+
+#     if ylabel is not None:
+#         ax.set_ylabel(ylabel)
+
+#     if grid:
+#         ax.grid(True, which="both", linestyle="--", alpha=0.5)
+
+#     if xscale is not None:
+#         ax.set_xscale(xscale)
+
+#     if yscale is not None:
+#         ax.set_xyscale(yscale)
+
+#     if legend:
+#         ax.legend(loc=legend_loc)
+
+#     if cmap is not None:
+#         plt.rc("image", cmap=cmap)
+
+#     if ylim[0] != None:
+#         ax.set_ylim(bottom=ylim[0])
+
+#     if ylim[1] != None:
+#         ax.set_ylim(top=ylim[1])
+
+#     if xlim[0] != None:
+#         ax.set_xlim(left=xlim[0])
+
+#     if xlim[1] != None:
+#         ax.set_xlim(right=xlim[1])
+
+#     plt.rcParams.update(
+#         {
+#             "axes.labelsize": label_fontsize * font_ratio,
+#             "axes.titlesize": title_fontsize * font_ratio,
+#             "legend.fontsize": legend_fontsize * font_ratio,
+#             "figure.titlesize": title_fontsize * font_ratio,
+#             "xtick.labelsize": xtics_fontsize * font_ratio,
+#             "ytick.labelsize": ytics_fontsize * font_ratio,
+#         }
+#     )
+
+#     return fig, ax
+
+
+# def _fig_settings(
+#     figure,
+#     figname=None,
+#     xsize=8,
+#     ysize=6,
+#     transparent=False,
+#     dpi=80,
+#     font_ratio=1,
+#     bbox_inches="tight",
+# ):
+
+#     fig, ax = figure
+
+#     fig.set_figheight(ysize)
+#     fig.set_figwidth(xsize)
+
+#     plt.rc(
+#         "font", size=plt.rcParams["font.size"] * font_ratio
+#     )  # controls default text sizes
+#     plt.rc(
+#         "axes", titlesize=plt.rcParams["axes.titlesize"] * font_ratio
+#     )  # fontsize of the axes title
+#     plt.rc(
+#         "axes", labelsize=plt.rcParams["axes.labelsize"] * font_ratio
+#     )  # fontsize of the x and y labels
+#     plt.rc(
+#         "xtick", labelsize=plt.rcParams["xtick.labelsize"] * font_ratio
+#     )  # fontsize of the tick labels
+#     plt.rc(
+#         "ytick", labelsize=plt.rcParams["ytick.labelsize"] * font_ratio
+#     )  # fontsize of the tick labels
+#     plt.rc(
+#         "legend", fontsize=plt.rcParams["legend.fontsize"] * font_ratio
+#     )  # legend fontsize
+#     plt.rc(
+#         "figure", titlesize=plt.rcParams["figure.titlesize"] * font_ratio
+#     )  # fontsize of the figure title
+
+#     if figname is not None:
+#         fig.savefig(figname, transparent=transparent, dpi=dpi, bbox_inches=bbox_inches)
+
+#     return fig, ax