wolfhece 2.2.1__py3-none-any.whl → 2.2.3__py3-none-any.whl

wolfhece/PyGui.py

@@ -7,14 +7,18 @@ Copyright (c) 2024 University of Liege. All rights reserved.
 This script and its content are protected by copyright law. Unauthorized
 copying or distribution of this file, via any medium, is strictly prohibited.
 """
+try:
+    from osgeo import gdal
+except ImportError as e:
+    print(f"Import Error: {e} - GDAL")
+    print("Please install GDAL for your Python version.")
+
 try:
     from os import scandir, getcwd, makedirs
     from os.path import exists, join, isdir, isfile, dirname, normpath, splitext
     from pathlib import Path
     import numpy.ma as ma
     import wx
-    import wx.adv
-    from wx.lib.busy import BusyInfo
     import logging
     from pathlib import Path
 except ImportError as e:

wolfhece/PyHydrographs.py

@@ -55,14 +55,13 @@ class Hydrograph(pd.Series):
                  dtype=None,
                  name='Discharge',
                  copy=None,
-                 file_path:str ='',
-                 fastpath=False) -> None:
+                 file_path:str ='') -> None:
         if file_path != '':
             data =self.read_from_wolf_file(file_path)
         elif isinstance(data, str):
             data = self.read_from_wolf_file(data)
 
-        super().__init__(data,index,dtype, name, copy, fastpath)
+        super().__init__(data,index,dtype, name, copy)
 
     def write_as_wolf_file(self,
                            file_path:str,

wolfhece/PyPalette.py

@@ -844,6 +844,16 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
 
         self.fill_segmentdata()
 
+    def defaultred_minmax(self, array: ma.masked_array, nbnotnull=99999):
+        """Remplissage des valeurs de palette sur base d'une équirépartition de valeurs"""
+
+        self.nb = 2
+        self.values = np.asarray([np.min(array), np.max(array)], dtype=np.float64)
+        self.colors = np.asarray([[255, 255, 255, 255], [255, 0, 0, 255]], dtype=np.int32)
+        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
+
+        self.fill_segmentdata()
+
     def defaultblue(self):
         """Remplissage des valeurs de palette sur base d'une équirépartition de valeurs"""
 

wolfhece/PyParams.py

@@ -721,15 +721,14 @@ class Wolf_Param(wx.Frame):
             #essai pour voir si le groupe existe ou non dans les params actifs
             if not self.is_in_active(groupname):
                 page_active.Append(pg.PropertyCategory(groupname))
+                self.myparams[groupname] = {}
 
             #teste si param existe
             activeprop = self.prop.GetPropertyByName(groupname + paramname)
             if activeprop is None:
                 #si non existant --> on ajoute, si existant --> rien à faire
                 self._insert_elem_to_page(page_active, groupname, param_def)
-            # if not self.is_in_active(groupname, paramname):
-            #     #si non existant --> on ajoute, si existant --> rien à faire
-            #     self._add_elem_to_page(page_active, groupname, param_def)
+                self.myparams[groupname][paramname] = param_def.copy()
 
         else:
             #recopiage de la valeur par défaut

wolfhece/PyVertex.py

@@ -630,12 +630,12 @@ class cloud_vertices(Element_To_Draw):
                 elif ';' in curhead:
                     # séparateur tabulation
                     sep = ';'
-                elif ' ' in curhead:
-                    # séparateur espace
-                    sep = ' '
                 elif ',' in curhead:
                     # séparateur espace
                     sep = ','
+                elif ' ' in curhead:
+                    # séparateur espace
+                    sep = ' '
                 headers = curhead.split(sep)
                 nbcols = len(headers)
             else:
@@ -647,14 +647,14 @@ class cloud_vertices(Element_To_Draw):
                 elif ';' in curline:
                     # séparateur point-virgule
                     sep = ';'
-                elif ' ' in curline:
-                    # séparateur espace
-                    sep = ' '
-                    curline = re.sub(' +', ' ', curline)
                 elif ',' in curline:
                     # séparateur virgule
                     sep = ','
                     curline = re.sub(' +', ' ', curline)
+                elif ' ' in curline:
+                    # séparateur espace
+                    sep = ' '
+                    curline = re.sub(' +', ' ', curline)
 
                 curval = curline.split(sep)
                 nbcols = len(curval)

wolfhece/PyVertexvectors.py

@@ -1229,6 +1229,7 @@ class vector:
 
         if inplace:
             self.import_shapelyobj(buffered)
+            self.reset_linestring()
             return self
         else:
             newvec = vector(fromshapely=buffered, name=self.myname)

wolfhece/PyWMS.py

@@ -16,6 +16,7 @@ import urllib.parse as ul
 import wx
 import logging
 from typing import Union, Literal
+from enum import Enum
 
 from .PyTranslate import _
 
@@ -112,6 +113,7 @@ def getWalonmap(cat:Literal['IMAGERIE/ORTHO_2021', 'ALEA', 'CADMAP', 'LIDAXES',
             return BytesIO(img.read())
         except:
             logging.warning(_('Impossible to get data from web services'))
+            pass
 
 def getVlaanderen(cat:Literal['Adpf'],
                 xl:float,
@@ -166,6 +168,7 @@ def getVlaanderen(cat:Literal['Adpf'],
             return BytesIO(img.read())
         except:
             logging.warning(_('Impossible to get data from web services'))
+            pass
 
 
 def getIGNFrance(cat:str,epsg:str,xl,yl,xr,yr,w,h,tofile=True) -> BytesIO:
@@ -192,7 +195,73 @@ def getIGNFrance(cat:str,epsg:str,xl,yl,xr,yr,w,h,tofile=True) -> BytesIO:
     else:
         return BytesIO(img.read())
 
+def getLifeWatch(cat:Literal['None'],
+                xl:float,
+                yl:float,
+                xr:float,
+                yr:float,
+                w:int = None,
+                h:int = None,
+                tofile=True) -> BytesIO:
+
+    wms=WebMapService(f'https://maps.elie.ucl.ac.be/cgi-bin/mapserv72?map=/maps_server/lifewatch/mapfiles/LW_Ecotopes/latest/{cat}.map&SERVICE=wms',
+                        version='1.3.0')
+
+    ppkm = 300
+    if w is None and h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+    elif w is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = h/real_h
+        w = int(real_w * ppkm)
+        # h = int(real_h * ppkm)
+    elif h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = w/real_w
+        # w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+
+    if tofile:
+        img=wms.getmap(layers=['lc_hr_raster'],
+                    #    styles=['default'],
+                       srs='EPSG:31370',
+                       bbox=(xl,yl,xr,yr),
+                       size=(w,h),
+                       format='image/png',
+                       transparent=False)
+
+        out = open('LifeWatch.png', 'wb')
+        out.write(img.read())
+        out.close()
+        return BytesIO(b'1')
+    else:
+        mycontents=list(wms.contents)
+        curcont=['lc_hr_raster'] # 'MS
+        curstyles=['1']
+
+        try:
+            img=wms.getmap(layers=curcont,
+                        #    styles=curstyles,
+                           srs='EPSG:31370',
+                           bbox=(xl,yl,xr,yr),
+                           size=(w,h),
+                           format='image/png',
+                           transparent=False)
+            return BytesIO(img.read())
+        except:
+            logging.warning(_('Impossible to get data from web services'))
+            pass
+
 if __name__=='__main__':
-    me=pyproj.CRS.from_epsg(27573)
-    t=pyproj.Transformer.from_crs(27573,4326)
-    getIGNFrance('OI.OrthoimageCoverage.HR','EPSG:27563',878000,332300,879000,333300,1000,1000)
+    # me=pyproj.CRS.from_epsg(27573)
+    # t=pyproj.Transformer.from_crs(27573,4326)
+    # getIGNFrance('OI.OrthoimageCoverage.HR','EPSG:27563',878000,332300,879000,333300,1000,1000)
+    img = getLifeWatch('',250000,160000,252000,162000,1000,1000,False)
+    img = Image.open(img)
+    img.show()
+    pass

wolfhece/acceptability/Parallels.py

@@ -15,14 +15,14 @@ from functools import partial
 import os
 from pathlib import Path
 
-def parallel_gpd_clip(layer:list[str], 
-                      file_path:str, 
-                      Study_Area:str, 
-                      output_dir:str, 
+def parallel_gpd_clip(layer:list[str],
+                      file_path:str,
+                      Study_Area:str,
+                      output_dir:str,
                       number_procs:int = 1):
-    """ 
+    """
     Clip the layers to the study area.
-    
+
     Process the layers in parallel.
 
     FIXME: The GPKG driver is it totally parallel compliant?
@@ -50,13 +50,15 @@ def parallel_gpd_clip(layer:list[str],
                     Study_Area=Study_Area,
                     output_dir=output_dir)
         result_list = pool.map(prod_x, layer)
+        pool.close()
+        pool.join()
 
 def parallel_v2r(manager:Accept_Manager,
-                 attribute:str, 
+                 attribute:str,
                  pixel:float,
                  number_procs:int = 1,
                  convert_to_sparse:bool = False):
-    """ 
+    """
     Convert the vector layers to raster.
 
     Process the layers in parallel.
@@ -69,7 +71,7 @@ def parallel_v2r(manager:Accept_Manager,
     :param number_procs: The number of processors to use
 
     """
-    
+
     attribute = str(attribute)
     layers = manager.get_layers_in_codevulne()
 
@@ -81,18 +83,20 @@ def parallel_v2r(manager:Accept_Manager,
     else:
         pool = multiprocessing.Pool(processes=number_procs)
         prod_x=partial(vector_to_raster,
-                       manager=manager, 
-                       attribute=attribute, 
+                       manager=manager,
+                       attribute=attribute,
                        pixel_size=pixel,
-                       convert_to_sparse=convert_to_sparse) 
-        
+                       convert_to_sparse=convert_to_sparse)
+
         result_list = pool.map(prod_x, layers)
+        pool.close()
+        pool.join()
 
-def parallel_datamod(manager:Accept_Manager, 
+def parallel_datamod(manager:Accept_Manager,
                      picc:gpd.GeoDataFrame,
                      capa:gpd.GeoDataFrame,
                      number_procs:int = 1):
-    """ 
+    """
     Apply the data modification to the layers.
 
     Process the layers in parallel.
@@ -103,7 +107,7 @@ def parallel_datamod(manager:Accept_Manager,
     :param number_procs: The number of processors to use
 
     """
-    
+
     layers = manager.get_layers_in_clipgdb()
 
     if number_procs == 1:
@@ -113,8 +117,10 @@ def parallel_datamod(manager:Accept_Manager,
         pool = multiprocessing.Pool(processes=number_procs)
         prod_x=partial(data_modification,
                           manager=manager,
-                          picc=picc, 
-                          capa=capa) 
-        
+                          picc=picc,
+                          capa=capa)
+
         result_list = pool.map(prod_x, layers)
+        pool.close()
+        pool.join()
 

wolfhece/acceptability/acceptability_gui.py

@@ -41,7 +41,7 @@ def nullvalue_for_hole(WA):
     WA.nullvalue = 0.
     WA.set_nullvalue_in_mask()
 
-def read_export_z_bin(fn_read, fn_write, fn_laststep):
+def read_export_z_bin(fn_read, fn_write, fn_laststep, type_extraction):
     """
     Reads the free surface altitude from a GPU simulation and exports it in binary format.
     Inputs:
@@ -49,20 +49,38 @@ def read_export_z_bin(fn_read, fn_write, fn_laststep):
         - fn_laststep: the folder EXTRACTED_LAST_STEP defined in acceptability.
         - fn_write: the path to save the output in binary format.
     """
-    fn_temp = os.path.join(fn_laststep, 'temp')
-    os.makedirs(fn_temp, exist_ok=True)
-    wolfres2DGPU_test = wolfres2DGPU(fn_read)
-    wolfres2DGPU_test.read_oneresult(-1)
-    wd = wolfres2DGPU_test.get_h_for_block(1)
-    top = wolfres2DGPU_test.get_top_for_block(1)
-    nullvalue_for_hole(wd)
-    nullvalue_for_hole(top)
-    wd.array = wd.array + top.array
-    fn_write = fn_write.with_suffix('.bin')
-    wd.write_all(fn_write)
-    shutil.rmtree(fn_temp)
-
-def riverbed_trace(fn_read_simu, fn_output, threshold):
+
+    if type_extraction == "last_step":
+        fn_temp = os.path.join(fn_laststep, 'temp')
+        os.makedirs(fn_temp, exist_ok=True)
+        wolfres2DGPU_test = wolfres2DGPU(fn_read)
+        #changer ici + vérifier si bien SF ou WD (comparer ;) )
+        wolfres2DGPU_test.read_oneresult(-1)
+        wd = wolfres2DGPU_test.get_h_for_block(1)
+        top = wolfres2DGPU_test.get_top_for_block(1)
+        nullvalue_for_hole(wd)
+        nullvalue_for_hole(top)
+        wd.array = wd.array + top.array
+        fn_write = fn_write.with_suffix('.bin')
+        wd.write_all(fn_write)
+        shutil.rmtree(fn_temp)
+
+    if type_extraction == "danger_map":
+        fn_temp = os.path.join(fn_laststep, 'temp')
+        os.makedirs(fn_temp, exist_ok=True)
+        wolfres2DGPU_last = wolfres2DGPU(fn_read)
+        wolfres2DGPU_last.read_oneresult(-1)
+        danger_map_h = wolfres2DGPU(fn_read) .danger_map_only_h(0,-1,1)
+        top = wolfres2DGPU_last.get_top_for_block(1)
+        nullvalue_for_hole(danger_map_h)
+        nullvalue_for_hole(top)
+        danger_map_h.array[danger_map_h.array != 0] += top.array[danger_map_h.array != 0]
+        fn_write = fn_write.with_suffix('.bin')
+        danger_map_h.write_all(fn_write)
+        shutil.rmtree(fn_temp)
+
+
+def riverbed_trace(fn_read_simu, fn_output, threshold, type_extraction):
     """
     Recognizes the riverbed trace based on a simulation, where water depth above a given threshold is considered part of the riverbed.
     Inputs:
@@ -70,15 +88,28 @@ def riverbed_trace(fn_read_simu, fn_output, threshold):
         - fn_output: the location to save the riverbed trace as a .tiff file.
         - threshold: the water depth threshold above which the areas are considered riverbed.
     """
-    wolfres2DGPU_test = wolfres2DGPU(fn_read_simu)
-    wolfres2DGPU_test.read_oneresult(-1)
-    wd = wolfres2DGPU_test.get_h_for_block(1)
-    wd.array[wd.array > 1000] = 0
-    wd.array[wd.array > threshold] = 1
-    wd.array[wd.array < threshold] = 0
-    wd.as_WolfArray()
-    wd.nodata=0
-    wd.write_all(Path(fn_output))
+
+
+    if type_extraction == "last_step":
+        wolfres2DGPU_test = wolfres2DGPU(fn_read_simu)
+        wolfres2DGPU_test.read_oneresult(-1)
+        wd = wolfres2DGPU_test.get_h_for_block(1)
+        wd.array[wd.array > 1000] = 0
+        wd.array[wd.array > threshold] = 1
+        wd.array[wd.array < threshold] = 0
+        wd.as_WolfArray()
+        wd.nodata=0
+        wd.write_all(Path(fn_output))
+
+    if type_extraction=="danger_map":
+        wd = wolfres2DGPU(fn_read_simu) .danger_map_only_h(0,-1,1)
+        wd.array[wd.array > 1000] = 0
+        wd.array[wd.array > threshold] = 1
+        wd.array[wd.array < threshold] = 0
+        wd.as_WolfArray()
+        wd.nodata=0
+        wd.write_all(Path(fn_output))
+
 
 def empty_folder(folder):
     """
@@ -158,7 +189,7 @@ def soustraction(fn_a,fn_b,fn_result):
 #2 - DEM (MNT) value in the buildings traces ------------------------------------------------------------------
 def mask_creation_data(mask_file, ground_file, output_file):
     with rasterio.open(mask_file) as mask_src:
-        mask = mask_src.read(1)
+        mask = mask_src.read(1).astype('float32')
         mask_meta = mask_src.meta
 
     indices = np.where(mask > 0)
@@ -167,7 +198,7 @@ def mask_creation_data(mask_file, ground_file, output_file):
         bathy = bathy_src.read(1)
 
     mask[indices] = bathy[indices]
-    mask[mask <= 0] = 9999.
+    mask[mask <= 0] = 99999.
 
     output_meta = mask_meta.copy()
     output_meta.update({"dtype": 'float32'})
@@ -397,7 +428,10 @@ class AcceptabilityGui(wx.Frame):
     def on_button_click(self, event):
         self.PopupMenu(self.menu)
 
-    def on_menu_click(self, event):
+    def on_button_click2(self, event2):
+        self.PopupMenu(self.menu2)
+
+    def onRiverbed(self, event):
         """Two options for the 'Update Riverbed' button: either the new riverbed trace
         file already exists and the user selects it, or it does not exist, and the user points to
         a no-overflow simulation, allowing the code to create the trace."""
@@ -451,11 +485,23 @@ class AcceptabilityGui(wx.Frame):
                                             "Error", wx.OK | wx.ICON_ERROR
                                         )
                                         break
-                                    wx.MessageBox(
-                                        f"Threshold accepted. Considering riverbed where water depth > {threshold}[m]. Please wait.",
-                                        "Succeed", wx.OK | wx.ICON_INFORMATION
+
+                                    dialog = wx.SingleChoiceDialog(
+                                        parent=None,
+                                        message=f"Threshold accepted. Considering riverbed where water depth > {threshold}[m] via",
+                                        caption="Choix",
+                                        choices=["last step", "danger map"]
                                     )
-                                    riverbed_trace(selected_folder, fn_output, threshold)
+
+                                    if dialog.ShowModal() == wx.ID_OK:
+                                        choix = dialog.GetStringSelection()
+                                        if choix == "last step":
+                                            type_extraction = "last step"
+                                        else:
+                                            type_extraction = "danger_map"
+                                    dialog.Destroy()
+                                    logging.info("Detecting riverbed.")
+                                    riverbed_trace(selected_folder, fn_output, threshold, type_extraction=type_extraction)
                                     logging.info("File created.")
                                     with wx.MessageDialog(
                                         self,
@@ -545,7 +591,11 @@ class AcceptabilityGui(wx.Frame):
 
         self._but_extrinterp = wx.Button(panel, label='Reading and interpolating\n free surface')
         self._but_extrinterp.SetToolTip("To read the simulation, and created the hydraulic input for\n acceptability (interpolated simulated free surfaces)")
-        self._but_extrinterp.Bind(wx.EVT_BUTTON, self.OnInterpolation)
+        self._but_extrinterp.Bind(wx.EVT_BUTTON, self.on_button_click2)
+        self.menu2 = wx.Menu()
+        self.menu2.Append(1, "Interpolate the last step of the simulation.")
+        self.menu2.Append(2, "Interpolate the danger map of the simulation.")
+        self.menu2.Bind(wx.EVT_MENU, self.OnInterpolation)
         sizer_hor1_1.Add(self._but_extrinterp, 1, wx.ALL | wx.EXPAND, 0)
 
         sizer_hor1.Add(self._but_maindir, 2, wx.ALL | wx.EXPAND, 0)
@@ -603,7 +653,7 @@ class AcceptabilityGui(wx.Frame):
         self.menu = wx.Menu()
         self.menu.Append(1, "File of riverbed trace exists.")
         self.menu.Append(2, "Point to a low discharge simulation and calculate the riverbed trace.")
-        self.menu.Bind(wx.EVT_MENU, self.on_menu_click)
+        self.menu.Bind(wx.EVT_MENU, self.onRiverbed)
 
         self._but_toggle_scen = wx.ToggleButton(panel, label="Accounting for scenarios")
         self._but_toggle_scen.SetToolTip("To be activated to surimpose the vuln_ files, \n and so to take into account scenarios")
@@ -708,7 +758,7 @@ class AcceptabilityGui(wx.Frame):
                 dlg.ShowModal()
             return
         else :
-            if (self._manager._study_area is None) or (self._manager._scenario is None):
+            if (self._manager._study_area == None) or (self._manager._scenario == None):
                 logging.error(f"No study area and/or scenario selected, no check of TEMP and OUTPUT.")
                 with wx.MessageDialog(self, f"INPUT is well structured, but TEMP and OUTPUT have not been checked because there is no study area and scenario selected.", "Checking", wx.OK | wx.ICON_INFORMATION) as dlg:
                         dlg.ShowModal()
@@ -964,6 +1014,8 @@ class AcceptabilityGui(wx.Frame):
                 logging.error('No hydraulic scenario selected.')
         else:
             logging.error('No folder found / selected. Please try again.')
+            return
+
         self._check_listbox.Clear()
         self.sims = {}
         for subdir in hydraulic_scen.iterdir():
@@ -1073,10 +1125,17 @@ class AcceptabilityGui(wx.Frame):
         return
 
     def OnInterpolation(self,e):
-        """Interpolates the last extracted time steps present in
-        LAST_STEP_EXTRACTED using the fast marching
+        """Interpolates the last extracted time steps present in LAST_STEP_EXTRACTED using the fast marching
         interpolation routine holes.exe, by creating a batch file
         while performing multiple checks on the required input files."""
+        menu_id = e.GetId()
+        if menu_id == 1:
+            type_extraction = "last_step"
+            logging.info("Option 1 : last step extraction and interpolation.")
+        if menu_id == 2:
+            type_extraction = "danger_map"
+            logging.info("Option 2 : danger map computation and interpolation.")
+
         if not hasattr(self, 'file_paths'):
             with wx.MessageDialog(self,
                                 f"Please, first load gpu simulations via the previous button.",
@@ -1103,7 +1162,7 @@ class AcceptabilityGui(wx.Frame):
                     name = parts[1]
                     fn_write = Path(path_LastSteps / name )
                     dx,dy,nbx,nby,X,Y = display_info_header(self.input_dx, self.input_nbxy, self.input_O, fn_write.with_suffix(".bin"))
-                    read_export_z_bin(fn_read, fn_write, path_LastSteps)
+                    read_export_z_bin(fn_read, fn_write, path_LastSteps, type_extraction = type_extraction)
                 else:
                     logging.info(f"Please, ensure your simulations are named with the return period, e.g sim_T4")
             else:
@@ -1111,113 +1170,27 @@ class AcceptabilityGui(wx.Frame):
         else:
             logging.error('No simulation selected! Please select some in the checkbox.')
 
-        C = None
-        D = None
-        for file in os.listdir(Path(self._manager.IN_SA_DEM)):
-            file_path = Path(self._manager.IN_SA_DEM) / file
-            if file_path.is_file() and file.startswith("MNT_") and file_path.suffix == ".bin":
-                if "mask" not in file:
-                    D = file_path
-                else:
-                    C = file_path
-        if D is None:
-            logging.info("DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'")
-            with wx.MessageDialog(self,
-                        f"DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'",
-                        "Missing file",
-                        style=wx.OK | wx.ICON_INFORMATION) as dlg:
-                dlg.ShowModal()
-            return
-
-        if C is None:
-            logging.info("DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'")
-            with wx.MessageDialog(self,
-                        f"DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'",
-                        "Missing file",
-                        style=wx.OK | wx.ICON_INFORMATION) as dlg:
-                dlg.ShowModal()
-            return
-
-        if not get_header_comparison([fn_write.with_suffix(".bin"), C, D]):
-            logging.info("Files in DEM_FILES do not have the same properties as the simulations files. Please, fix them.")
-            with wx.MessageDialog(self,
-                        f"Files in DEM_FILES do not have the same properties as the simulations files. Please, fix them.",
-                        "Error in DEM_FILES files",
-                        style=wx.OK | wx.ICON_INFORMATION) as dlg:
-                dlg.ShowModal()
-            return
-
         checked_names = self._check_listbox.GetCheckedStrings()
         if not checked_names:
             logging.info("No items selected. Adding all paths.")
             checked_paths = list(self.file_paths.values())
-            message_info = "No simulations were checked in the box; so the computations will consider all of them. The interpolation of the given free surface will begin when you press OK, please wait."
         else:
             logging.info("Adding only the selected simulations.")
             checked_paths = [self.file_paths[name] for name in checked_names]
-            message_info = "The interpolation of the given free surface will begin (for the selected simulation(s)), please wait."
 
         if len(self.file_paths) == 0 :
-            with wx.MessageDialog(self, f"No files in EXTRACTED_LAST_STEP_WD. Please provide some or use the 'Load gpu simulation' button.",
-                        "OK", wx.OK | wx.ICON_INFORMATION) as dlg:
-                dlg.ShowModal()
-        else :
-            path_Interp =  Path(self._manager.IN_SA_INTERP)
-            path_bat_file = os.path.join(self._manager.IN_SCEN_DIR, "process_files.bat")
-
-            if os.path.exists(path_bat_file):
-                logging.info(f"The file {path_bat_file} already exists and will be replaced.")
-                os.remove(path_bat_file)
-            path_code = os.path.join(self._manager.IN_WATER_DEPTH, "holes.exe")
-
-            A=[]
-            for path in checked_paths:
-                parts = path.name.split("sim_")
-                A.extend([os.path.join(path_LastSteps, g) for g in os.listdir(path_LastSteps) if g.endswith(f"{parts[1]}.bin")])
-            B = [os.path.join(path_Interp, os.path.splitext(os.path.basename(f))[0]) for f in A]
-            if not A or not B or not C or not D:
-                logging.info("Missing files.")
-                with wx.MessageDialog(self, f"The interpolation cannot go on, as some files are missing (see logs): please check the DEM_FILES or the EXTRACTED_LAST_STEP_WD folders.",
-                            "Missing files.", wx.OK | wx.ICON_INFORMATION) as dlg:
-                    dlg.ShowModal()
-            with open(path_bat_file, "w") as bat_file:
-                for a, b in zip(A, B):
-                    line = f'"{path_code}" filling in="{a}" out="{b}" mask="{C}" dem="{D} avoid_last=1"\n'
-                    bat_file.write(line)
-            logging.info(message_info)
-
-            empty_folder(self._manager.IN_SA_INTERP)
-            path_bat_file = os.path.join(self._manager.IN_SCEN_DIR, "process_files.bat")
-
-            if True:
-                # FORTRAN HOLES.EXE
-                subprocess.run([path_bat_file], check=True)
-            else:
-                #Python eikonal model
-                from ..eikonal import inpaint_array, inpaint_waterlevel
-                for a, b in zip(A, B):
-                    in_wa = WolfArray(a)
-                    mask_wa = WolfArray(C)
-                    dem_wa = WolfArray(D)
-                    inpaint_array(in_wa.array, mask_wa.array, dem_wa.array, avoid_last=1)
-                    in_wa.write_all(b)
-
-            renamed_files = []
-            path_fichier=self._manager.IN_SA_INTERP
-            for file in path_fichier.glob("*.tif"):
-                if "_h" in file.name:
-                    new_name = file.stem.split("_h")[0].replace(".bin", "") + ".tif"
-                    file.rename(file.with_name(new_name))
-                    renamed_files.append(new_name)
-            #deleting the other
-            for file in path_fichier.glob("*.tif"):
-                if "_combl" in file.name or file.name not in renamed_files:
-                    file.unlink()
+            return logging.info("No files in EXTRACTED_LAST_STEP_WD. Please provide some or use the 'Load gpu simulation' button.")
+
+        interp_bool, renamed_files = self._manager.batch_creation_and_interpolation(checked_paths,None)
+
+        if interp_bool == True:
             logging.info("Filling completed.")
             with wx.MessageDialog(self, f"Filling completed. Created files : {renamed_files}",
                         "Redirecting", wx.OK | wx.ICON_INFORMATION) as dlg:
                 dlg.ShowModal()
-        update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
+            update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
+        else :
+            logging.error("Something went wrong for the interpolation.")
 
     def OnToggle(self,e):
         """Creates a toggle button to be activated if the scenarios vuln_ have to be taken into account."""