wolfhece 2.2.2__py3-none-any.whl → 2.2.4__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/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/PyVertex.py

@@ -822,6 +822,20 @@ class cloud_vertices(Element_To_Draw):
         # read data
         gdf:gpd.GeoDataFrame = gpd.read_file(fn, bbox=bbox)
 
+        if gdf is None:
+            logging.error(_('Error during import of shapefile : ')+fn)
+            return
+
+        # check if the file is empty
+        if gdf.empty:
+            logging.error(_('Imported shapefile is empty : ')+fn)
+            return
+
+        #check if the number of lines is > 0
+        if len(gdf) == 0:
+            logging.error(_('Imported shapefile is empty : ')+fn)
+            return
+
         # Bouclage sur les éléments du Shapefile
         if targetcolumn in gdf.columns:
             k=0
@@ -839,8 +853,7 @@ class cloud_vertices(Element_To_Draw):
         elif 'geometry' in gdf.columns:
 
             try:
-                for k, (xx,yy) in enumerate(zip(gdf.get_coordinates()['x'], gdf.get_coordinates()['y'])):
-
+                for k, (xx,yy) in enumerate(zip(gdf.geometry.x, gdf.geometry.y)):
                     curvert = wolfvertex(xx, yy)
                     curdict = self.myvertices[k] = {}
                     curdict['vertex'] = curvert

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/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,23 +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)
-    fn_write = fn_write.with_suffix('.tif')
-    wd.write_all(fn_write)
-    top.write_all(fn_write.parent / fn_write.stem / "_dem.tif")
-    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:
@@ -73,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):
     """
@@ -161,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)
@@ -170,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'})
@@ -400,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."""
@@ -454,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,
@@ -548,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)
@@ -606,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")
@@ -711,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()
@@ -1078,10 +1125,16 @@ 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,
@@ -1109,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:
@@ -1117,136 +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")
-
-
-            renamed_files = []
-            if True:
-                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")
-
-                # FORTRAN HOLES.EXE
-                subprocess.run([path_bat_file], check=True)
-                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()
-            else:
-                #Python eikonal model
-                from ..eikonal import inpaint_array, inpaint_waterlevel
-
-                dtm = WolfArray(D)
-
-                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]}.tif")])
-                if not A  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()
-
-                empty_folder(self._manager.IN_SA_INTERP)
-
-                for a in A:
-                    a = Path(a)
-                    in_wa = WolfArray(a)
-                    dem_wa = WolfArray(a.parent / a.stem / "_dem.tif")
-                    _t, _wse, _wd = inpaint_waterlevel(in_wa.array, dem_wa.array.data, dtm.array.data, ignore_last_patches=1)
+            return logging.info("No files in EXTRACTED_LAST_STEP_WD. Please provide some or use the 'Load gpu simulation' button.")
 
-                    b = os.path.join(path_Interp, os.path.splitext(os.path.basename(a))[0])
-                    new_name = Path(b).with_suffix('.tif')
-                    renamed_files.append(new_name)
-
-                    in_wa.array.data[:,:] = _wd
-                    in_wa.array.mask[:,:] = _wd == 0.
-                    in_wa.write_all(new_name)
+        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."""

wolfhece/acceptability/func.py

@@ -15,6 +15,7 @@ from ..PyVertexvectors import Zones, zone, vector, wolfvertex, getIfromRGB
 from ..PyTranslate import _
 from ..scenario. config_manager import Config_Manager_2D_GPU
 
+import subprocess
 import geopandas as gpd
 import pandas as pd
 import numpy as np
@@ -94,6 +95,23 @@ def cleaning_directory(dir:Path):
         if item.is_file():
             os.remove(item)
 
+def empty_folder(folder):
+    """
+    Empties the content of a directory if it exists.
+    """
+    if os.path.exists(folder):
+        for files in os.listdir(folder):
+            fn = os.path.join(folder, files)
+            try:
+                if os.path.isfile(fn) or os.path.islink(fn):
+                    os.unlink(fn)  
+                elif os.path.isdir(fn):
+                    shutil.rmtree(fn)  
+            except Exception as e:
+                print(f"Error when deleting file {fn}: {e}")
+    else:
+        print("The folder does not exist.")
+        
 class Accept_Manager():
     """
     Structure to store the directories and names of the files.
@@ -608,10 +626,8 @@ class Accept_Manager():
             for i in range(1, len(rt)-1):
                 # Full formula
                 # pond.append((1./float(rt[i-1]) - 1./float(rt[i]))/2. + (1./float(rt[i]) - 1./float(rt[i+1]))/2.)
-
                 # More compact formula
                 pond.append((1./float(rt[i-1]) - 1./float(rt[i+1]))/2.)
-
             pond.append(1./float(rt[-1]) + (1./float(rt[-2]) - 1./float(rt[-1]))/2.)
 
             return pd.DataFrame(pond, columns=["Ponderation"], index=rt)
@@ -898,15 +914,15 @@ class Accept_Manager():
 
         if len(code) == 0:
             logging.error("The code rasters do not exist")
-            return ["The code rasters do not exist"]
+            return False
 
         if len(vuln) == 0:
             logging.error("The vulnerability rasters do not exist")
-            return ["The vulnerability rasters do not exist"]
+            return False
 
         if len(code) != len(vuln):
             logging.error("The number of code and vulnerability rasters do not match")
-            return ["The number of code and vulnerability rasters do not match"]
+            return False
 
         # we take a reference raster
         ref = gdal.Open(str(code[0]))
@@ -1041,9 +1057,73 @@ class Accept_Manager():
         else :
             logging.error("No Masked_River_extent files. Please provide them.")
         return trace
-
-
-
+    
+    # Interpolation
+    # -----------------------------
+    def batch_creation_and_interpolation(self, checked_paths, iftest):
+        """Creates a batch file to launch holes.exe from the selected simulations and launches it.
+                -Every files in EXTRACTED_LAST_STEP are interpolated for tests (iftest==True).
+                -Only the check simulations of the windows are interpolated for the GUI (iftest!=True)."""
+        path_LastSteps = Path(self.IN_SA_EXTRACTED)
+        C = None
+        D = None
+        for file in os.listdir(Path(self.IN_SA_DEM)):
+            file_path = Path(self.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 == None:
+            return logging.error("DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'")
+            
+        if C == None:
+            return logging.error("DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'")
+             
+        path_Interp =  Path(self.IN_SA_INTERP)
+        path_bat_file = os.path.join(self.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.IN_WATER_DEPTH, "holes.exe") 
+        A, B = [], []
+        if iftest == True:
+            #no checked box in the tests
+            path_Interp =  Path(self.IN_SA_INTERP)
+            path_LastSteps = Path(self.IN_SA_EXTRACTED)
+            A = [os.path.join(path_LastSteps,f) for f in os.listdir(path_LastSteps) if f.endswith('.bin') and not f.endswith('.bin.txt')]
+            B = [os.path.join(path_Interp, os.path.splitext(os.path.basename(f))[0]) for f in A]
+        
+        else : 
+            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:
+            return logging.error("Missing files.")
+        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)
+        
+        empty_folder(self.IN_SA_INTERP)
+        path_bat_file = os.path.join(self.IN_SCEN_DIR, "process_files.bat")
+        subprocess.run([path_bat_file], check=True)
+        
+        renamed_files = []
+        path_fichier=self.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 True, renamed_files
 
 def clip_layer(layer:str,
              file_path:str,