wolfhece 2.1.120__py3-none-any.whl → 2.1.122__py3-none-any.whl

wolfhece/acceptability/func.py

@@ -152,7 +152,7 @@ class Accept_Manager():
 
     def __init__(self,
                  main_dir:str = 'Data',
-                 Study_area:str = 'Bassin_Vesdre.shp',
+                 Study_area = None,
                  scenario = None,
                  Original_gdb:str = 'GT_Resilence_dataRisques202010.gdb',
                  CaPa_Walloon:str = 'Cadastre_Walloon.gpkg',
@@ -171,9 +171,7 @@ class Accept_Manager():
         # If it is a string, concatenate it with the current directory
         if not self.main_dir.is_absolute():
             self.main_dir = Path(os.getcwd()) / self.main_dir
-
-        self._study_area = str(Study_area)
-
+        self._study_area = Study_area
         if Study_area is not None:
             if not str(self._study_area).endswith('.shp'):
                 self._study_area += '.shp'
@@ -391,7 +389,7 @@ class Accept_Manager():
             self._study_area = None
             self._scenario = None
         else:
-            if Study_area in self.get_list_studyareas(with_suffix=True):
+            if Study_area in self.get_list_studyareas(with_suffix=True) or Study_area+".shp" in self.get_list_studyareas(with_suffix=True):
                 self._study_area = Path(Study_area)
             else:
                 logging.error("The study area does not exist in the study area directory")
@@ -474,18 +472,17 @@ class Accept_Manager():
         sims = self.get_sims_files_for_scenario()
 
         if len(sims)==0:
-            logging.info("No simulations found") #no error, need to act if so. See accept manager flow chart
+            logging.info("No simulations found at this stage") 
             return None
 
         if "_h.tif" in sims[0].name:
             for cursim in sims:
-                if cursim.stem.find("_T{}_".format(return_period)) != -1:
+                if cursim.stem.find("_T{}_".format(return_period)) != -1  or cursim.stem.find("_Q{}_".format(return_period))  != -1:
                     return cursim
         else:
             for cursim in sims:
-                if cursim.stem.find("T{}".format(return_period)) != -1:
+                if cursim.stem.find("T{}".format(return_period)) != -1 or cursim.stem.find("Q{}".format(return_period))  != -1:
                     return cursim
-
         return None
 
     def get_types_in_file(self, file:str) -> list[str]:
@@ -560,44 +557,36 @@ class Accept_Manager():
 
         # List files in directory
         sims = self.get_sims_files_for_scenario()
-
+        sims_modif = [
+            os.path.join(os.path.dirname(path), os.path.basename(path).replace("Q", "T"))
+            for path in sims
+            ]
+        
         if len(sims)==0:
-            logging.info("No simulations found")#no error, need to act if so. See accept manager flow chart
+            logging.info("No simulations found at this stage.")
             return []
 
-        # Two cases:
-        # - Return periods are named as T2.tif, T5.tif, T10.tif, ...
-        # - Return periods are named as *_T2_h.tif, *_T5_h.tif, *_T10_h.tif, ...
-
-        if "_h.tif" in sims[0].name:
-
-            # Searching for the position of the return period in the name
-            idx_T = [cursim.name.find("_T") for cursim in sims]
-            idx_h = [cursim.name.find("_h.tif") for cursim in sims]
-
-            assert len(idx_T) == len(idx_h), "The number of T and h are not the same"
-            for curT, curh in zip(idx_T, idx_h):
-                assert curT != -1, "The T is not found"
-                assert curh != -1, "The h is not found"
-                assert curh > curT, "The h is before the T"
-
-            # Create the list of return periods -- only the numeric part
-            sims = [int(cursim.name[idx_T[i]+2:idx_h[i]]) for i, cursim in enumerate(sims)]
-        else:
-            # searching for the position of the return period in the name
-            idx_T = [cursim.name.find("T") for cursim in sims]
-            idx_h = [cursim.name.find(".tif") for cursim in sims]
-
-            assert len(idx_T) == len(idx_h), "The number of T and h are not the same"
-            for curT, curh in zip(idx_T, idx_h):
-                assert curT != -1, "The T is not found"
-                assert curh != -1, "The h is not found"
-                assert curh > curT, "The h is before the T"
-
-            # create the list of return periods -- only the numeric part
-            sims = [int(cursim.name[idx_T[i]+1:idx_h[i]]) for i, cursim in enumerate(sims)]
-
+        # - Return periods are named as T2.tif, T5.tif, T10.tif, ... or with Q instead of T
+        # searching for the position of the return period in the name
+        idx_T = [Path(cursim).name.find("T") for cursim in sims_modif]
+        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:idx_h[i]]) 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_ponderations(self) -> pd.DataFrame:
         """ Get the ponderation data from available simulations """
@@ -605,11 +594,11 @@ class Accept_Manager():
         rt = self.get_return_periods()
 
         if len(rt)==0:
-            logging.info("No simulations found")
+            logging.info("No simulations found at this stage.")
             return None
 
         if len(rt)<2:
-            logging.info("There is only one simulation!")
+            logging.info("There is only one simulation! Weigthing coefficient is unique and set to 1.")
             return pd.DataFrame(1, columns=["Ponderation"], index=rt)
 
         else :
@@ -979,7 +968,7 @@ class Accept_Manager():
 
     def select_name_tif(self, path_baseline: Path, folder_path: Path, name) -> list[Path]:
         """
-        Collects and appends all .tiff files starting with 'vuln' from folder_path into a list.
+        Collects and appends all .tiff files starting with 'name' from folder_path into a list.
         """
         files = []
         #first element must be vulnerability_baseline
@@ -991,23 +980,21 @@ class Accept_Manager():
             files.append(tree[-1].as_posix())
         return files
 
-    def check_nodata(self, name):
+    def check_nodata(self, name, path_baseline):
             """ Check nodata in a path """
-
-            list_tif = Accept_Manager.select_name_tif(self, self.OUT_VULN, self.IN_CH_SA_SC, name)
+            list_tif = Accept_Manager.select_name_tif(self, path_baseline, self.IN_CH_SA_SC, name)
             for cur_lst in list_tif:
-                if "Vulnerability.tiff" not in cur_lst:
-                    curarray:WolfArray = WolfArray(cur_lst)
-                    if curarray.nullvalue != 99999.:
-                        curarray.nullvalue = 99999.
-                        curarray.set_nullvalue_in_mask()
-                        curarray.write_all()
-                        logging.warning(_('nodata changed in favor of 99999. value for file {} !'.format(cur_lst)))
+                curarray:WolfArray = WolfArray(cur_lst)
+                if curarray.nullvalue != 99999.:
+                    curarray.nullvalue = 99999.
+                    curarray.set_nullvalue_in_mask()
+                    curarray.write_all()
+                    logging.warning(_('nodata changed in favor of 99999. value for file {} !'.format(cur_lst)))
 
     def create_vrtIfExists(self, fn_baseline, fn_scenario, fn_vrt, name):
         """ Create a vrt file from a path """
         logging.info(_('Checking nodata values...'))
-        self.check_nodata(name)
+        self.check_nodata(name, fn_baseline)
         list_tif = Accept_Manager.select_name_tif(self, fn_baseline, fn_scenario, name)
         #création du fichier vrt - assembly/agglomération
         if len(list_tif)>1:
@@ -1536,7 +1523,8 @@ def match_vulnerability2sim(inRas:Path, outRas:Path, MODREC:Path):
 def update_accept(accept, model_h, ij, bounds, loc_accept):
     for idx in range(len(bounds)):
         for i,j in ij:
-            if bounds[idx,0] < model_h[i,j] <= bounds[idx,1]: #lit dans wd vs Ti où on est et associe son score d'accept
+            #lit dans wd vs Ti où on est et associe son score d'accept
+            if bounds[idx,0] < model_h[i,j] <= bounds[idx,1]: 
                 accept[i,j] = loc_accept[idx]
 
 def compute_acceptability(manager:Accept_Manager,

wolfhece/apps/version.py

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

wolfhece/lazviewer/laz_viewer.py

@@ -553,7 +553,7 @@ class xyz_laz_grids():
             return np.asarray([])
         else:
             ret = np.concatenate(ret)
-            logging.info(_('Data found -- {} points'.format(ret.shape[0])))
+            logging.info(_('Data found -- {:_} points'.format(ret.shape[0])))
             return ret
 
     def find_files_in_bounds(self, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
@@ -565,7 +565,7 @@ class xyz_laz_grids():
             logging.info(_('No data found'))
             return []
         else:
-            logging.info(_('Data found -- {} files'.format(len(ret))))
+            logging.info(_('Data found -- {:_} files'.format(len(ret))))
             return ret
 
     def copy_files_in_bounds(self, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]], dirout:str):
@@ -578,7 +578,7 @@ class xyz_laz_grids():
         files = self.find_files_in_bounds(bounds)
 
         for curdir, curfiles in files:
-            locdir = dirout / Path(curdir).parent.name
+            locdir = out / Path(curdir).name
             locdir.mkdir(exist_ok=True)
             for curfile in curfiles:
                 shutil.copy(curfile, locdir / Path(curfile).name)
@@ -762,6 +762,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
         self._data:np.ndarray = None    # Numpy data array -- to be plotted
         self._colors:np.ndarray = None  # NumPy array of colors for each point --> see viewer attributes for details
         self.classification = Classification_LAZ() # Classification of LAZ data --> defining colors if codification is used
+        self.classification.init_2023() # Default classification for LAZ data
 
         self._associated_color:int = Colors_Lazviewer.CODE_2023.value # Associated color type for LAZ data
 
@@ -1204,7 +1205,8 @@ class Wolf_LAZ_Data(Element_To_Draw):
 
     def from_file(self, fn:str):
         """ Create data from LAZ file """
-        self.data = read_laz(fn)
+        laz = read_laz(fn)
+        self.data = np.column_stack((laz.x, laz.y, laz.z, laz.classification)).astype(np.float32)
         self.bounds = [[np.min(self.data[:,0]), np.max(self.data[:,0])],[np.min(self.data[:,1]), np.max(self.data[:,1])]]
 
     def descimate(self, step:int):

wolfhece/pybridges.py

@@ -340,7 +340,12 @@ class Bridge(Zones):
 
         if self.leftbank is not None and self.riverbed is not None and self.rightbank is not None:
 
-            self.polygons_zone = zone(name= "polygons_river")
+            keys_zones = [curzone.myname for curzone in self.myzones]
+            if "_river_auto" in keys_zones:
+                logging.warning(_('Polygons already created'))
+                return
+
+            self.polygons_zone = zone(name= "_river_auto")
             self.add_zone(self.polygons_zone, forceparent=True)
             self.polygons_zone.myvectors = [self.leftbank, self.riverbed, self.rightbank] #inverse order to be up -> down