wolfhece 2.1.125__py3-none-any.whl → 2.1.127__py3-none-any.whl

wolfhece/lazviewer/laz_viewer.py

@@ -17,6 +17,7 @@ from matplotlib.figure import Figure
 from shapely.geometry import LineString, Point, CAP_STYLE, Polygon
 from shapely.ops import prep
 import wx
+from tqdm import tqdm
 
 from . import viewer
 from ..PyWMS import getWalonmap
@@ -41,6 +42,7 @@ class Colors_Lazviewer(Enum):
     ORTHO_2006_2007 = 2006
     CODE_2013 = 0
     CODE_2023 = 2
+    CODE_2021_2022 = 3
     FROM_FILE = 1
 
 class Classification_LAZ():
@@ -68,6 +70,18 @@ class Classification_LAZ():
             9  : ['Eau', 'Eau',Colors.rgb_withalpha_float('aqua',1.)],
             10 : ['Ponts', 'Ponts',Colors.rgb_withalpha_float('lightyellow1',1.)]}
 
+    def init_2021_2022(self):
+
+        self.class_name = 'SPW 2021-2022'
+        self.classification={
+            0  : ['0', 'Pas de classification', Colors.rgb_withalpha_float('black',.2),],
+            1  : ['Hors-sol', 'building, toits et autres', Colors.rgb_withalpha_float('white',.2),],
+            2  : ['Sol', 'y compris talus et digues', Colors.rgb_withalpha_float('brown',1.)],
+            4  : ['Végétation', 'y compris la végétation linéaire', Colors.rgb_withalpha_float('forestgreen',1.)],
+            9  : ['Eau', 'Eau',Colors.rgb_withalpha_float('aqua',1.)],
+            10 : ['Ponts', 'Ponts',Colors.rgb_withalpha_float('lightyellow1',1.)],
+            15 : ['Ligne hautes-tension', 'Ligne hautes-tension',Colors.rgb_withalpha_float('lightcyan1',0.25)]}
+
     def init_2023(self):
 
         self.class_name = 'SPW-Geofit 2023'
@@ -155,8 +169,8 @@ class xyz_laz():
             parts = last_part.split('_')
 
             # L'origine est codée dans le nom de fichier
-            self.origx = float(parts[2])
-            self.origy = float(parts[3])
+            self.origx = float(parts[-3])
+            self.origy = float(parts[-2])
 
             dx = 2500.
             dy = 3500.
@@ -557,6 +571,9 @@ class xyz_laz_grids():
             return ret
 
     def find_files_in_bounds(self, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
+        """ Find all files in bounds
+
+        :param bounds: [[xmin,xmax], [ymin,ymax]]"""
 
         ret = [(cur.mydir, cur.find_files_in_bounds(bounds)) for cur in self.grids]
         ret = [cur for cur in ret if len(cur[1])>0]
@@ -569,6 +586,11 @@ class xyz_laz_grids():
             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):
+        """ Copy files in bounds to directory
+
+        :param bounds: [[xmin,xmax], [ymin,ymax]]
+        :param dirout: output directory
+        """
 
         import shutil
 
@@ -587,10 +609,28 @@ class xyz_laz_grids():
             shutil.copy(join(curdir,'gridinfo.txt'), locdir / 'gridinfo.txt')
 
     def read_dir(self, dir_grids):
+        """ Read all grids in directory and subdirectories """
+
+        import asyncio
+
         dirs = listdir(dir_grids)
 
-        for curdir in dirs:
-            self.grids.append(xyz_laz_grid(join(dir_grids,curdir)))
+        logging.info(_('Reading grids information -- {} grids'.format(len(dirs))))
+
+        def init_grid(curdir):
+            if (Path(dir_grids) / Path(curdir)).is_dir():
+                return xyz_laz_grid(join(dir_grids, curdir))
+
+            return None
+
+        async def init_grid_async(curdir):
+            return init_grid(curdir)
+
+        loop = asyncio.get_event_loop()
+        tasks = [init_grid_async(curdir) for curdir in dirs]
+        self.grids = list(filter(None, loop.run_until_complete(asyncio.gather(*tasks))))
+
+        logging.info(_('Grids initialized'))
 
     def scan_around(self, xy:Union[LineString,list[list[float], list[float]]], length_buffer=5.):
         """
@@ -707,42 +747,82 @@ class xyz_laz_grids():
 
         return figmpl
 
-    def create_from_laz(self, dir_laz:str, shape:str, ds:float = 50, force_format = np.float64):
+    def create_from_laz(self, dir_laz:str, shape:str=None, ds:float = 50, force_format = np.float64):
 
         try:
             from ..PyVertexvectors import Zones
         except:
             from wolfhece.PyVertexvectors import Zones
-        vecs = Zones(shape)
 
-        for entry in scandir(dir_laz):
+        vecs = None
+        if shape is not None:
+            vecs = Zones(shape)
+
+        dir_laz = Path(dir_laz)
+
+        for entry in tqdm(dir_laz.glob('**/*.laz')):
             if entry.is_file():
-                if entry.name.endswith('.laz'):
 
-                    file_wo_suf = entry.name.removesuffix('.laz')
-                    dirname = join(self.dir, file_wo_suf)
+                file_wo_suf = entry.stem
+                dirname = join(self.dir, file_wo_suf)
 
-                    if not exists(dirname):
-                        makedirs(dirname, exist_ok=True)
+                if not exists(dirname):
+                    makedirs(dirname, exist_ok=True)
 
-                        newlaz = xyz_laz_grid(mydir=dirname)
+                    newlaz = xyz_laz_grid(mydir=dirname)
 
+                    if vecs is not None:
                         vec = vecs.get_zone(file_wo_suf)
                         bounds = vec.myvectors[0].get_bounds()
+                    else:
+                        lazdata = laspy.read(entry)
+                        bounds = [[lazdata.x.min(), lazdata.y.min()],
+                                    [lazdata.x.max(), lazdata.y.max()]]
+
+                    bounds = [[math.floor(bounds[0][0]/ds)*ds, math.floor(bounds[0][1]/ds)*ds],
+                                        [math.ceil(bounds[1][0]/ds)*ds, math.ceil(bounds[1][1]/ds)*ds]]
+
+                    dx = bounds[1][0] -bounds[0][0]
+                    dy = bounds[1][1] -bounds[0][1]
+                    nb = max(int(dx/ds), int(dy/ds))
+
+                    self.grids.append(newlaz._sort_grid_np(entry,
+                                                        join(dirname, file_wo_suf),
+                                                        bounds=[[bounds[0][0], bounds[1][0]], [bounds[0][1], bounds[1][1]]],
+                                                        gridsize=[max(int(dx/ds),1), max(int(dy/ds),1)],
+                                                        force_format=force_format))
+
+    def create_bounds_shape(self, dir_laz:str, out_shape:str):
+        """ Create shape from laz files """
+        try:
+            from ..PyVertexvectors import Zones
+        except:
+            from wolfhece.PyVertexvectors import Zones
+
+        dir_laz = Path(dir_laz)
+        out_shape = Path(out_shape)
+
+        vecs = Zones()
 
-                        bounds = [[math.floor(bounds[0][0]/ds)*ds, math.floor(bounds[0][1]/ds)*ds],
-                                            [math.ceil(bounds[1][0]/ds)*ds, math.ceil(bounds[1][1]/ds)*ds]]
+        for entry in tqdm(dir_laz.glob('**/*.laz')):
+            if entry.is_file():
+                lazdata = laspy.read(entry)
+
+                bounds = [[lazdata.x.min(), lazdata.y.min()],
+                            [lazdata.x.max(), lazdata.y.max()]]
+                loczone = zone(name=entry.stem)
+                locvec = vector(name=entry.stem)
 
-                        dx = bounds[1][0] -bounds[0][0]
-                        dy = bounds[1][1] -bounds[0][1]
-                        nb = max(int(dx/ds), int(dy/ds))
+                locvec.add_vertex(wolfvertex(bounds[0][0], bounds[0][1]))
+                locvec.add_vertex(wolfvertex(bounds[1][0], bounds[0][1]))
+                locvec.add_vertex(wolfvertex(bounds[1][0], bounds[1][1]))
+                locvec.add_vertex(wolfvertex(bounds[0][0], bounds[1][1]))
+                locvec.close_force()
 
-                        self.grids.append(newlaz._sort_grid_np(entry.path,
-                                                            join(dirname, file_wo_suf),
-                                                            bounds=[[bounds[0][0], bounds[1][0]], [bounds[0][1], bounds[1][1]]],
-                                                            gridsize=[max(int(dx/ds),1), max(int(dy/ds),1)],
-                                                            force_format=force_format))
+                loczone.add_vector(locvec, forceparent=True)
+                vecs.add_zone(loczone, forceparent=True)
 
+        vecs.saveas(Path(self.dir) / out_shape)
 
 class Wolf_LAZ_Data(Element_To_Draw):
     """ Base class for LAZ data which can be imported in Pydraw.Mapviewer.
@@ -1145,6 +1225,8 @@ class Wolf_LAZ_Data(Element_To_Draw):
             logging.warning(_('No classification chosen - Abort !'))
         elif classification == 'SPW 2013-2014':
             self.classification.init_2013()
+        elif classification == 'SPW 2021-2022':
+            self.classification.init_2021_2022()
         else:
             self.classification.init_2023()
 
@@ -1900,6 +1982,34 @@ def get_colors(las:laspy.LasData, which_colors:Colors_Lazviewer, imsize=2000, fn
             name, comment, color = value
             colors[myclass==int(key)] = color
 
+    elif which_colors==Colors_Lazviewer.CODE_2021_2022.value:
+        """
+        - Rebus/non classés - Code 0;
+        - Hors-sol (building, toits et autres) - Code 1;
+        - Sol (y compris talus et digues) - Code 2;
+        - Végétation haute (y compris la végétation linéaire) - Code 4;
+        - Eau - Code 9;
+        - Pont – Code 10;
+        - Ligne hautes-tension - Code 15.
+        """
+        if type(las) is laspy.LasData:
+            myclass = las.classification
+        elif type(las) is list:
+            myclass=[]
+            for curlas in las:
+                myclass.append(curlas.classification)
+            myclass = np.concatenate(myclass)
+        else:
+            myclass = np.int8(las[:,3])
+
+        if palette_classif is None:
+            palette_classif = Classification_LAZ()
+            palette_classif.init_2021_2022()
+
+        for key, value in palette_classif.classification.items():
+            name, comment, color = value
+            colors[myclass==int(key)] = color
+
     elif which_colors==Colors_Lazviewer.CODE_2023.value:
 
         if palette_classif is None:

wolfhece/math_parser/calculator.py

@@ -116,7 +116,7 @@ class Calculator(wx.Frame):
             from ..PyDraw import draw_type
             ids = self._mapviewer.get_list_keys(drawing_type=draw_type.ARRAYS, checked_state=None)
             for id in ids:
-                self.memory_txt += id
+                self.memory_txt = id
 
     def memory_clear_event(self, e):
         self.memory_clear()

wolfhece/scenario/config_manager.py

@@ -472,13 +472,13 @@ class Config_Manager_2D_GPU:
 
         logging.info(_('Number of tif files : {}'.format(len(list_tif))))
 
-        standard_files = ['bathymetry.tif', 
-                          'manning.tif', 
-                          'infiltration.tif', 
-                          'h.tif', 
-                          'qx.tif', 
-                          'qy.tif', 
-                          'roof.tif', 
+        standard_files = ['bathymetry.tif',
+                          'manning.tif',
+                          'infiltration.tif',
+                          'h.tif',
+                          'qx.tif',
+                          'qy.tif',
+                          'roof.tif',
                           'deck.tif']
 
         log = ''
@@ -1217,7 +1217,7 @@ class Config_Manager_2D_GPU:
             logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
 
 
-    def combine_bath_roof_deck(self, bathymetry:WolfArray, 
+    def combine_bath_roof_deck(self, bathymetry:WolfArray,
                                bridge_roof:WolfArray, bridge_deck:WolfArray,
                                threshold:float = .05) -> str:
         """ Verify bathymetry, roof and deck """
@@ -1231,7 +1231,7 @@ class Config_Manager_2D_GPU:
         if ret != '':
             logging.error(ret)
             return ret
-        
+
         # si la matrice de toit de pont est plus basse que la bathymétrie, on met à 99999
         # la bathymétrie et le toit de pont.
         # Ainsi, ces maille seront infranchissables.
@@ -1257,7 +1257,7 @@ class Config_Manager_2D_GPU:
             ret += _(' -- Bathymetry values will be set to max(bath, deck)\n')
             ret += _(' -- These cells will remain impassable until the water level rises above them\n')
             bridge_roof.array.data[mask] = 99999.
-            bathymetry.array.data[mask]  = np.maximum(bridge_deck.array.data[mask], bathymetry.array.data[mask]) 
+            bathymetry.array.data[mask]  = np.maximum(bridge_deck.array.data[mask], bathymetry.array.data[mask])
 
         mask = np.where(bridge_roof.array.data - bathymetry.array.data < threshold)
         if mask[0].shape[0] > 0:
@@ -1273,7 +1273,7 @@ class Config_Manager_2D_GPU:
             logging.warning(ret)
 
         return ret
-    
+
     def create_simulation(self,
                           dir:Path,
                           idx_hydros:list[int] = [-1],
@@ -1576,7 +1576,7 @@ class Config_Manager_2D_GPU:
         for cursim in allsims:
             cursim:Path
             batch += 'cd {}\n'.format(str(cursim.parent))
-            batch += str(cursim.name) + '\n'
+            batch += 'call ' + str(cursim.name) + '\n'
 
         with open(path, 'w', encoding='utf-8') as f:
             f.write(batch)