wolfhece 2.2.38__py3-none-any.whl → 2.2.39__py3-none-any.whl

wolfhece/acceptability/func.py

@@ -14,10 +14,9 @@ from typing import Union, Literal
 from ..PyVertexvectors import Zones, zone, vector, wolfvertex, getIfromRGB
 from ..PyTranslate import _
 from ..scenario. config_manager import Config_Manager_2D_GPU
-from ..eikonal import inpaint_waterlevel, inpaint_array
-
 import subprocess
 import geopandas as gpd
+
 import pandas as pd
 import numpy as np
 from osgeo import gdal, ogr, osr, gdalconst
@@ -31,6 +30,7 @@ from enum import Enum
 import numba as nb
 import shutil
 
+
 ENGINE = 'pyogrio' # or 'Fiona -- Pyogrio is faster
 EXTENT = '.gpkg'
 class Modif_Type(Enum):
@@ -593,25 +593,17 @@ class Accept_Manager():
         idx_h = [Path(cursim).name.find(".tif") for cursim in sims_modif]
 
         # create the list of return periods -- only the numeric part
-        sims = [int(Path(cursim).name[idx_T[i]+1:]) for i, cursim in enumerate(sims_modif)]
+        sims = [int(Path(cursim).stem[1:]) for i, cursim in enumerate(sims_modif)]
         return sorted(sims)
 
-    def get_modifiedrasters(self):
-        folder = Path(self.IN_CH_SA_SC)
-        vuln_tiff_files = [str(file.name) for file in folder.rglob("*.tiff") if file.name.startswith('vuln_')]
-        vuln_tif_files = [str(file.name)for file in folder.rglob("*.tif") if file.name.startswith('vuln_')]
-        vuln_files = vuln_tiff_files + vuln_tif_files
-
-        folder = Path(self.IN_CH_SA_SC)
-        mnt_tiff_files = [str(file.name) for file in folder.rglob("*.tiff") if file.name.startswith('MNTmodifs_')]
-        mnt_tif_files = [str(file.name) for file in folder.rglob("*.tif") if file.name.startswith('MNTmodifs_')]
-        mnt_files = mnt_tiff_files + mnt_tif_files
-
-        return vuln_files + mnt_files
+    def get_modifiedrasters(self, name:str):
+        """Returns the name_ files (either vuln_ or MNTmodifs_) in CHANGE_VULNE to analyse later on the type."""
+        folder = Path(self.IN_CH_SA_SC) #common folder
+        name_paths = [file for file in folder.rglob("*.tif*") if file.name.startswith(name)]
+        return name_paths
 
     def get_ponderations(self) -> pd.DataFrame:
         """ Get the ponderation data from available simulations """
-
         rt = self.get_return_periods()
 
         if len(rt)==0:
@@ -985,24 +977,61 @@ class Accept_Manager():
                     tiff_trees.append(curtree)
         return tiff_trees
 
-    def select_name_tif(self, path_baseline: Path, folder_path: Path, name) -> list[Path]:
+    def select_name_tif(self, path_baseline: Path, folder_path: Path, name, filter_type = False) -> tuple[list[Path], list[Path]]:
         """
-        Collects and appends all .tiff files starting with 'name' from folder_path into a list.
+        Collects all .tiff files starting with `name` from `folder_path` and appends them to a list.
+        Checks each file's data type against the baseline raster and renames files with a mismatched type,
+        (allowing it not to be surimposed as it does not begin by "vuln_" anymore).
+
+        :param path_baseline: Path to the baseline raster file.
+        :type path_baseline: pathlib.Path
+        :param folder_path: Path to the folder containing raster files to check.
+        :type folder_path: pathlib.Path
+        :param name: Prefix name to filter .tiff files in the folder.
+        :type name: str
+        :return: A tuple containing two lists:
+            - files: List of paths with matching data type.
+            - unused_files: List of paths renamed due to type mismatch.
+        :rtype: tuple[list[pathlib.Path], list[pathlib.Path]]
         """
+
         files = []
-        #first element must be vulnerability_baseline
+        unused_files = []
+
+        # Check type of base of assembly
+        ds_base = gdal.Open(path_baseline.as_posix())
+        type_base = gdal.GetDataTypeName(ds_base.GetRasterBand(1).DataType)
+        ds_base = None
+        
         files.append(path_baseline.as_posix())
-        tiff_trees = Accept_Manager.tree_name_tif(folder_path, name)
 
-        #only the 'final' path of the tree
+        #any files that begin by 'name'
+        tiff_trees = Accept_Manager.tree_name_tif(folder_path, name)
         for tree in tiff_trees:
-            files.append(tree[-1].as_posix())
-        return files
+            file_path = tree[-1]
+            ds = gdal.Open(file_path.as_posix())
+            file_type = gdal.GetDataTypeName(ds.GetRasterBand(1).DataType)
+            ds = None
+            #filter if not the same type and renaming
+            if filter_type == True :
+                if file_type != type_base:
+                    suffix_to_add = f"_{file_type}"
+                    new_name = file_path.parent / f"{file_path.name}{suffix_to_add}"
+                    if not file_path.stem.endswith(suffix_to_add):
+                        file_path.rename(new_name)
+                        unused_files.append(new_name)
+                    else:
+                        unused_files.append(file_path)
+                else:
+                    files.append(file_path.as_posix())
+            else:
+                files.append(file_path.as_posix())
+        return files, unused_files
 
     def check_nodata(self, name, path_baseline):
             """ Check nodata in a path """
             from ..wolf_array import WOLF_ARRAY_FULL_INTEGER8
-            list_tif = Accept_Manager.select_name_tif(self, path_baseline, self.IN_CH_SA_SC, name)
+            list_tif, unused = Accept_Manager.select_name_tif(self, path_baseline, self.IN_CH_SA_SC, name)
             for cur_lst in list_tif:
                 curarray:WolfArray = WolfArray(cur_lst)
                 if curarray.wolftype != WOLF_ARRAY_FULL_INTEGER8:
@@ -1018,14 +1047,19 @@ class Accept_Manager():
         """ Create a vrt file from a path """
         logging.info(_('Checking nodata values...'))
         self.check_nodata(name, fn_baseline)
-        list_tif = Accept_Manager.select_name_tif(self, fn_baseline, fn_scenario, name)
+        list_tif, list_fail = Accept_Manager.select_name_tif(self, fn_baseline, fn_scenario, name, filter_type = True)
+        if len(list_fail)>0:
+                return False, list_fail
         #création du fichier vrt - assembly/agglomération
         if len(list_tif)>1:
             logging.info(_('Creating .vrt from files (first based)...'))
-            create_vrt_from_diverged_files_first_based(list_tif, fn_vrt)
-            return True
+            if name == "vuln_":
+                create_vrt_from_diverged_files_first_based(list_tif, fn_vrt, Nodata = 127)
+            else :
+                create_vrt_from_diverged_files_first_based(list_tif, fn_vrt, Nodata = 99999.)
+            return True, list_fail
         else:
-            return False
+            return False, list_fail
 
 
     def translate_vrt2tif(self, fn_VRT, fn_vuln_s):
@@ -1050,163 +1084,26 @@ class Accept_Manager():
 
         logging.info("All the existing .tif files have been copied to the destination directory.")
 
-    def wich_river_trace(self):
+    def wich_river_trace(self, state_toggle_scen):
         """ Searches for existing riverbed traces: if none ending with '_scenarios' are found, it selects the baseline trace."""
         trace = None
-        if os.path.exists(self.OUT_MASKED_RIVER):
-            trace = self.OUT_MASKED_RIVER
-        elif os.path.exists(self.OUT_MASKED_RIVER_S):
-            trace = self.OUT_MASKED_RIVER_S
+        if state_toggle_scen == True :
+            if os.path.exists(self.OUT_MASKED_RIVER_S):
+                trace = self.OUT_MASKED_RIVER_S
+                logging.info(_(f"Used river mask = {self.OUT_MASKED_RIVER_S}."))
+            elif os.path.exists(self.OUT_MASKED_RIVER):
+                trace = self.OUT_MASKED_RIVER
+                logging.error(_(f"No scenario_ river mask, the used river mask will be the one of the baseline = {self.OUT_MASKED_RIVER}."))
+            else :
+                logging.error(_("No Masked_River_extent file. Please provide it (button 'Update riverbed trace')."))
         else :
-            logging.error(_("No Masked_River_extent files. Please provide them."))
+            if os.path.exists(self.OUT_MASKED_RIVER_S):
+                trace = self.OUT_MASKED_RIVER_S
+                logging.info(_(f"Used river mask = {self.OUT_MASKED_RIVER_S}."))
+            else :
+                logging.error(_("No Masked_River_extent file. Please provide it (button 'Update riverbed trace')."))
         return trace
 
-    # Interpolation
-    # -------------
-
-    def batch_creation_and_interpolation_fotran_holes(self, checked_paths:list[Path], iftest:bool) -> tuple[bool, list[str]]:
-        """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).
-
-        :param checked_paths: list of paths to the checked simulations
-        :param iftest: boolean to indicate if the function is called from the tests or not
-        """
-
-        path_LastSteps = Path(self.IN_SA_EXTRACTED)
-
-        # Identifying the DEM and its mask
-        C = None # DEM mask
-        D = None # DEM
-        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 is 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 is 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:
-            # no checked box in the tests
-            A = [path_LastSteps / f for f in os.listdir(path_LastSteps) if f.endswith('.bin') and not f.endswith('.bin.txt')]
-
-        else :
-            for path in checked_paths:
-                parts = path.name.split("sim_")
-                A.extend([path_LastSteps / g for g in os.listdir(path_LastSteps) if g.endswith(f"{parts[1]}.bin")])
-
-        B = [path_Interp / f.stem 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 = 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 batch_creation_and_interpolation_python_eikonal(self, checked_paths:list[Path], iftest:bool) -> tuple[bool, list[str]]:
-        """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).
-
-        :param checked_paths: list of paths to the checked simulations
-        :param iftest: boolean to indicate if the function is called from the tests or not
-        """
-
-        path_LastSteps = Path(self.IN_SA_EXTRACTED)
-
-        # Identifying the DEM and its mask
-        C = None # DEM mask
-        D = None # DEM
-        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 is None:
-            return logging.error(_("DTM (.bin) not found in DTM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'"))
-
-        if C is 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)
-
-        A, B = [], []
-        if iftest:
-            # no checked box in the tests
-            A = [path_LastSteps / f for f in os.listdir(path_LastSteps) if f.endswith('.bin') and not f.endswith('.bin.txt')]
-
-        else :
-            for path in checked_paths:
-                parts = path.name.split("sim_")
-                A.extend([path_LastSteps / g for g in os.listdir(path_LastSteps) if g.endswith(f"{parts[1]}.bin")])
-
-        B = [path_Interp / f.stem for f in A]
-
-        if not A or not B or not C or not D:
-            return logging.error(_("Missing files."))
-
-        renamed_files = []
-        for a, b in zip(A, B):
-            wa_a = WolfArray(a)
-            wa_c = WolfArray(C)
-            wa_d = WolfArray(D)
-            _t, _d, wh = inpaint_array(data = wa_a.array,
-                          where_compute = wa_c.array.data != wa_c.array.data[0,0],
-                          test = wa_d.array.data,
-                          ignore_last_patches= 1)
-
-            new_name = b.with_suffix(".tif")
-            wa_a.write_all(new_name)
-            renamed_files.append(new_name.name)
-
-        return True, renamed_files
 
 def clip_layer(layer:str,
              file_path:str,
@@ -1717,9 +1614,9 @@ def compute_acceptability(manager:Accept_Manager,
 
     #logging.info(interval)
 
-    points_accept = pd.read_csv(manager.POINTS_CSV)
-
-    if interval not in points_accept["Interval"]:
+    points_accept = pd.read_csv(manager.POINTS_CSV)    
+    
+    if interval not in points_accept["Interval"].to_list():
         logging.error(_("The return period {} is not in the intermediate.csv file -- Please update it").format(interval))
         return None
 

wolfhece/apps/version.py

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