wolfhece 2.1.107__py3-none-any.whl → 2.1.109__py3-none-any.whl

wolfhece/acceptability/func.py

@@ -186,7 +186,6 @@ class Accept_Manager():
 
         self.IN_DIR         = self.main_dir / "INPUT"
         self.IN_CH_VULN     = self.IN_DIR / "CHANGE_VULNE"
-        self.IN_CH_SA_SC    = self.IN_CH_VULN / str(Study_area).rsplit('.', 1)[0] / str(scenario)
         self.IN_DATABASE    = self.IN_DIR / "DATABASE"
         self.IN_STUDY_AREA  = self.IN_DIR / "STUDY_AREA"
         self.IN_CSV         = self.IN_DIR / "CSVs"
@@ -290,11 +289,17 @@ class Accept_Manager():
 
             self.scenario:str       = str(self._scenario)
 
+            
+            self.IN_SA_BASE         = self.IN_WATER_DEPTH / self.SA.stem / "Scenario_baseline"
+            self.IN_SA_BASE_INTERP  = self.IN_SA_BASE / "INTERP_WD"
+            
             self.IN_SCEN_DIR        = self.IN_WATER_DEPTH / self.SA.stem / self.scenario
-            self.IN_SA_Base         = self.IN_WATER_DEPTH / self.SA.stem / "Scenario_baseline"
             self.IN_SA_INTERP       = self.IN_SCEN_DIR / "INTERP_WD"
             self.IN_SA_EXTRACTED    = self.IN_SCEN_DIR / "EXTRACTED_LAST_STEP_WD"
-            self.IN_SA_DEM          = self.IN_SCEN_DIR / "DEM_FILES"
+            self.IN_SA_DEM          = self.IN_SCEN_DIR / "DEM_FILES"            
+            self.IN_CH_SA_SC        = self.IN_CH_VULN /self.SA.stem  / self.scenario
+            self.IN_CH_SA_SC_MNT_VRT = self.IN_CH_SA_SC / "__MNT_assembly.vrt"
+            self.IN_CH_SA_SC_MNT_tif = self.IN_CH_SA_SC / "MNTassembly"
 
             self.IN_RM_BUILD_DIR    = self.IN_SCEN_DIR / "REMOVED_BUILDINGS"
 
@@ -302,21 +307,26 @@ class Accept_Manager():
             self.TMP_RM_BUILD_DIR   = self.TMP_SCEN_DIR / "REMOVED_BUILDINGS"
             self.TMP_QFILES         = self.TMP_SCEN_DIR / "Q_FILES"
 
-            self.TMP_VULN           = self.TMP_SCEN_DIR / "Vulnerability.tiff"
-            self.TMP_CODE           = self.TMP_SCEN_DIR / "Vulnerability_Code.tiff"
+            self.TMP_VULN           = self.TMP_SCEN_DIR / "Vulnerability_baseline.tiff"
+            self.TMP_CODE           = self.TMP_SCEN_DIR / "Vulnerability_Code_baseline.tiff"
 
             self.OUT_SCEN_DIR       = self.OUT_STUDY_AREA / self.scenario
 
-            self.OUT_VULN           = self.OUT_SCEN_DIR / "Vulnerability.tiff"
-            self.OUT_VULN_VRT       = self.OUT_SCEN_DIR / "__vuln_assembly.vrt"
-            self.OUT_VULN_S         = self.OUT_SCEN_DIR / "Vulnerability_scenarios" #no .tif because wolf_vrt add it itself (see create_vrtIfExists below)
-            self.OUT_VULN_Stif      = self.OUT_SCEN_DIR / "Vulnerability_scenarios.tif"
-            self.OUT_CODE           = self.OUT_SCEN_DIR / "Vulnerability_Code.tiff"
-            self.OUT_MASKED_RIVER   = self.OUT_SCEN_DIR / "Masked_River_extent.tiff"
-            self.OUT_ACCEPT         = self.OUT_SCEN_DIR / "Acceptability.tiff"
-            self.OUT_ACCEPT_100M    = self.OUT_SCEN_DIR / "Acceptability_100m.tiff"
-            self.OUT_ACCEPT_Stif         = self.OUT_SCEN_DIR / "Acceptability_scenarios.tiff"
-            self.OUT_ACCEPT_100M_Stif    = self.OUT_SCEN_DIR / "Acceptability_scenarios_100m.tiff"
+            self.OUT_WITHVULN       = self.OUT_SCEN_DIR / "vuln_ scenarios"
+            self.OUT_VULN_VRT       = self.OUT_WITHVULN / "__vuln_assembly.vrt"
+            self.OUT_VULN_S         = self.OUT_WITHVULN / "Vulnerability_scenarios" 
+            self.OUT_VULN_Stif      = self.OUT_WITHVULN / "Vulnerability_scenarios.tif"
+            self.OUT_MASKED_RIVER_S = self.OUT_WITHVULN / "Masked_River_extent_scenarios.tiff"
+            self.OUT_ACCEPT_Stif           = self.OUT_WITHVULN / "Acceptability_scenarios.tiff"
+            self.OUT_ACCEPT_RESAMP_Stif    = self.OUT_WITHVULN / "Acceptability_scenarios_resampled.tiff"
+            
+            self.OUT_BASELINE       = self.OUT_SCEN_DIR / "baseline"
+            self.OUT_VULN           = self.OUT_BASELINE / "Vulnerability_baseline.tiff"
+            self.OUT_CODE           = self.OUT_BASELINE / "Vulnerability_Code_baseline.tiff"
+            self.OUT_MASKED_RIVER   = self.OUT_BASELINE / "Masked_River_extent_baseline.tiff"
+            self.OUT_ACCEPT         = self.OUT_BASELINE / "Acceptability_baseline.tiff"
+            self.OUT_ACCEPT_RESAMP  = self.OUT_BASELINE / "Acceptability_baseline_resampled.tiff"
+            
         else:
             self.scenario = None
 
@@ -330,12 +340,20 @@ class Accept_Manager():
             self.TMP_VULN          = None
             self.TMP_CODE          = None
 
-            self.OUT_SCEN_DIR      = None
-            self.OUT_VULN          = None
-            self.OUT_CODE          = None
-            self.OUT_MASKED_RIVER  = None
-            self.OUT_ACCEPT        = None
-            self.OUT_ACCEPT_100M   = None
+            self.OUT_SCEN_DIR       = None
+            self.OUT_WITHVULN       = None
+            self.OUT_VULN_VRT       = None
+            self.OUT_VULN_S         = None
+            self.OUT_VULN_Stif      = None
+            self.OUT_MASKED_RIVER_S = None
+            self.OUT_ACCEPT_Stif      = None
+            self.OUT_ACCEPT_RESAMP_Stif  = None
+            self.OUT_BASELINE       = None
+            self.OUT_VULN           = None
+            self.OUT_CODE           = None
+            self.OUT_MASKED_RIVER   = None
+            self.OUT_ACCEPT         = None
+            self.OUT_ACCEPT_RESAMP  = None
 
     @property
     def is_valid_inputs(self) -> bool:
@@ -437,17 +455,17 @@ class Accept_Manager():
         if self.IN_SA_INTERP.exists() :
             files = [Path(a) for a in glob.glob(str(self.IN_SA_INTERP / "*.tif"))]
         else :
-            logging.error("No _baseline")
+            logging.error("No such scenario")
         return files
 
     def get_sims_files_for_baseline(self) -> list[Path]:
         files = [] #to avoid NoneType
-        if self.IN_SA_INTERP.exists() :
-            logging.info("Getting the _baseline WATER_DEPTHS files.")
-            track = Path(str(self.IN_SA_INTERP / "*.tif"))
+        if self.IN_SA_BASE_INTERP.exists() :
+            logging.info("Getting the _baseline interpolated free surfaces files.")
+            track = Path(str(self.IN_SA_BASE_INTERP / "*.tif"))
             files = [Path(a) for a in glob.glob(str(track))]
         else :
-            logging.error("No _baseline WATER_DEPTHS files")
+            logging.error("No _baseline interpolated free surfaces files")
 
         return files
 
@@ -591,8 +609,8 @@ class Accept_Manager():
             return None
 
         if len(rt)<2:
-            logging.info("Need for more simulations")
-            return None
+            logging.info("There is only one simulation!")
+            return pd.DataFrame(1, columns=["Ponderation"], index=rt)
 
         else :
             pond = []
@@ -723,6 +741,9 @@ class Accept_Manager():
 
         if self.scenario is not None:
             self.OUT_SCEN_DIR.mkdir(parents=True, exist_ok=True)
+            self.OUT_WITHVULN.mkdir(parents=True, exist_ok=True)
+            self.OUT_BASELINE.mkdir(parents=True, exist_ok=True)
+            
 
         return True
 
@@ -938,11 +959,11 @@ class Accept_Manager():
     the search of a more specific word ('vuln', and not 'bath', 'mann', or 'inf').
     """
 
-    def tree_vuln_tif(folder_path):
+    def tree_name_tif(folder_path, name):
         """Find all .tiff files starting with 'vuln' in the directory and return paths"""
         folder = Path(folder_path)
-        vuln_tiff_files = {file for file in folder.rglob("*.tiff") if file.name.startswith("vuln")}
-        vuln_tif_files = {file for file in folder.rglob("*.tif") if file.name.startswith("vuln")}
+        vuln_tiff_files = {file for file in folder.rglob("*.tiff") if file.name.startswith(name)}
+        vuln_tif_files = {file for file in folder.rglob("*.tif") if file.name.startswith(name)}
 
         vuln_files = vuln_tiff_files.union(vuln_tif_files)
 
@@ -956,24 +977,24 @@ class Accept_Manager():
                     tiff_trees.append(curtree)
         return tiff_trees
 
-    def select_vuln_tif(self, path_baseline: Path, folder_path: Path) -> list[Path]:
+    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.
         """
         files = []
         #first element must be vulnerability_baseline
         files.append(path_baseline.as_posix())
-        tiff_trees = Accept_Manager.tree_vuln_tif(folder_path)
+        tiff_trees = Accept_Manager.tree_name_tif(folder_path, name)
 
         #only the 'final' path of the tree
         for tree in tiff_trees:
             files.append(tree[-1].as_posix())
         return files
 
-    def check_nodata(self):
+    def check_nodata(self, name):
             """ Check nodata in a path """
 
-            list_tif = Accept_Manager.select_vuln_tif(self, self.OUT_VULN, self.IN_CH_SA_SC)
+            list_tif = Accept_Manager.select_name_tif(self, self.OUT_VULN, self.IN_CH_SA_SC, name)
             for cur_lst in list_tif:
                 if "Vulnerability.tiff" not in cur_lst:
                     curarray:WolfArray = WolfArray(cur_lst)
@@ -983,24 +1004,25 @@ class Accept_Manager():
                         curarray.write_all()
                         logging.warning(_('nodata changed in favor of 99999. value for file {} !'.format(cur_lst)))
 
-    def create_vrtIfExists(self):
+    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()
-        list_tif = Accept_Manager.select_vuln_tif(self, self.OUT_VULN, self.IN_CH_SA_SC)
+        self.check_nodata(name)
+        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:
             logging.info(_('Creating .vrt from files (first based)...'))
-            create_vrt_from_diverged_files_first_based(list_tif, self.OUT_VULN_VRT)
+            create_vrt_from_diverged_files_first_based(list_tif, fn_vrt)
             return True
         else:
             return False
 
 
-    def translate_vrt2tif(self):
-        """ Translate vrt from OUTPUT > ... > Scenario to tif saved in the same folder """
-        if (self.OUT_VULN_VRT).exists():
-            translate_vrt2tif(self.OUT_VULN_VRT, self.OUT_VULN_S)
+    def translate_vrt2tif(self, fn_VRT, fn_vuln_s):
+        """ Translate vrt from OUTPUT > ... > Scenario to tif saved in the same folder, and delete the vrt file """
+        if (fn_VRT).exists():
+            translate_vrt2tif(fn_VRT, fn_vuln_s)
+            os.remove(fn_VRT)
 
     def copy_tif_files(self, files: list[Path], destination_dir: Path) -> None:
         destination_dir.mkdir(parents=True, exist_ok=True)
@@ -1016,7 +1038,20 @@ class Accept_Manager():
 
             dataset = None
 
-        logging.info("All .tif files have been copied to the destination directory.")
+        logging.info("All the existing .tif files have been copied to the destination directory.")
+    
+    def wich_river_trace(self):
+        """ 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
+        if os.path.exists(self.OUT_MASKED_RIVER_S):
+            trace = self.OUT_MASKED_RIVER_S
+        else :
+            logging.error("No Masked_River_extent files. Please provide them.")
+        return trace
+        
+        
 
 
 def clip_layer(layer:str,
@@ -1287,7 +1322,7 @@ def compute_vulnerability(manager:Accept_Manager):
         return array_vuln
 
     for i in tqdm(range(len(rasters_vuln)), 'Computing Vulnerability : '):
-        logging.info("Computing layer {} / {}".format(i, len(rasters_vuln)))
+        #logging.info("Computing layer {} / {}".format(i, len(rasters_vuln)))
 
         locvuln = vuln_csv.get_vulnerability_level(rasters_vuln[i].stem)
 
@@ -1378,7 +1413,7 @@ def compute_code(manager:Accept_Manager):
         return array_code
 
     for i in tqdm(range(len(rasters_code)), 'Computing Code : '):
-        logging.info("Computing layer {} / {}".format(i, len(rasters_code)))
+        #logging.info("Computing layer {} / {}".format(i, len(rasters_code)))
 
         loccode = vuln_csv.get_vulnerability_code(rasters_code[i].stem.removesuffix("_CODE"))
 
@@ -1481,7 +1516,7 @@ def match_vulnerability2sim(inRas:Path, outRas:Path, MODREC:Path):
     :param MODREC: the MODREC/simulation extent file
 
     """
-
+    
     inRas  = str(inRas)
     outRas = str(outRas)
     MODREC = str(MODREC)
@@ -1525,7 +1560,7 @@ def compute_acceptability(manager:Accept_Manager,
 
     """
 
-    logging.info(interval)
+    #logging.info(interval)
 
     points_accept = pd.read_csv(manager.POINTS_CSV)
 

wolfhece/apps/version.py

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

wolfhece/lazviewer/laz_viewer.py

@@ -23,6 +23,7 @@ from ..PyWMS import getWalonmap
 from ..PyTranslate import _
 from ..color_constants import Colors
 from ..PyParams import Wolf_Param
+from ..matplotlib_fig import Matplotlib_Figure as mplfig
 
 """
 Importation et visualisation de données LAS et LAZ
@@ -620,6 +621,27 @@ class xyz_laz_grids():
 
         return fig,ax
 
+    def plot_laz_wx(self, xy:Union[LineString, list[list[float], list[float]]], length_buffer=5., show=True):
+        """
+        Dessin des points LAZ sur un graphique Matplotlib
+        """
+
+        (up_s, up_z, up_color), (down_s, down_z, down_color) = self.scan_around(xy, length_buffer)
+
+        figmpl = mplfig()
+        figmpl.presets()
+        fig = figmpl.fig
+        ax = figmpl.cur_ax
+
+        logging.info(_('Plotting'))
+        ax.scatter(up_s,   up_z,  c=up_color  ,marker='.')
+        ax.scatter(down_s, down_z,c=down_color,marker='+')
+
+        if show:
+            figmpl.Show()
+
+        return figmpl
+
     def create_from_laz(self, dir_laz:str, shape:str, ds:float = 50, force_format = np.float64):
 
         try:

wolfhece/matplotlib_fig.py

@@ -1053,6 +1053,7 @@ class Matplotlib_Figure(wx.Frame):
         self.ax_dict:dict[str,Axes] = {}    # dict of axes
         self.ax:list[Axes] = []             # list of axes -- always flatten
         self.shown_props = None     # shown properties
+        self._shiftdown = False
 
         self.apply_layout(layout)   # apply the layout
         pass
@@ -1192,6 +1193,7 @@ class Matplotlib_Figure(wx.Frame):
         self._canvas.mpl_connect('motion_notify_event', self.UpdateStatusBar)
         self._canvas.mpl_connect('button_press_event', self.OnClickCanvas)
         self._canvas.mpl_connect('key_press_event', self.OnKeyCanvas)
+        self._canvas.mpl_connect('key_release_event', self.OnKeyRelease)
 
         # Toolbar - Matplotlib
         # --------------------
@@ -1280,6 +1282,9 @@ class Matplotlib_Figure(wx.Frame):
         self._add_row = wx.Button(win, -1, 'Add rows')
         self._add_row.Bind(wx.EVT_BUTTON, self.add_row_to_grid)
 
+        self._new_line = wx.Button(win, -1, 'New line')
+        self._new_line.Bind(wx.EVT_BUTTON, self.onnew_line)
+
         self._add_line = wx.Button(win, -1, 'Add line')
         self._add_line.Bind(wx.EVT_BUTTON, self.onadd_line)
 
@@ -1287,10 +1292,19 @@ class Matplotlib_Figure(wx.Frame):
         self._del_line.Bind(wx.EVT_BUTTON, self.ondel_line)
 
         self._sizer_xls.Add(self._xls, 1, wx.EXPAND)
-        self._sizer_xls.Add(self._update_xy, 0, wx.EXPAND)
-        self._sizer_xls.Add(self._add_row, 0, wx.EXPAND)
-        self._sizer_xls.Add(self._add_line, 0, wx.EXPAND)
-        self._sizer_xls.Add(self._del_line, 0, wx.EXPAND)
+
+        self._sizer_update_add = wx.BoxSizer(wx.HORIZONTAL)
+        self._sizer_add_remove = wx.BoxSizer(wx.HORIZONTAL)
+
+        self._sizer_xls.Add(self._sizer_update_add, 0, wx.EXPAND)
+        self._sizer_xls.Add(self._sizer_add_remove, 0, wx.EXPAND)
+
+        self._sizer_update_add.Add(self._update_xy, 1, wx.EXPAND)
+        self._sizer_update_add.Add(self._add_row, 1, wx.EXPAND)
+
+        self._sizer_add_remove.Add(self._new_line, 1, wx.EXPAND)
+        self._sizer_add_remove.Add(self._add_line, 1, wx.EXPAND)
+        self._sizer_add_remove.Add(self._del_line, 1, wx.EXPAND)
 
         # Properties sizer
         # ---------------
@@ -1519,6 +1533,12 @@ class Matplotlib_Figure(wx.Frame):
 
         if event.key == 'escape':
             self._axes_properties[int(self._ax_current.GetSelection())].reset_selection()
+        elif event.key == 'shift':
+            self._shiftdown = True
+
+    def OnKeyRelease(self, event:KeyEvent):
+        if event.key == 'shift':
+            self._shiftdown = False
 
     def OnClickCanvas(self, event:MouseEvent):
 
@@ -1533,21 +1553,33 @@ class Matplotlib_Figure(wx.Frame):
             idx= ax.get_figure().axes.index(event.inaxes)
             x, y = event.xdata, event.ydata
 
-            dist_min = 1e6
-            line_min = None
+            if rclick and not self._shiftdown:
 
-            for line in ax.get_lines():
-                xy = line.get_xydata()
-                dist = np.linalg.norm(xy - np.array([x,y]), axis=1)
-                idx_min = np.argmin(dist)
-                if dist[idx_min] < dist_min:
-                    dist_min = dist[idx_min]
-                    line_min = line
+                dist_min = 1e6
+                line_min = None
 
-            self._ax_current.SetSelection(idx)
-            self._fill_lines_ax(idx = ax.get_lines().index(line_min))
-            self._axes_properties[idx].select_line(ax.get_lines().index(line_min))
-            self.fill_grid_with_xy(line_min)
+                for line in ax.get_lines():
+                    xy = line.get_xydata()
+                    if xy.shape[0] == 0:
+                        continue
+
+                    dist = np.linalg.norm(xy - np.array([x,y]), axis=1)
+                    idx_min = np.argmin(dist)
+                    if dist[idx_min] < dist_min:
+                        dist_min = dist[idx_min]
+                        line_min = line
+
+                self._ax_current.SetSelection(idx)
+                self._fill_lines_ax(idx = ax.get_lines().index(line_min))
+                self._axes_properties[idx].select_line(ax.get_lines().index(line_min))
+                self.fill_grid_with_xy(line_min)
+
+            if rclick and self._shiftdown:
+                xy = self.cur_line.get_xydata()
+                xy = np.vstack((xy, [x,y]))
+                self.cur_line.set_data(xy[:,0], xy[:,1])
+                self.fill_grid_with_xy(self.cur_line)
+                self._canvas.draw()
 
             self.show_curline_properties()
 
@@ -1609,6 +1641,17 @@ class Matplotlib_Figure(wx.Frame):
         xy = self._get_xy_from_grid(self._xls)
         self.add_line(xy, self.cur_ax)
 
+    def onnew_line(self, event):
+        """ Add a plot to the current ax """
+
+        curline = self.cur_line
+        if curline is not None:
+            xy = curline.get_xydata()
+            xy = np.asarray([[xy[0,0],xy[0,1]]])
+        else:
+            xy = np.asarray([[0,0]])
+        self.add_line(xy, self.cur_ax)
+
     def _get_xy_from_grid(self, grid:CpGrid, colx:int= 0, coly:int= 1):
         """ Get the xy from a grid """
 
@@ -1637,23 +1680,29 @@ class Matplotlib_Figure(wx.Frame):
         cur_ax_prop:Matplotlib_ax_properties = self._axes_properties[idx_ax]
         cur_ax_prop._lines.append(Matplolib_line_properties(ax.get_lines()[-1], cur_ax_prop))
         cur_ax_prop._lines[-1].add_props_to_sizer(self._collaps_pane.GetPane(), self._sizer_grid_props)
+
+        self._fill_lines_ax(len(ax.get_lines())-1)
+
         self.update_layout()
+        self._canvas.SetFocus()
 
     def ondel_line(self, event):
         """ Remove a plot from the current ax """
 
+        if self._line_current.GetSelection() == -1:
+            return
+
         dlg = wx.MessageDialog(self, _('Do you want to remove the selected line?\n\nSuch action is irrevocable !\n\nPlease consider to set "Visible" to "False" to hide data'), _('Remove line'), wx.YES_NO | wx.ICON_QUESTION | wx.NO_DEFAULT)
 
         ret = dlg.ShowModal()
         if ret == wx.ID_NO:
             return
 
-        if self._line_current.GetSelection() == -1:
-            return
-
         idx = self._line_current.GetSelection()
         self.del_line(idx)
 
+        self._fill_lines_ax()
+
     def del_line(self, idx:int):
         """ Delete a line """
 

wolfhece/picc.py

@@ -64,10 +64,10 @@ class Picc_data(Element_To_Draw):
         if datafile.exists():
             self.zones = Zones(data_dir / self._filename_vector, bbox = bbox, mapviewer=self.mapviewer, colors= self._colors)
         else:
-            logging.error(_('File not found : {}').format(datafile))
+            logging.info(_('File not found : {}').format(datafile))
 
             if self.mapviewer is not None:
-                dlg = wx.SingleChoiceDialog(None, _('Would you like to select a PICC file or a GDB database ?'), _('Choose data source'), ['Shape file/GPKG', 'GDB database'], wx.CHOICEDLG_STYLE)
+                dlg = wx.SingleChoiceDialog(None, _('Would you like to select a Shape file or a GDB database ?'), _('Choose data source'), ['Shape file/GPKG', 'GDB database'], wx.CHOICEDLG_STYLE)
                 ret = dlg.ShowModal()
 
                 if ret == wx.ID_CANCEL: