smashbox 1.0__py2.py3-none-any.whl

smashbox/tools/geo_toolbox.py

@@ -0,0 +1,1028 @@
+import numpy as np
+from scipy.ndimage import zoom
+import rasterio
+
+
+# Convert coordinates to mesh matrix row-col (from smash)
+def xy_to_rowcol(x, y, xmin, ymax, xres, yres):
+    row = int((ymax - y) / yres)
+    col = int((x - xmin) / xres)
+    return row, col
+
+
+# Convert mesh matrix row-col to geographic coordinates (from smash)
+def rowcol_to_xy(row, col, xmin, ymax, xres, yres):
+    x = int(col * xres + xmin)
+    y = int(ymax - row * yres)
+    return x, y
+
+
+def get_bbox_from_smash_mesh(mesh):
+    """
+    Description
+    -----------
+    Compute the bbox from a Smash mesh dictionary
+    Parameters
+    ----------
+    mesh: dict
+        dict of smash mesh
+    return
+    ------
+    dict()
+        the bounding box of the smash mesh
+    """
+
+    if "xres" in mesh and "yres" in mesh:
+        dx = mesh["xres"]
+        dy = mesh["yres"]
+    else:
+        dx = np.mean(mesh["dx"])
+        dy = np.mean(mesh["dy"])
+
+    if "ncol" in mesh:
+        ncol = mesh["ncol"]
+        nrow = mesh["nrow"]
+    else:
+        nrow = mesh["active_cell"].shape[0]
+        ncol = mesh["active_cell"].shape[1]
+
+    left = mesh["xmin"]
+    right = mesh["xmin"] + ncol * dx
+    bottom = mesh["ymax"] - nrow * dy
+    top = mesh["ymax"]
+    bbox = {"left": left, "bottom": bottom, "right": right, "top": top}
+
+    return bbox
+
+
+def get_bbox_from_ascii_data(ascii_data):
+    """
+
+    Description
+    -----------
+
+    Compute the boundingbox from ascii-data stored in a dictionnary (must contain the header)
+
+    Parameters
+    ----------
+
+    ascii_data: dict()
+        Un dictionnaire contenant un format ascii: {ascii_data,xllcorner,yllcorner,ncol,nrows,cellsize}, la clé ascii_data contient un sous dictionnaire contenant des clés associés a des sources de données {clé:numpy_array}
+
+    return
+    ------
+
+    dict()
+        Un dictionnaire contenant la boundingbox (coordonnées): {left, bottom, right, top}
+
+    """
+    ascii_data_l = {}
+    for key, value in ascii_data.items():
+        ascii_data_l.update({key.lower(): value})
+
+    bbox = {
+        "left": ascii_data_l["xllcorner"],
+        "bottom": ascii_data_l["yllcorner"],
+        "right": ascii_data_l["xllcorner"]
+        + ascii_data_l["ncols"] * ascii_data_l["cellsize"],
+        "top": ascii_data_l["yllcorner"]
+        + ascii_data_l["nrows"] * ascii_data_l["cellsize"],
+    }
+
+    return bbox
+
+
+def check_bbox_consistency(bbox_model_active_cell, bbox_param):
+
+    if bbox_model_active_cell["left"] < bbox_param["left"]:
+        print(
+            f"Warning: Model domain is larger than the domain of the parameter. {bbox_model_active_cell['left']}<{bbox_param['left']} (bbox model left < bbox param left). Expect lacuna (-99.) in model parameters"
+        )
+
+    if bbox_model_active_cell["right"] > bbox_param["right"]:
+        print(
+            f"Warning: Model domain is larger than the domain of the parameter. {bbox_model_active_cell['right']}>{bbox_param['right']} (bbox model left < bbox param left). Expect lacuna (-99.) in model parameters"
+        )
+
+    if bbox_model_active_cell["bottom"] < bbox_param["bottom"]:
+        print(
+            f"Warning: Model domain is larger than the domain of the parameter. {bbox_model_active_cell['bottom']}<{bbox_param['bottom']} (bbox model left < bbox param left). Expect lacuna (-99.) in model parameters"
+        )
+
+    if bbox_model_active_cell["top"] < bbox_param["top"]:
+        print(
+            f"Warning: Model domain is larger than the domain of the parameter. {bbox_model_active_cell['top']}>{bbox_param['top']} (bbox model left < bbox param left). Expect lacuna (-99.) in model parameters"
+        )
+
+
+def intersection_bbox(bbox1, bbox2):
+    """
+
+    Description
+    -----------
+
+    Function which compute the bounding boxes intersection of 2 input bbox. It return the working bbox
+
+    Parameters
+    ----------
+
+    bbox1: dict()
+        containing the first bbox informations
+    bbox2 : dict()
+        containing the second bbox informations
+
+    returns
+    ----------
+
+    dict()
+        containing the bbox union
+
+    Examples
+    ----------
+
+    dataset=gdal_raster_open(filename)
+    possible_bbox=intersection_bbox(bbox,bbox_dataset)
+
+    """
+    left = max(bbox1["left"], bbox2["left"])
+    bottom = max(bbox1["bottom"], bbox2["bottom"])
+    right = min(bbox1["right"], bbox2["right"])
+    top = min(bbox1["top"], bbox2["top"])
+    if (left < right) and (bottom < top):
+        bbox_intersection = {"left": left, "bottom": bottom, "right": right, "top": top}
+        return bbox_intersection
+    else:
+        print("Impossible bounding boxes intersection")
+        return {"left": 0, "bottom": 0, "right": 0, "top": 0}
+
+
+def get_window_from_bbox(mesh, bbox):
+    """
+    Function to get the mesh window from a defined bbox
+
+    Parameters
+    ----------
+    dataset: gdal object
+    bbox : dict containing the bbox
+    ----------
+    returns
+    dic containing the computed windows
+
+    Examples
+    ----------
+    dataset=gdal_raster_open(filename)
+    bbox_dataset=get_bbox(dataset)
+    window=get_window_from_bbox(dataset,bbox_dataset)
+
+    """
+
+    if "xres" in mesh and "yres" in mesh:
+        dx = mesh["xres"]
+        dy = mesh["yres"]
+    else:
+        dx = np.mean(mesh["dx"])
+        dy = np.mean(mesh["dy"])
+
+    col_off = (bbox["left"] - mesh["xmin"]) / dx
+    row_off = (mesh["ymax"] - bbox["top"]) / dy
+    ncols = (bbox["right"] - bbox["left"]) / dx
+    nrows = (bbox["top"] - bbox["bottom"]) / dy
+
+    if (col_off < 0) or (row_off < 0):
+        raise Exception(
+            "The requested bounding box exceeds the limits of the raster domain."
+        )
+
+    window = {
+        "row_off": int(row_off),
+        "col_off": int(col_off),
+        "nrows": int(nrows),
+        "ncols": int(ncols),
+    }
+
+    return window
+
+
+def get_cropped_window_from_bbox_intersection(bbox_intersection, bbox_origin, dx, dy):
+    """
+
+    Description
+    -----------
+
+    Function to compute the domain to crop between a bbox intersection (included into bbox_origin) and the origin bbox. This function return a window such as the domain with bbox_intersection can be cropped using the retruned window according the bbox_origin
+
+    Parameters
+    ----------
+
+    bbox_intersection: dict
+        A bbox that intersect bbox_origin
+
+    bbox_origin: dict
+        a bbox from which we want to extract data
+
+    dx: float
+        size of the grid in the x direction
+
+    dy: float
+        size of the grid in the y direction
+
+    Return
+    ------
+
+    dict()
+        a window dictionnary containing information to crop a matrix: {row_off, col_off, nrows, ncols}
+
+
+    """
+    if (
+        (bbox_intersection["left"] < bbox_origin["left"])
+        or (bbox_intersection["bottom"] < bbox_origin["bottom"])
+        or (bbox_intersection["right"] > bbox_origin["right"])
+        or (bbox_intersection["top"] > bbox_origin["top"])
+    ):
+        print("The domain of bbox_intersection is not included in the domain of bbox_out")
+        window = {"row_off": 0, "col_off": 0, "nrows": 0, "ncols": 0}
+        return window
+
+    col_off = (bbox_intersection["left"] - bbox_origin["left"]) / dx
+    row_off = (bbox_origin["top"] - bbox_intersection["top"]) / dy
+
+    ncols = (bbox_intersection["right"] - bbox_intersection["left"]) / dx
+    nrows = (bbox_intersection["top"] - bbox_intersection["bottom"]) / dy
+
+    window = {
+        "row_off": int(row_off),
+        "col_off": int(col_off),
+        "nrows": int(nrows),
+        "ncols": int(ncols),
+    }
+
+    return window
+
+
+def write_array_to_geotiff(filename, array, xmin, ymax, xres, yres):
+
+    metadata = {
+        "driver": "GTiff",
+        "dtype": "float64",
+        "nodata": None,
+        "width": array.shape[1],
+        "height": array.shape[0],
+        "count": 1,
+        "crs": None,
+        "transform": rasterio.Affine(xres, 0.0, xmin, 0.0, -yres, ymax),
+    }
+
+    rasterio_write_tiff(filename=filename, matrix=array, metadata=metadata)
+
+
+def rasterio_write_tiff(filename="test.tif", matrix=np.zeros(10), metadata={}):
+
+    with rasterio.Env():
+        with rasterio.open(filename, "w", compress="lzw", **metadata) as dst:
+            dst.write(matrix, 1)
+
+
+def crop_array(
+    array,
+    bbox_in,
+    res_in,
+    bbox_out,
+    res_out,
+    order=0,
+    cval=-99.0,
+    grid_mode=True,
+):
+    """
+
+    Description
+    --------------
+
+    Crop a part of a numpy array with an input bbox and resolution to a new bbox with a new resolution
+
+    Parameters
+    ----------
+
+    array : numpy.array()
+        Input gridded numpy array shape=(n,m)
+
+    bbox_in : dict()
+        bounding box of the input array. Dictionnary {"left":,"top":,"right":,"bottom":}
+
+    res_in : dict()
+        resolution of the input array in x and y direction. Disctionnary {"dx":, "dy":}
+
+    bbox_out : dict()
+        bounding box of the output array. Dictionnary {"left":,"top":,"right":,"bottom":}
+
+    res_out : dict()
+        resolution of the output array in x and y direction. Disctionnary {"dx":, "dy":}
+
+    order : int()
+        order of the resampling cubic interpolation
+
+    cval : float() | np.nan
+        fill value for the extended boundaries
+
+    grid_mode : bool()
+        True | False. if True coordinate start from the edge of the cell. If False coordinate starts from the center of the cell.
+
+    Return
+    ------
+
+    numpy.array()
+        Cropped and resampled array according bbox_out and res_out
+
+    """
+
+    # intersection bbox
+    bbox_intersection = intersection_bbox(bbox_in, bbox_out)
+
+    # ---------------------- fait une découpe grossière du domaine -------
+
+    # 1- crop array on bbox_intersection+-res_in at res in: shrink the domain, speed up futur resampling on large domain ?
+    if res_in["dx"] >= res_out["dx"] and res_in["dy"] >= res_out["dy"]:
+        res_shrinked = {"dx": res_in["dx"], "dy": res_in["dy"]}
+    elif res_in["dx"] < res_out["dx"] and res_in["dy"] < res_out["dy"]:
+        res_shrinked = {"dx": res_out["dy"], "dy": res_out["dy"]}
+    elif res_in["dx"] < res_out["dx"] and res_in["dy"] >= res_out["dy"]:
+        res_shrinked = {"dx": res_out["dx"], "dy": res_in["dy"]}
+    elif res_in["dx"] >= res_out["dx"] and res_in["dy"] < res_out["dy"]:
+        res_shrinked = {"dx": res_in["dx"], "dy": res_out["dy"]}
+
+    bbox_in_shrinked = {
+        "left": bbox_in["left"]
+        + int(max(bbox_intersection["left"] - bbox_in["left"], 0) / res_shrinked["dx"])
+        * res_shrinked["dx"],
+        "right": bbox_in["right"]
+        - int(max(bbox_in["right"] - bbox_intersection["right"], 0) / res_shrinked["dx"])
+        * res_shrinked["dx"],
+        "bottom": bbox_in["bottom"]
+        + int(
+            max(bbox_intersection["bottom"] - bbox_in["bottom"], 0) / res_shrinked["dy"]
+        )
+        * res_shrinked["dy"],
+        "top": bbox_in["top"]
+        - int(max(bbox_in["top"] - bbox_intersection["top"], 0) / res_shrinked["dy"])
+        * res_shrinked["dy"],
+    }
+    bbox_intersection_shrinked = intersection_bbox(bbox_in, bbox_in_shrinked)
+
+    windows_wrap = get_window_from_bbox(
+        mesh={
+            "xmin": bbox_in["left"],
+            "ymax": bbox_in["top"],
+            "xres": res_shrinked["dx"],
+            "yres": res_shrinked["dy"],
+        },
+        bbox=bbox_intersection_shrinked,
+    )
+
+    # Erase input array and bbox_in
+    array = array[
+        windows_wrap["row_off"] : windows_wrap["row_off"] + windows_wrap["nrows"],
+        windows_wrap["col_off"] : windows_wrap["col_off"] + windows_wrap["ncols"],
+    ]
+
+    bbox_in = bbox_intersection_shrinked
+
+    # ---------------------------------------------------------------------------------------
+
+    # 2- resample the array to res_out
+    resampled_array = resample_array(
+        array,
+        res_in=res_in,
+        res_out=res_out,
+        order=order,
+        cval=cval,
+        grid_mode=grid_mode,
+    )
+
+    # 3- crop the array on the intersection of bbox_in and bbox_out
+    # window of bbox_intersection in the domain of bbox_in (bbox_prcp, matrix to read)
+    window_intersection = get_cropped_window_from_bbox_intersection(
+        bbox_intersection, bbox_in, res_out["dx"], res_out["dy"]
+    )
+
+    # reading the part of the matrix (array_in)
+    cropped_array = resampled_array[
+        window_intersection["row_off"] : window_intersection["row_off"]
+        + window_intersection["nrows"],
+        window_intersection["col_off"] : window_intersection["col_off"]
+        + window_intersection["ncols"],
+    ]
+
+    # allocate out array: shape of bbox_out
+    array_out = (
+        np.zeros(
+            shape=(
+                int((bbox_out["top"] - bbox_out["bottom"]) / res_out["dx"]),
+                int((bbox_out["right"] - bbox_out["left"]) / res_out["dy"]),
+            )
+        )
+        - 99.0
+    )
+
+    # window of bbox_intersection in the domain of bbox_smash
+    window_intersection_out = get_cropped_window_from_bbox_intersection(
+        bbox_intersection, bbox_out, res_out["dx"], res_out["dy"]
+    )
+
+    # copy crop_array (input matrix cropped) in array_out
+    array_out[
+        window_intersection_out["row_off"] : window_intersection_out["row_off"]
+        + window_intersection_out["nrows"],
+        window_intersection_out["col_off"] : window_intersection_out["col_off"]
+        + window_intersection_out["ncols"],
+    ] = cropped_array
+
+    return array_out
+
+
+def resample_array(
+    array,
+    res_in={"dx": 1, "dy": 1},
+    res_out={"dx": 1, "dy": 1},
+    order=0,
+    cval=-99.0,
+    grid_mode=True,
+):
+    """
+
+    Parameters
+    ----------
+
+    array: numpy.array()
+        Input gridded numpy array shape=(n,m)
+
+    res_in: dict()
+        resolution of the input array in x and y direction. Disctionnary {"dx":, "dy":}
+
+    res_out: dict()
+        resolution of the output array in x and y direction. Disctionnary {"dx":, "dy":}
+
+    order: int()
+        order of the resampling cubic interpolation
+
+    cval: float() | np.nan
+        fill value for the extended boundaries
+
+    grid_mode: bool()
+        True | False. if True coordinate start from the edge of the cell. If False coordinate starts from the center of the cell.
+
+    Return
+    ------
+
+    numpy.array()
+        Cropped and resampled array according bbox_out and res_out
+
+    """
+
+    ratio_x = res_in["dx"] / res_out["dx"]
+    ratio_y = res_in["dy"] / res_out["dy"]
+    resampled_array = zoom(
+        array,
+        (ratio_y, ratio_x),
+        order=order,
+        mode="grid-constant",
+        cval=-99.0,
+        grid_mode=True,
+    )
+
+    return resampled_array
+
+
+# def read_geotiff_to_ascii(path=""):
+
+#     if not os.path.exists(path):
+#         raise ValueError(f"{path} does not exist.")
+
+#     with rasterio.open(path) as ds:
+#         transform = ds.get_transform()
+#         xmin = transform[0]
+#         ymax = transform[3]
+#         xres = transform[1]
+#         yres = -transform[5]
+
+#         ascii_data = {
+#             "ncols": ds.width,
+#             "nrows": ds.height,
+#             "cellsize": xres,
+#             "xllcorner": xmin,
+#             "yllcorner": ymax - ds.height * yres,
+#             "nodata_value": ds.nodata,
+#             "data": ds.read(indexes=1),
+#         }
+
+#     return ascii_data
+
+
+# def write_smashparam_to_geotiff(model, path):
+
+#     if not os.path.exists(path):
+#         os.mkdir(path)
+
+#     list_param = list(model.rr_parameters.keys)
+
+#     for param in list_param:
+
+#         array = model.rr_parameters.values[:, :, list_param.index(param)]
+
+#         write_array_to_geotiff(
+#             os.path.join(path, param + ".tif"),
+#             array,
+#             model.mesh.xmin,
+#             model.mesh.ymax,
+#             model.mesh.xres,
+#             model.mesh.yres,
+#         )
+
+
+# # format standart smashop ?
+# # faire une fonction qui extrait des params depuis smash vers un dict_ascii_format ?
+# def load_param_from_tiffformat(
+#     model=None, path_to_parameters="", bounding_condition=False
+# ):
+
+#     # check metadata first
+
+#     list_param = model.rr_parameters.keys
+
+#     mesh_out = object_handler.read_object_as_dict(model.mesh)
+
+#     bbox_out = get_bbox_from_smash_mesh(mesh_out)
+#     res_out = {"dx": np.mean(mesh_out["dx"]), "dy": np.mean(mesh_out["dy"])}
+
+#     for param in list_param:
+
+#         if os.path.exists(os.path.join(path_to_parameters, param + ".tif")):
+
+#             ascii_data = read_geotiff_to_ascii(
+#                 os.path.join(path_to_parameters, param + ".tif")
+#             )
+
+#             bbox_in = get_bbox_from_ascii_data(ascii_data)
+
+#             check_bbox_consistency(bbox_out, bbox_in)
+
+#             res_in = {"dx": ascii_data["cellsize"], "dy": ascii_data["cellsize"]}
+
+#             print(f"</> In read_param_from_asciiformat, reading param {param}")
+
+#             cropped_param = crop_array(
+#                 ascii_data["data"],
+#                 bbox_in,
+#                 res_in,
+#                 bbox_out,
+#                 res_out,
+#                 resampling_method="scipy-zoom",
+#                 order=0,
+#                 cval=-99.0,
+#                 grid_mode=True,
+#             )
+
+#             pos = np.where(list_param == param)[0][0]
+#             model.rr_parameters.values[:, :, pos] = cropped_param
+
+#             print("</> Removing values lower than 0")
+#             model.rr_parameters.values[:, :, pos] = np.where(
+#                 model.rr_parameters.values[:, :, pos] < 0,
+#                 0,
+#                 model.rr_parameters.values[:, :, pos],
+#             )
+
+#         else:
+
+#             print(
+#                 f"</> Error: in load_param_from_tiffformat, missing parameter {param} in {path_to_parameters}"
+#             )
+
+
+# # format standart smashop ?
+# # faire une fonction qui extrait des params depuis smash vers un dict_ascii_format ?
+# def load_param_from_asciiformat(model, dict_ascii_parameters, bounding_condition=False):
+
+#     list_param = model.rr_parameters.keys
+
+#     mesh_out = object_handler.read_object_as_dict(model.mesh)
+
+#     bbox_in = get_bbox_from_ascii_data(dict_ascii_parameters)
+#     res_in = {
+#         "dx": dict_ascii_parameters["cellsize"],
+#         "dy": dict_ascii_parameters["cellsize"],
+#     }
+
+#     bbox_out = get_bbox_from_smash_mesh(mesh_out)
+#     res_out = {"dx": np.mean(mesh_out["dx"]), "dy": np.mean(mesh_out["dy"])}
+
+#     check_bbox_consistency(bbox_out, bbox_in)
+
+#     for param in list_param:
+
+#         if param in dict_ascii_parameters["ascii_data"].keys():
+
+#             print(f"</> In read_param_from_asciiformat, reading param {param}")
+
+#             cropped_param = crop_array(
+#                 param,
+#                 bbox_in,
+#                 res_in,
+#                 bbox_out,
+#                 res_out,
+#                 resampling_method="scipy-zoom",
+#                 order=0,
+#                 cval=-99.0,
+#                 grid_mode=True,
+#             )
+
+#             pos = np.where(list_param == param)[0][0]
+#             model.rr_parameters.values[:, :, pos] = cropped_param
+#         else:
+#             print(
+#                 f"</> In read_param_from_asciiformat, skipping missing parameter {param}"
+#             )
+
+
+# def transfert_params_to_model(
+#     from_mesh=dict(), with_param=(dict | object), to_model=None
+# ):
+
+#     if isinstance(with_param, dict):
+#         pass
+#     else:
+#         with_param = object_handler.read_object_as_dict(with_param)
+
+#     structure = to_model.setup.structure
+#     structure_parameters = smash._constant.STRUCTURE_RR_PARAMETERS.copy()
+#     # copy() obligatoire car la liste contenu dans la copie du dictionnaire n'est pas une copy mais un pointeur ...
+#     parameters_list = structure_parameters[structure].copy()
+
+#     mesh_out = object_handler.read_object_as_dict(to_model.mesh)
+
+#     bbox_in = get_bbox_from_smash_mesh(from_mesh)
+
+#     if "xres" in from_mesh and "yres" in from_mesh:
+#         dx = from_mesh["xres"]
+#         dy = from_mesh["yres"]
+#     else:
+#         dx = np.mean(from_mesh["dx"])
+#         dy = np.mean(from_mesh["dy"])
+
+#     res_in = {
+#         "dx": dx,
+#         "dy": dy,
+#     }
+
+#     bbox_out = get_bbox_from_smash_mesh(mesh_out)
+
+#     if "xres" in mesh_out and "yres" in mesh_out:
+#         dx = mesh_out["xres"]
+#         dy = mesh_out["yres"]
+#     else:
+#         dx = np.mean(mesh_out["dx"])
+#         dy = np.mean(mesh_out["dy"])
+
+#     res_out = {
+#         "dx": dx,
+#         "dy": dy,
+#     }
+
+#     for i in range(len(parameters_list)):
+
+#         if "values" in with_param:
+#             param = with_param["values"][:, :, i]
+#             pos = i
+#         else:
+#             param = with_param[parameters_list[i]]
+#             pos = np.where(to_model.rr_parameters.keys == parameters_list[i])[0][0]
+
+#         cropped_param = crop_array(
+#             param,
+#             bbox_in,
+#             res_in,
+#             bbox_out,
+#             res_out,
+#             resampling_method="scipy-zoom",
+#             order=0,
+#             cval=-99.0,
+#             grid_mode=True,
+#         )
+
+#         to_model.rr_parameters.values[:, :, pos] = cropped_param
+
+
+# def resample_array(
+#     array,
+#     res_in={"dx": 1, "dy": 1},
+#     res_out={"dx": 1, "dy": 1},
+#     # resampling_method="scipy-zoom",
+#     order=3,
+#     cval=-99.0,
+#     grid_mode=True,
+# ):
+# """
+
+# Description
+# -----------
+
+# Resample an array with input resolution to the output resolution. It use zoom function form scipy package.
+
+# Parameters
+# ----------
+
+# array: numpy.array()
+#     Input gridded numpy array shape=(n,m)
+
+# res_in: dict()
+#     resolution of the input array in x and y direction. Disctionnary {"dx":, "dy":}
+
+# res_out: dict()
+#     resolution of the output array in x and y direction. Disctionnary {"dx":, "dy":}
+
+# resampling_method: str()
+#     scipy-zoom | numpy ; scipy-zoom use the zoom function from scipy (see function resample_array_scipy_zoom for other input arg). numpy only resample using basic function np.repeat ans basic calculation (not suitable for every case).
+
+# Return
+# ------
+
+# numpy.array()
+#     Resampled array according res_out
+
+# """
+# if resampling_method == "numpy":
+#     resampled_array = resample_array_numpy(array, res_in=res_in, res_out=res_out)
+
+#     if resampled_array is None:
+#         print("</>Fallback to scipy-zoom resampling (scipy.ndimage.zoom method)")
+#         resampling_method = "scipy-zoom"
+
+# if resampling_method == "scipy-zoom":
+#     resampled_array = resample_array_scipy_zoom(
+#         array, res_in, res_out, order=0, cval=-99.0, grid_mode=True
+#     )
+
+# return resampled_array
+
+
+# def resample_array_numpy(array, res_in={"dx": 1, "dy": 1}, res_out={"dx": 1, "dy": 1}):
+#     """
+
+#     Description
+#     -----------
+
+#     resample an array with input resolution to the output resolution. It simpy use numpy functions.
+
+#     Parameters
+#     ----------
+
+#     array: numpy.array()
+#         Input gridded numpy array shape=(n,m)
+
+#     res_in: dict()
+#         resolution of the input array in x and y direction. Disctionnary {"dx":, "dy":}
+
+#     res_out: dict()
+#         resolution of the output array in x and y direction. Disctionnary {"dx":, "dy":}
+
+#     Return
+#     ------
+
+#     numpy.array()
+#         Resampled array according res_out
+
+#     """
+#     # 1Resampling
+#     if (res_in["dx"] >= res_out["dx"]) and (res_in["dy"] >= res_out["dy"]):
+#         ratio_x = int(res_in["dx"] / res_out["dx"])
+#         ratio_y = int(res_in["dy"] / res_out["dy"])
+#         # resampling input matrix to dx,dy smash si résolution demandée est inférieur
+#         resampled_array = np.repeat(np.repeat(array, ratio_x, axis=0), ratio_y, axis=1)
+
+#     elif (res_in["dx"] < res_out["dx"]) and (res_in["dy"] < res_out["dy"]):
+
+#         ratio_x = int(res_out["dx"] / res_in["dx"])
+#         ratio_y = int(res_out["dy"] / res_in["dy"])
+#         # resampling input matrix si résolution demandée est supérieur:
+#         xsize = int(np.ceil(array.shape[0] / ratio_x))
+#         ysize = int(np.ceil(array.shape[1] / ratio_y))
+#         resampled_array = np.full(shape=(xsize, ysize), fill_value=0)
+
+#         xr = 0
+#         for x in range(0, xsize):
+#             yr = 0
+#             for y in range(0, ysize):
+#                 buffer = array[xr : xr + ratio_x, yr : yr + ratio_y]
+#                 average = np.mean(buffer, axis=(0, 1))
+#                 resampled_array[x, y, :] = average
+#                 yr = yr + ratio_y
+#             xr = xr + ratio_x
+#     else:
+#         print(
+#             "</> average resampling method impossible, different resampling resolution in x and y axis."
+#         )
+#         return None
+
+#     return resampled_array
+
+
+# def import_parameters(model: Model, path_to_parameters: FilePath):
+#     """
+#     Description
+#     -----------
+#     Read a geotif, resample if necessarry then clip it on the bouning box of the smash mesh
+
+#     Parameters
+#     ----------
+#     model: object
+#         SMASH model object
+#     path_to_parameters: str
+#         Path to the directory which contain the geotiff files (parameters)
+
+#     return
+#     ------
+#     np.ndarray
+#         The data clipped on the SMASH bounding box
+#     """
+#     list_param = model.rr_parameters.keys
+
+#     for param in list_param:
+#         if os.path.exists(os.path.join(path_to_parameters, param + ".tif")):
+#             cropped_param = _rasterio_read_param2(
+#                 path=os.path.join(path_to_parameters, param + ".tif"), mesh=model.mesh
+#             )
+
+#             pos = np.argwhere(list_param == param).item()
+#             model.rr_parameters.values[:, :, pos] = cropped_param
+
+#         else:
+#             raise ValueError(f"Missing parameter {param} in {path_to_parameters}")
+
+
+# def _rasterio_read_param(path: FilePath, mesh: MeshDT):
+#     """
+#     Description
+#     -----------
+#     Read a geotif, resample if necessarry then clip it on the bouning box of the smash mesh
+
+#     Parameters
+#     ----------
+#     path: str
+#         Path to a geotiff file.
+#     mesh: object
+#         object of the smash mesh
+
+#     return
+#     ------
+#     np.ndarray
+#         The data clipped on the SMASH bounding box
+#     """
+#     bounds = get_bbox_from_smash_mesh(mesh)
+#     xres = mesh.xres
+#     yres = mesh.yres
+
+#     # Open the larger raster
+#     with rasterio.open(path) as dataset:
+#         x_scale_factor = dataset.res[0] / xres
+#         y_scale_factor = dataset.res[1] / yres
+
+#         # resampling first to avoid spatial shifting of the parameters
+#         data = dataset.read(
+#             out_shape=(
+#                 dataset.count,
+#                 int(dataset.height * y_scale_factor),
+#                 int(dataset.width * x_scale_factor),
+#             ),
+#             resampling=Resampling.nearest,
+#         )
+
+#     bbox_dataset = {
+#         "left": dataset.bounds.left,
+#         "bottom": dataset.bounds.bottom,
+#         "right": dataset.bounds.right,
+#         "top": dataset.bounds.top,
+#     }
+
+#     bbox_intersection = intersection_bbox(bbox_dataset, bounds)
+
+#     window_intersection = get_cropped_window_from_bbox_intersection(
+#         bbox_intersection, bbox_dataset, xres, yres
+#     )
+
+#     cropped_array = data[
+#         0,
+#         window_intersection["row_off"] : window_intersection["row_off"]
+#         + window_intersection["nrows"],
+#         window_intersection["col_off"] : window_intersection["col_off"]
+#         + window_intersection["ncols"],
+#     ]
+
+#     # allocate out array: shape of bbox_out
+#     array_out = np.zeros(
+#         shape=(
+#             int((bounds["top"] - bounds["bottom"]) / xres),
+#             int((bounds["right"] - bounds["left"]) / yres),
+#         )
+#     )
+
+#     # window of bbox_intersection in the domain of bbox_smash
+#     window_intersection_out = get_cropped_window_from_bbox_intersection(
+#         bbox_intersection, bounds, xres, yres
+#     )
+
+#     # copy crop_array (input matrix cropped) in array_out
+#     array_out[
+#         window_intersection_out["row_off"] : window_intersection_out["row_off"]
+#         + window_intersection_out["nrows"],
+#         window_intersection_out["col_off"] : window_intersection_out["col_off"]
+#         + window_intersection_out["ncols"],
+#     ] = cropped_array
+
+#     return array_out
+
+
+# def _rasterio_read_param2(path: FilePath, mesh: MeshDT):
+#     """
+#     Description
+#     -----------
+#     Read a geotif, resample if necessarry then clip it on the bouning box of the smash mesh
+
+#     Parameters
+#     ----------
+#     path: str
+#         Path to a geotiff file.
+#     mesh: object
+#         object of the smash mesh
+
+#     return
+#     ------
+#     np.ndarray
+#         The data clipped on the SMASH bounding box
+#     """
+#     input_bbox = get_bbox_from_smash_mesh(mesh)
+
+#     xres = mesh.xres
+#     yres = mesh.yres
+
+#     output_crs = rasterio.CRS.from_epsg(mesh.epsg)
+
+#     # Open the larger raster
+#     with rasterio.open(path) as dataset:
+
+#         x_scale_factor = dataset.res[0] / xres
+#         y_scale_factor = dataset.res[1] / yres
+
+#         transform = dataset.transform
+#         height = dataset.height
+#         width = dataset.width
+#         crs = dataset.crs
+
+#         # resampling first to avoid spatial shifting of the parameters
+#         data = dataset.read(
+#             out_shape=(
+#                 dataset.count,
+#                 int(dataset.height * y_scale_factor),
+#                 int(dataset.width * x_scale_factor),
+#             ),
+#             resampling=Resampling.nearest,
+#         )
+
+#     # Use a memory dataset
+#     with rasterio.io.MemoryFile() as memfile:
+
+#         with memfile.open(
+#             driver="GTiff",
+#             height=height,
+#             width=width,
+#             count=1,
+#             dtype=data.dtype,
+#             transform=transform,
+#             crs=crs,
+#         ) as dataset:
+#             dataset.write(data[0, :, :], 1)
+
+#             new_width = int((input_bbox["right"] - input_bbox["left"]) / yres)
+#             new_height = int((input_bbox["top"] - input_bbox["bottom"]) / xres)
+#             new_transform = rasterio.transform.from_bounds(
+#                 west=input_bbox["left"],
+#                 south=input_bbox["bottom"],
+#                 east=input_bbox["right"],
+#                 north=input_bbox["top"],
+#                 width=new_width,
+#                 height=new_height,
+#             )
+
+#             # Target array
+#             new_array = np.empty((new_height, new_width), dtype=np.float32)
+
+#             # reproject dataset
+#             rasterio.warp.reproject(
+#                 source=rasterio.band(dataset, 1),
+#                 destination=new_array,
+#                 src_transform=transform,
+#                 src_crs=crs,
+#                 dst_transform=new_transform,
+#                 dst_crs=output_crs,
+#                 resampling=Resampling.nearest,
+#             )
+
+#     return new_array