wolfhece 2.2.43__py3-none-any.whl → 2.2.44__py3-none-any.whl

wolfhece/analyze_poly.py

@@ -58,7 +58,7 @@ class Array_analysis_onepolygon():
             self.compute_values()
 
         if which == 'Area' and 'Area' not in self._values:
-            self._add_area2velues()
+            self._add_area2values()
 
         if self._values is None:
             raise ValueError("No values computed. Please call compute_values() first.")
@@ -76,7 +76,7 @@ class Array_analysis_onepolygon():
         if add_values:
             if self._values is None:
                 self.compute_values()
-                self._add_area2velues()
+                self._add_area2values()
 
             if self._values is None:
                 raise ValueError("No values computed. Please call compute_values() first.")
@@ -147,7 +147,7 @@ class Array_analysis_onepolygon():
         else:
             self._values = self._wa.statistics(self._selected_cells)
 
-    def _add_area2velues(self):
+    def _add_area2values(self):
         """ Add the area of the polygon to the values """
 
         if self._selected_cells is None:
@@ -1044,7 +1044,26 @@ class Arrays_analysis_zones():
         if engine == 'seaborn':
             return self._plot_count_strictly_positive_seaborn(show=show, merge_zones=merge_zones)
         elif engine == 'plotly':
-            return self.plot_count_strictly_positive_plotly(show=show, merge_zones=merge_zones)
+            return self._plot_count_strictly_positive_plotly(show=show, merge_zones=merge_zones)
+
+    def save_plot_count_strictly_positive(self, filepath:Path | str,
+                                         merge_zones:bool = False,
+                                         dpi:int = 300):
+        """ Save the plot of the count of strictly positive values for each array in each zone.
+        :param filepath: path to the image file (png)
+        :param merge_zones: whether to merge the zones in the plot
+        :param dpi: resolution of the saved plot
+        :return: None
+        """
+        import matplotlib.pyplot as plt
+        # Force Agg backend for saving the plot
+        old_back = plt.get_backend()
+        plt.switch_backend('Agg')
+        fig, ax = self.plot_count_strictly_positive(show=False, merge_zones=merge_zones, engine='seaborn')
+        fig.savefig(filepath, bbox_inches='tight', dpi=dpi)
+        plt.close(fig)
+        # Restore the previous backend
+        plt.switch_backend(old_back)
 
     def _plot_count_strictly_positive_seaborn(self, show:bool = True, merge_zones:bool = False):
         """ Plot the count of strictly positive values for each array in each zone using seaborn
@@ -1122,6 +1141,32 @@ class Arrays_analysis_zones():
         else:
             raise ValueError(f"Invalid engine '{engine}'. Must be 'seaborn' or 'plotly'.")
 
+    def save_plot_distributed_values(self, filepath:Path | str,
+                                     bins:list[float]= [0., .3, 1.3, -1],
+                                     operator:Literal['Mean', 'Median', 'Sum', 'Volume', 'Area'] = 'Median',
+                                     merge_zones:bool = False,
+                                     dpi:int = 300):
+        """ Save the plot of the distribution of values in bins for each array in each zone or merged zones.
+
+        :param filepath: path to the image file (png)
+        :param bins: list of bin edges
+        :param operator: 'Mean', 'Median', 'Sum', 'Volume', 'Area
+        :param merge_zones: whether to merge the zones in the plot
+        :return: None
+        """
+        import matplotlib.pyplot as plt
+
+        # Force Agg backend for saving the plot
+        old_back = plt.get_backend()
+        plt.switch_backend('Agg')
+
+        fig, ax = self.plot_distributed_values(bins, operator, show=False, merge_zones=merge_zones, engine='seaborn')
+
+        fig.savefig(filepath, bbox_inches='tight', dpi=dpi)
+        plt.close(fig)
+        # Restore the previous backend
+        plt.switch_backend(old_back)
+
     def _plot_distributed_values_seaborn(self, bins:list[float],
                                          operator:Literal['Mean', 'Median', 'Sum', 'Volume', 'Area'],
                                          show:bool = True,
@@ -1137,6 +1182,11 @@ class Arrays_analysis_zones():
         import seaborn as sns
         import matplotlib.pyplot as plt
 
+        # Check which engine is used by matplotlib
+        backend = plt.get_backend()
+        if backend in ['Agg']:
+            show = False
+
         df = self._values_as_df(operator, merge_zones=merge_zones)
 
         if bins[-1] == -1:
@@ -1181,6 +1231,124 @@ class Arrays_analysis_zones():
 
             return (figs, axs)
 
+    def _get_distributed_values(self,
+                                bins:list[float],
+                                operator:Literal['Mean', 'Median', 'Sum', 'Volume', 'Area'],
+                                merge_zones:bool = False):
+
+        """ Save the distribution of values in bins for each array in each zone as a CSV file.
+
+        :param bins: list of bin edges
+        :param operator: 'Mean', 'Median', 'Sum', 'Volume', 'Area
+        :param merge_zones: whether to merge the zones in the plot
+        """
+
+        df = self._values_as_df(operator, merge_zones=merge_zones)
+        if bins[-1] == -1:
+            bins[-1] = df['Value'].max()
+
+        # Bin and count for each array
+        result = []
+        for array in df['Array'].unique():
+            values = df[df['Array'] == array]['Value']
+            counts, edges = np.histogram(values, bins=bins)
+            for edge, count in zip(edges[:-1], counts):
+                result.append({'Array': array, 'Rightmost edge': edge, 'Count': count})
+
+        return pd.DataFrame(result)
+
+    def save_distributed_values(self,
+                                filepath:Path | str,
+                                bins:list[float],
+                                operator:Literal['Mean', 'Median', 'Sum', 'Volume', 'Area'],
+                                merge_zones:bool = False):
+
+        """ Save the distribution of values in bins for each array in each zone as a CSV file.
+
+        :param filepath: path to the CSV file
+        :param bins: list of bin edges
+        :param operator: 'Mean', 'Median', 'Sum', 'Volume', 'Area
+        :param merge_zones: whether to merge the zones in the plot
+        """
+
+        # Ensure CSV extension
+        filepath = Path(filepath)
+        if filepath.suffix != '.csv':
+            filepath = filepath.with_suffix('.csv')
+
+        result = self._get_distributed_values(bins, operator, merge_zones=merge_zones)
+
+        result.to_csv(filepath, index=False)
+
+    def save_distributed_values_table(self,
+                                        filepath:Path | str,
+                                        bins:list[float],
+                                        operator:Literal['Mean', 'Median', 'Sum', 'Volume', 'Area'],
+                                        merge_zones:bool = False):
+        """ Create a table of the distribution of values in bins for each array in each zone.
+
+        :param filepath: path to the image file (png)
+        :param bins: list of bin edges
+        :param operator: 'Mean', 'Median', 'Sum', 'Volume', 'Area
+        :param merge_zones: whether to merge the zones in the plot
+        :return: pandas DataFrame with the counts of values in each bin for each array in each zone
+        """
+
+        # Ensure PNG extension
+        filepath = Path(filepath)
+        if filepath.suffix != '.png':
+            filepath = filepath.with_suffix('.png')
+
+        results = self._get_distributed_values(bins, operator, merge_zones=merge_zones)
+
+        # Calculer la borne inférieure en décalant la colonne
+        results["Bin Lower Edge"] = results.groupby("Array")["Rightmost edge"].shift(1).fillna(0)
+
+        # Créer la chaîne de caractère de l'intervalle
+        results[_("Bounds [m]")] = "]" + results["Bin Lower Edge"].map(lambda x: f"{x:.2f}") + "–" + results["Rightmost edge"].map(lambda x: f"{x:.2f}") + "]"
+        # Ensure 'Count' is integer
+        results['Count'] = results['Count'].astype(int)
+
+        table = results.pivot_table(index=_("Bounds [m]"), columns='Array', values='Count', fill_value=0, sort=False)
+        # Force values as integers
+        table = table.astype(int)
+
+        table.reset_index(inplace=True)
+
+
+        # table.columns = pd.MultiIndex.from_tuples([(_('Arrays'),col) for col in table.columns])
+
+        import dataframe_image as dfi
+
+        # Place the column labels (Array) on the same line as the row label (Intervalle)
+        styled_df = table.style.format(precision=1) \
+            .set_caption(_('Count')) \
+            .set_properties(**{
+            'text-align': 'center',
+            'font-size': '12px',
+            'border': '1px solid black',
+            }) \
+            .set_table_styles([
+            {
+                'selector': 'th.col_heading.level0',
+                'props': [('vertical-align', 'middle')],
+            },
+            {
+                'selector': 'thead th.row_heading.level0',
+                'props': [('vertical-align', 'middle')],
+            },
+            {
+                'selector': 'thead th',
+                'props': [('text-align', 'center'), ('background-color', '#d9edf7'), ('color', '#31708f')],
+            },
+            ])
+        styled_df = styled_df.hide(axis="index")
+
+        # Export the styled DataFrame as an image
+
+        # Convert to html table image
+        dfi.export(styled_df, filename=filepath, dpi = 300)
+
     def _plot_distributed_values_plotly(self, bins:list[float],
                                         operator:Literal['Mean', 'Median', 'Sum', 'Volume', 'Area'],
                                         show:bool = True,
@@ -1363,6 +1531,32 @@ class Building_Waterdepth_analysis(Arrays_analysis_zones):
                                 merge_zones = False):
 
         return super()._plot_distributed_areas_seaborn(bins, operator, show=show, merge_zones=merge_zones)
+
+    def save_plot_distributed_areas(self, filepath,
+                                    bins = [0, 0.3, 1.3, -1],
+                                    operator = 'Median',
+                                    merge_zones = False,
+                                    dpi = 300):
+        """ Save the plot of the distribution of areas in bins for each array in each zone or merged zones.
+        :param filepath: path to the image file (png)
+        :param bins: list of bin edges
+        :param operator: 'Mean', 'Median', 'Sum', 'Volume', 'Area
+        :param merge_zones: whether to merge the zones in the plot
+        :param dpi: resolution of the saved plot
+        :return: None
+        """
+
+        import matplotlib.pyplot as plt
+        # Force Agg backend for saving the plot
+        old_back = plt.get_backend()
+        plt.switch_backend('Agg')
+        fig, ax = self.plot_distributed_areas(bins, operator, show=False, merge_zones=merge_zones, engine='seaborn')
+        fig.savefig(filepath, bbox_inches='tight', dpi=dpi)
+        plt.close(fig)
+        # Restore the previous backend
+        plt.switch_backend(old_back)
+
+
 class Slope_analysis:
     """ Class for slope analysis of in an array based on a trace vector.
 

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 2
-        self.patch = 43
+        self.patch = 44
 
     def __str__(self):
 

wolfhece/dike.py

@@ -13,14 +13,207 @@ from mpl_toolkits.mplot3d.art3d import Poly3DCollection
 import matplotlib.tri as tri
 import time
 
-from wolfpydike.dikeBreaching import pyDike
+try:
+    from wolfpydike.dikeBreaching import pyDike, injector
+except ImportError:
+    # Test if wolfpydike is installed and check the version
+    try:
+        import wolfpydike
+        version = wolfpydike.__version__
+        if version < '0.1.2':
+            raise ImportError("wolfpydike version is too old. Please update to at least version 0.1.2")
+    except:
+        raise ImportError(_("Error importing pyDike. Make sure the pydike library is installed and accessible (use 'pip install wolfpydike')."))
+
+from wolfhece.drawing_obj import Element_To_Draw
+from wolfhece.PyParams import Wolf_Param, Type_Param, Buttons, key_Param, new_json
+from wolfhece.PyDraw import Triangulation
+from wolfhece.wolf_array import WolfArray
+from wolfhece.matplotlib_fig import Matplotlib_Figure
+from wolfhece.PyTranslate import _
+
+from wolfgpu.SimulationRunner import SimulationRunner, SimulationInjector, SimulationProxy
+from wolfgpu.simple_simulation import SimulationDuration, SimpleSimulation
+from wolfgpu.results_store import ResultsStore
+
+class CoupledSimulation():
+    """
+    Class for the coupled simulation between WOLF and pydike.
+    """
+    def __init__(self):
+        self.filename = None
+        self.injectorWolf = None
+        self.interpMatrix = None
+        self.sim = SimpleSimulation()
+        self.store_dir = None
+        # WHEN INTERACTIONS BETWEEN WOLF AND PYDIKE ARE ACTIVATED
+        self.updateFrequency = 30 #[s] Update frequency of the topo in WOLF
+        self.firstUpdate = 1 #[s] Time of the first update of the topo in WOLF
+
+class InjectorWolf(Element_To_Draw):
+    """
+    Class for the injector object.
+    """
+    def __init__(self, idx = '', plotted = True, mapviewer=None, need_for_wx = False):
+        super().__init__(idx, plotted, mapviewer, need_for_wx)
+        self.wp = None
+        self._injector = injector()
+
+    def set_params(self, params):
+        """
+        Set the injector parameters.
+        :param params: Parameters to set for the injector.
+        """
+        return self._injector.set_params(params)
+
+    def get_params(self):
+        """
+        Set the injector parameters.
+        :param params: Parameters to set for the injector.
+        """
+        return self._injector.get_params()
+
+    def save(self):
+        '''
+        Save the parameters in a .json text file
+        '''
+        if self.filename is None:
+            self.save_as()
+        else:
+            with open(self.filename, 'w') as f:
+                json.dump(self.get_params(), f, indent=4)
+
+    def save_as(self):
+        '''
+        Save the parameters in a .json text file
+        '''
+        filterArray = "json (*.json)|*.json|all (*.*)|*.*"
+        fdlg = wx.FileDialog(None, _("Where should the parameters be stored (.json file)?"), wildcard=filterArray, style=wx.FD_SAVE)
+        ret = fdlg.ShowModal()
+        if ret == wx.ID_OK:
+            self.filename = fdlg.GetPath()
+            self.save()
+
+        fdlg.Destroy()
+
+    def callback_apply(self):
+        """
+        Callback function to apply changes made in the Wolf_Param window.
+        Update the parameters in the dike object.
+        """
+        updated_wp = self.wp.merge_dicts()
+        self.from_wp_to_dict(wolf_dict=updated_wp, dict_ref=self.get_params())
+
+    def show_properties(self):
+        """
+        Show properties window
+        """
+        if self.wp is None:
+            self.wp = self.from_dict_to_wp(params_dict=self.get_params())
+            self.wp.set_callbacks(callback_update=self.callback_apply, callback_destroy=None)
+            self.wp._set_gui_dike(title=_('Injector parametrization'))
+            self.wp.hide_selected_buttons([Buttons.Reload,Buttons.Save])
+        self.wp.Show()
+
+    def hide_properties(self):
+        """
+        Hide properties window
+        """
+        if self.wp is not None:
+            self.wp.Hide()
+
+    def from_wp_to_dict(self, wolf_dict, dict_ref) -> dict:
+        """
+        Convert a Wolf_Param dictionary to a "normal" dictionary used as parameters dictionary in the injector object + updates injector attributes accordingly.
+        'dict_ref' used to rename keys (=mapping).
+        :param wolf_dict: Dictionary containing the parameters from the Wolf_Param object.
+        :param dict_ref: Dictionary mapping injector parameter names (keys) to explicit names in wolf_param.
+        :return: Dictionary with injector parameter names as keys, containing values and metadata.
+        """
+        params_dict = {}
 
-from .drawing_obj import Element_To_Draw
-from .PyParams import Wolf_Param, Type_Param, Buttons, key_Param
-from .PyDraw import Triangulation
-from .matplotlib_fig import Matplotlib_Figure
-from .PyTranslate import _
+        for section in wolf_dict.keys():
+            params_dict[section] = {}
+            for param_data in wolf_dict[section].values():
+                explicit_name = param_data[key_Param.NAME]  # Extract explicit name
+
+                # Search for the corresponding injector_key inside dict_ref
+                injector_key = None
+                for section_name, section_params in dict_ref.items():
+                    for param_key, param_details in section_params.items():
+                        if param_details.get("explicit name") == explicit_name:
+                            injector_key = param_key  # Get the correct parameter key
+                            break
+                    if injector_key:  # Exit the outer loop if found
+                        break
 
+                if injector_key is None:
+                    print(_("Warning: No match found in dict_ref for '%s'") % explicit_name)
+                    continue  # Skip if no match is found
+
+                params_dict[section][injector_key] = {
+                    "value": param_data[key_Param.VALUE],
+                    "description": param_data[key_Param.COMMENT],
+                    "explicit name": explicit_name,
+                    "type": param_data[key_Param.TYPE],
+                    "choices": dict_ref[section_name][injector_key].get("choices"),
+                    "mandatory": dict_ref[section_name][injector_key].get("mandatory"),
+                }
+
+        self._dike.update_paramsDict(params_dict)
+
+        return
+
+    def from_dict_to_wp(self,params_dict) -> Wolf_Param:
+        """ Modify the Wolf_Param object to represent the injector parameters. """
+
+        wp = Wolf_Param_dike(parent = None, # Contains all the parameters of the window
+                            title = _("Breaching of a dike"),
+                            to_read=False,
+                            withbuttons=True,
+                            toShow=False,
+                            init_GUI=False,
+                            force_even_if_same_default = True,
+                            filename="default_name.json",
+                            DestroyAtClosing=False)
+
+        for current_section in params_dict.keys():
+            for key in params_dict[current_section].keys():
+
+                value = params_dict[current_section][key]["value"]
+                description = params_dict[current_section][key]["description"]
+                name = params_dict[current_section][key]["explicit name"]
+                # Parameter type
+                if params_dict[current_section][key]["type"] == "Float":
+                    type_param = Type_Param.Float
+                elif params_dict[current_section][key]["type"] == "Integer":
+                    type_param = Type_Param.Integer
+                elif params_dict[current_section][key]["type"] == "Logical":
+                    type_param = Type_Param.Logical
+                elif params_dict[current_section][key]["type"] == "String":
+                    type_param = Type_Param.String
+                elif params_dict[current_section][key]["type"] == "Directory":
+                    type_param = Type_Param.Directory
+                elif params_dict[current_section][key]["type"] == "File":
+                    type_param = Type_Param.File
+
+                if params_dict[current_section][key]["choices"] != None:
+                    wp.add_param((current_section), (name), value, type_param, whichdict='Default', jsonstr=new_json(params_dict[current_section][key]["choices"]), comment=_(description))
+                    if params_dict[current_section][key]["mandatory"]:
+                        wp.add_param((current_section), (name), value, type_param, whichdict='Active', jsonstr=new_json(params_dict[current_section][key]["choices"]), comment=_(description))
+                else:
+                    wp.add_param((current_section), (name), value, type_param, whichdict='Default', comment=_(description))
+                    if params_dict[current_section][key]["mandatory"]:
+                        wp.add_param((current_section), (name), value, type_param, whichdict='Active', comment=_(description))
+        return wp
+
+    # def read_params(self, file_name:str, store_dir: Path = None):
+        # '''
+        # Read the model parameters and store them in a dictionary + updates attributes accordingly
+        # :param file_name: name of the file to read
+        # :param store_dir: directory where to read the file
+        # '''
+        # self._dike.read_params(file_name, store_dir)
 class DikeWolf(Element_To_Draw):
 
     def __init__(self, idx = '', plotted = True, mapviewer=None, need_for_wx = False):
@@ -28,15 +221,64 @@ class DikeWolf(Element_To_Draw):
 
         self.filename = None
         self.wp = None
+        self.injector = None
+        self.interpMatrix = None
         self._dike = pyDike()
 
-    def run(self, store_dir=None):
+    def run_lumped(self, params_dir=None):
         """
-        Run the dike breaching simulation.
+        Run the dike breaching simulation using the lumped model.
         :param store_dir: Directory where the simulation will be run.
         """
         try:
-            self._dike.run(store_dir=store_dir)
+            self._dike.run_initialization(params_dir=params_dir)
+            for time_idx in np.arange(0,self._dike.t_end_idx,1):
+                self._dike.run(time_idx)
+            logging.info(_("Breaching simulation done."))
+        except subprocess.CalledProcessError as e:
+            logging.error(_("Error while running the breaching simulation: %s") % e)
+
+    def set_injector(self):
+        """
+        Set the injector for the dike object.
+        :param injector: Injector object to be set.
+        """
+        self.injectorWolf = InjectorWolf()
+        self.mapviewer.add_object(newobj=self.injectorWolf, which='injector', id=_("Injector_{filename}").format(filename=self.filename))
+
+    def run_2Dcoupled(self, params_dir=None):
+        """
+        Run the dike breaching simulation coupled with WOLF.
+        :param store_dir: Directory where the simulation will be run.
+        """
+        if self.injectorWolf is None:
+            logging.error(_("Injector is not set. Please set the injector before running the simulation."))
+            return
+
+        # Select WOLF array file
+        filterArray = "Wolf array files (*.bin)|*.bin"
+        dlg = wx.FileDialog(self.mapviewer, _('Choose the file containing the Wolf array on which interpolation is applied'), wildcard=filterArray, style=wx.FD_FILE_MUST_EXIST)
+        ret=dlg.ShowModal()
+        if ret == wx.ID_CANCEL:
+            dlg.Destroy()
+        path_TriangArray = dlg.GetPath()
+        self.interpMatrix = WolfArray(fname = path_TriangArray)
+
+        # Select WOLF simulation data folder
+        dlg = wx.DirDialog(self.mapviewer, _('Folder containing WOLF simulation data'), style=wx.DD_DEFAULT_STYLE)
+        ret=dlg.ShowModal()
+        if ret == wx.ID_CANCEL:
+            dlg.Destroy()
+        path_sim = dlg.GetPath()
+        sim = SimpleSimulation.load(path_sim)
+
+        # self.mapviewer.add_object(newobj=sim, which='triangulation', id=_("Triangulation_{filename}_{index:03d}").format(filename=self.filename, index=current_idx))
+        # logging.info(_("Added triangulation for time index %d to viewer.") % current_idx)
+
+        try:
+            self._dike.run_initialization(params_dir=params_dir)
+            for time_idx in np.arange(0,self._dike.t_end_idx,1):
+                self._dike.run(time_idx)
             logging.info(_("Breaching simulation done."))
         except subprocess.CalledProcessError as e:
             logging.error(_("Error while running the breaching simulation: %s") % e)
@@ -143,9 +385,13 @@ class DikeWolf(Element_To_Draw):
                     type_param = Type_Param.File
 
                 if params_dict[current_section][key]["choices"] != None:
-                    wp.add_param((current_section), (name), value, type_param, whichdict='Default', jsonstr={"Values":params_dict[current_section][key]["choices"]}, comment=_(description))
+                    wp.add_param((current_section), (name), value, type_param,
+                                 whichdict='Default', jsonstr=new_json(params_dict[current_section][key]["choices"]),
+                                 comment=_(description))
                     if params_dict[current_section][key]["mandatory"]:
-                        wp.add_param((current_section), (name), value, type_param, whichdict='Active', jsonstr={"Values":params_dict[current_section][key]["choices"]}, comment=_(description))
+                        wp.add_param((current_section), (name), value, type_param,
+                                     whichdict='Active', jsonstr=new_json(params_dict[current_section][key]["choices"]),
+                                     comment=_(description))
                 else:
                     wp.add_param((current_section), (name), value, type_param, whichdict='Default', comment=_(description))
                     if params_dict[current_section][key]["mandatory"]:
@@ -156,22 +402,22 @@ class DikeWolf(Element_To_Draw):
         """
         Load the main outputs and/or the triangulation of the simulation.
         """
-        filterArray = "Parameter files (*_params.json)|*_params.json"
+        filterArray = "Parameter files (*_paramsDike.json)|*_paramsDike.json"
         dlg = wx.FileDialog(self.mapviewer, _('Choose the file containing the simulation parametrization'), wildcard=filterArray, style=wx.FD_FILE_MUST_EXIST)
         ret=dlg.ShowModal()
         if ret == wx.ID_CANCEL:
             dlg.Destroy()
         self.param_path = dlg.GetPath()
-        if self.param_path.endswith("_params.json"):
-            gen_path = self.param_path.removesuffix("_params.json")
+        if self.param_path.endswith("_paramsDike.json"):
+            gen_path = self.param_path.removesuffix("_paramsDike.json")
         else:
-            logging.warning(_("ERROR : the name of the file containing the simulation parametrization should end with '_params.json'"))
+            logging.warning(_("ERROR : the name of the file containing the simulation parametrization should end with '_paramsDike.json'"))
             dlg.Destroy()
             return
 
         self.param_path = Path(self.param_path)
-        self.filename = (self.param_path.name).removesuffix("_params.json")
-        self.read_params(file_name=self.filename+"_params", store_dir=self.param_path.parent)
+        self.filename = (self.param_path.name).removesuffix("_paramsDike.json")
+        self.read_params(file_name=self.filename, store_dir=self.param_path.parent)
 
         try:
             mainOutputs_path = Path(gen_path + '_mainOutputs.txt')
@@ -596,7 +842,7 @@ class Wolf_Param_dike(Wolf_Param):
         # read the file
         if self.wx_exists:
             #ouverture d'une boîte de dialogue
-            file=wx.FileDialog(self,_("Choose .json file"), wildcard="json (*.json)|*.json|all (*.*)|*.*")
+            file=wx.FileDialog(self,_("Choose .json file"), wildcard="Parameter files (*_paramsDike.json)|*_paramsDike.json")
             if file.ShowModal() == wx.ID_CANCEL:
                 return
             else:
@@ -658,7 +904,7 @@ class Wolf_Param_dike(Wolf_Param):
                     type_param = Type_Param.File
 
                 if params_dict[current_section][key]["choices"] != None:
-                    wp.add_param((current_section), (name), value, type_param, whichdict=whichdict, jsonstr={_("Values"):params_dict[current_section][key]["choices"]}, comment=_(description))
+                    wp.add_param((current_section), (name), value, type_param, whichdict=whichdict, jsonstr=new_json(params_dict[current_section][key]["choices"]), comment=_(description))
                 else:
                     wp.add_param((current_section), (name), value, type_param, whichdict=whichdict, comment=_(description))
 

wolfhece/eikonal.py

@@ -435,6 +435,7 @@ def inpaint_waterlevel(water_level:np.ndarray | np.ma.MaskedArray,
     :param dy: (float, optional): The mesh size in y direction.
     :param NoDataValue: (float, optional): The NoDataValue, used if mask is not explicitly provided (mask attribute or water_level as a Numpy MaskedArray). Default is 0.
     :param multiprocess: (bool, optional): Whether to use multiprocessing.
+    :param epsilon: (float, optional): The minimum value to consider that a water height is present.
     """
     if inplace:
         if isinstance(water_level, np.ma.MaskedArray):