wolfhece 2.1.98__py3-none-any.whl → 2.1.100__py3-none-any.whl

wolfhece/wolf_vrt.py

@@ -38,7 +38,24 @@ def create_vrt(wdir:str, fout:str='out.vrt', format:str='tif'):
     myvrt = None
 
     os.chdir(curdir)
-
+def _get_diverged_relative_path(path: Path, base: Path) -> Path:
+    """
+    Get relative path from base to path, even if they only share part of their paths.
+    More general than the next function "_get_relative_path", especially for not "child/parents paths"
+    """
+    
+    # Parts of the paths
+    relative_path_parts = path.parts
+    base_parts = base.parts
+    # Where do they diverge ?
+    i = 0
+    while i < min(len(relative_path_parts), len(base_parts)) and relative_path_parts[i] == base_parts[i]:
+        i += 1
+
+    # Building of the relative path, by adding ".." from the divergence point
+    return Path(*(['..'] * (len(base_parts) - i) + list(relative_path_parts[i:])))
+    
+    
 def _get_relative_path(path:Path, base:Path):
     """
     Get relative path from base to path
@@ -47,7 +64,6 @@ def _get_relative_path(path:Path, base:Path):
     :type path: Path
     :param base: base path
     :type base: Path
-
     """
 
     if base in path.parents:
@@ -79,7 +95,8 @@ def create_vrt_from_files(files:list[Path]=[], fout:Path='assembly.vrt'):
     # change working directory to the parent of the output file
     os.chdir(fout.parent)
     # work with relative paths
-    myvrt = gdal.BuildVRT(str(fout.with_suffix('.vrt').name) , [str(_get_relative_path(file, fout.parent)) for file in files])
+    
+    myvrt = gdal.BuildVRT(str(fout.with_suffix('.vrt').name) , [str(_get_diverged_relative_path(file, fout.parent)) for file in files])
     # close the dataset -- force to write on disk
     myvrt = None
     # restore working directory
@@ -91,7 +108,7 @@ def create_vrt_from_files_first_based(files:list[Path]=[], fout:Path='assembly.v
 
     Restreint l'emprise et force la résolution sur le premier fichier listé
     """
-
+    
     if isinstance(fout, str):
         fout = Path(fout)
 
@@ -119,6 +136,7 @@ def create_vrt_from_files_first_based(files:list[Path]=[], fout:Path='assembly.v
 
     locNoData = raster.GetRasterBand(1).GetNoDataValue()
 
+    # options of BuildVRT defined on properties of "files[0]"
     options = gdal.BuildVRTOptions(resolution='user',
                                    xRes=abs(geotr[1]),
                                    yRes=abs(geotr[5]),
@@ -128,11 +146,94 @@ def create_vrt_from_files_first_based(files:list[Path]=[], fout:Path='assembly.v
 
     # retain current working directory
     oldcwd = os.getcwd()
-    # change working directory to the parent of the output file
-    os.chdir(fout.parent.absolute())
+    # change working directory to the parent of the output file 
+    os.chdir(fout.parent.absolute()) 
+    # work with relative paths 
+    myvrt = gdal.BuildVRT(str(fout.with_suffix('.vrt').name),[str(_get_diverged_relative_path(file, fout.parent)) for file in files], options=options) #str(_get_diverged_relative_path(file, fout.parent)) for file in files
+    
+    # close the dataset -- force to write on disk
+    myvrt = None
+    # restore working directory
+    os.chdir(oldcwd)
+    
+    
+def create_vrt_from_diverged_files(files:list[Path]=[], fout:Path='assembly.vrt'):
+    """
+    Agglomération de tous les fichiers énumérés dans files dans un layer virtuel .vrt
 
+    :param files: list of files to process
+    :type files: list[Path]
+    :param fout: output file
+    :type fout: Path
+    """
+
+    if isinstance(fout, str):
+        fout = Path(fout)
+
+    if isinstance(files[0], str):
+        files = [Path(file) for file in files]
+
+    # retain current working directory
+    oldcwd = os.getcwd()
+    # change working directory to the parent of the output file
+    os.chdir(fout.parent)
     # work with relative paths
-    myvrt = gdal.BuildVRT(str(fout.with_suffix('.vrt').name) , [str(_get_relative_path(file, fout.parent)) for file in files], options=options)
+    
+    myvrt = gdal.BuildVRT(str(fout.with_suffix('.vrt').name) , [str(_get_diverged_relative_path(file, fout.parent)) for file in files])
+    # close the dataset -- force to write on disk
+    myvrt = None
+    # restore working directory
+    os.chdir(oldcwd)
+
+def create_vrt_from_diverged_files_first_based(files:list[Path]=[], fout:Path='assembly.vrt', Nodata:float=99999.):
+    """
+    Agglomération de tous les fichiers énumérés dans files dans un layer virtuel .vrt
+
+    Restreint l'emprise et force la résolution sur le premier fichier listé
+    """
+    
+    if isinstance(fout, str):
+        fout = Path(fout)
+
+    if isinstance(files[0], str):
+        files = [Path(file) for file in files]
+
+    first = files[0]
+    raster:gdal.Dataset
+    raster = gdal.Open(str(first))
+    geotr = raster.GetGeoTransform()
+
+    # Dimensions
+    nbx = raster.RasterXSize
+    nby = raster.RasterYSize
+
+    xmin = geotr[0]
+    xmax = geotr[0]+geotr[1]*float(nbx)
+
+    if geotr[5]>0:
+        ymin = geotr[3]
+        ymax = geotr[3]+geotr[5]*float(nby)
+    else:
+        ymin = geotr[3]+geotr[5]*float(nby)
+        ymax = geotr[3]
+
+    locNoData = raster.GetRasterBand(1).GetNoDataValue()
+
+    # options of BuildVRT defined on properties of "files[0]"
+    options = gdal.BuildVRTOptions(resolution='user',
+                                   xRes=abs(geotr[1]),
+                                   yRes=abs(geotr[5]),
+                                   outputBounds=[xmin,ymin,xmax,ymax],
+                                   resampleAlg='bilinear',
+                                   srcNodata=Nodata)
+
+    # retain current working directory
+    oldcwd = os.getcwd()
+    # change working directory to the parent of the output file 
+    os.chdir(fout.parent.absolute()) 
+    # work with relative paths 
+    myvrt = gdal.BuildVRT(str(fout.with_suffix('.vrt').name),[str(_get_diverged_relative_path(file, fout.parent)) for file in files], options=options) #str(_get_diverged_relative_path(file, fout.parent)) for file in files
+    
     # close the dataset -- force to write on disk
     myvrt = None
     # restore working directory

wolfhece/wolfresults_2D.py

@@ -12,6 +12,7 @@ import sys
 import wx
 from os.path import dirname, exists, join, splitext
 from math import floor
+from pathlib import Path
 
 import numpy.ma as ma
 import numpy as np
@@ -51,7 +52,6 @@ except Exception as ex:
 
     from importlib.util import find_spec
     s = find_spec('wolfhece.libs.wolfpy')
-    from pathlib import Path
 
     # Not too sure about this find_spec. If the root
     # directory is not the good one, the import search may
@@ -747,7 +747,6 @@ class Props_Res_2D(wx.Frame):
         """ Load default palette """
 
         import glob
-        from pathlib import Path
 
         # list of all .pal file in model directory
 
@@ -2303,6 +2302,25 @@ class Wolfresults_2D(Element_To_Draw):
         self.myops = None
         self._active_blocks = 0
 
+    @property
+    def all_dt(self):
+        #FIXME : defined in GPU version --> to be implemented for CPU version
+        pass
+
+    @property
+    def all_mostly_dry_mesh(self):
+        #FIXME : defined in GPU version --> to be implemented for CPU version
+        pass
+
+    @property
+    def all_clock_time(self):
+        #FIXME : defined in GPU version --> to be implemented for CPU version
+        pass
+
+    @property
+    def all_wet_meshes(self):
+        #FIXME : defined in GPU version --> to be implemented for CPU version
+        pass
 
     def set_opacity(self, alpha:float):
         """ Set the transparency of the array """
@@ -3691,6 +3709,80 @@ class Wolfresults_2D(Element_To_Draw):
         """
         self._cache = None
 
+    def get_hydrographs(self, vect:Union[vector, list[vector], zone]):
+        """ Get hydrograph accross a vector
+
+        :param vect: wolf polyline or list of wolf polylines or zone
+        """
+
+        assert isinstance(vect, vector | list | zone), 'Expected a vector'
+
+        if isinstance(vect, zone):
+            vect = vect.myvectors
+
+        nb = self.get_nbresults()
+        times, steps = self.times, self.timesteps
+
+        if isinstance(vect, vector):
+            q=[]
+            for i in tqdm(range(nb)):
+                if i==0:
+                    myhead = self.get_header_block(1)
+                    vect_raster = myhead.rasterize_vector(vect)
+                self.read_oneresult(i)
+                q.append(self._plot_one_q_raster_splitting(vect_raster, True, to_rasterize = False))
+
+        elif isinstance(vect, list):
+            q={str:list}
+            vect_raster = []
+            myhead = self.get_header_block(1)
+
+            for i in range(len(vect)):
+                q[vect[i].myname]= []
+                vect_raster.append(myhead.rasterize_vector(vect[i]))
+
+            for i in tqdm(range(nb)):
+                self.read_oneresult(i)
+
+                for curvec, cur_vect_raster in zip(vect, vect_raster):
+                    q[curvec.myname].append(self._plot_one_q_raster_splitting(cur_vect_raster, True, to_rasterize = False))
+
+        return times, q
+
+    def export_hydrographs(self, vect:Union[vector, list[vector], zone], filename:str|Path):
+        """ Export hydrograph accross a vector as CSV file
+
+        :param vect: wolf polyline or list of wolf polylines or zone
+        :param filename: output filename
+        """
+
+        assert isinstance(vect, vector | list | zone), 'Expected a vector'
+
+        filename = Path(filename)
+        filename = filename.with_suffix('.csv')
+
+        if isinstance(vect, zone):
+            vect = vect.myvectors
+
+        times, q = self.get_hydrographs(vect)
+
+        with open(filename, 'w') as f:
+            f.write('Time [s],')
+            if isinstance(vect, vector):
+                f.write(vect.myname)
+            elif isinstance(vect, list):
+                f.write(','.join([cur.myname for cur in vect]))
+            f.write('\n')
+
+            for i in range(len(times)):
+                f.write(f'{times[i]},')
+                if isinstance(vect, vector):
+                    f.write(f'{q[i]}')
+                elif isinstance(vect, list):
+                    f.write(','.join([str(q[cur.myname][i]) for cur in vect]))
+                f.write('\n')
+
+
     #FIXME : rename 'x_or_y' to be more explicit
     def plot_q(self,
                vect:Union[vector, list[vector]],
@@ -4435,9 +4527,9 @@ class Wolfresults_2D(Element_To_Draw):
     def export_as(self,
                   outdir:str,
                   fields:list[views_2D],
-                  which:Literal['geotiff', 'shape'],
+                  which:Literal['geotiff', 'shape', 'numpy'],
                   multiband:bool=True):
-        """ Export as geotiff or shapefile """
+        """ Export as geotiff or shapefile or numpy """
 
         oldview = self.get_currentview()
         old_plotted = self.plotted
@@ -4470,6 +4562,19 @@ class Wolfresults_2D(Element_To_Draw):
                             [key.value for key,arr in arrays.items()],
                             shape_mask)
 
+        elif which=='numpy':
+            for curfield, curarray in arrays.items():
+                if curfield == views_2D.TOPOGRAPHY:
+                    curarray.write_all(Path(outdir) / 'bathymetry.npy')
+                elif curfield == views_2D.WATERDEPTH:
+                    curarray.write_all(Path(outdir) / 'h.npy')
+                elif curfield == views_2D.QX:
+                    curarray.write_all(Path(outdir) / 'qx.npy')
+                elif curfield == views_2D.QY:
+                    curarray.write_all(Path(outdir) / 'qy.npy')
+                else:
+                    curarray.write_all(Path(outdir) / (curfield.value + '.npy'))
+
         self.plotted = old_plotted
         self.set_currentview(oldview)
 

wolfhece/xyz_file.py

@@ -13,106 +13,130 @@ import numpy as np
 import matplotlib.pyplot as plt
 from os.path import normpath,exists,join,basename
 from os import listdir,scandir
+import logging
 
 from .PyTranslate import _
 
 class XYZFile:
     """ Classe pour la gestion des fichiers xyz """
-    nblines:int
     x:np.array
     y:np.array
     z:np.array
     filename:str
 
-    def __init__(self, fname,toread=True):
+    def __init__(self, fname:str, toread:bool= True,
+                 folder:str= None, bounds:list= None,
+                 delimiter:str=','):
         """ Initialisation du nom du fichier """
+
         self.filename = fname
-        self.nblines=0
-        
+
         self.x = None
         self.y = None
         self.z = None
         self.xyz = None
-        
+
         if toread:
-            self.read_from_file()
+            self.read_from_file(folder=folder, bounds=bounds, delimiter=delimiter)
+
+    @property
+    def nblines(self):
+        if self.x is None:
+            return 0
+        else:
+            return len(self.x)
+
+    def reset(self):
+        """ Reset des données """
+        self.x = None
+        self.y = None
+        self.z = None
+        self.xyz = None
 
     def test_bounds(self,bounds):
-        
+
         if bounds is None:
             return True
-        
+
         x1=bounds[0][0]
         x2=bounds[0][1]
         y1=bounds[1][0]
         y2=bounds[1][1]
-        
+
         mybounds = self.get_extent()
 
         test = not(x2 < mybounds[0][0] or x1 > mybounds[0][1] or y2 < mybounds[1][0] or y1 > mybounds[1][1])
-    
+
         return test
 
-    def read_from_file(self):
+    def read_from_file(self, folder:str=None, bounds:list=None, delimiter=','):
         """ Lecture d'un fichier xyz et remplissage de l'objet """
-        
-        self.xyz = np.genfromtxt(self.filename, delimiter=',',dtype=np.float32)
+
+        try:
+            if folder is None:
+                self.xyz = np.genfromtxt(self.filename, delimiter=delimiter, dtype=np.float32)
+            else:
+                if bounds is None:
+                    self.reset()
+                    logging.error(_('Bounds must be defined when reading a directory'))
+                    return
+
+                self.xyz = xyz_scandir(folder,bounds=bounds,delimiter=delimiter)
+                # check if self.xyz is an empty array
+                if len(self.xyz) == 0:
+                    self.xyz = None
+                    return
+        except:
+            self.reset()
+            logging.error(_('Error reading file: {self.filename}'))
+            return
+
         self.x = self.xyz[:,0]
         self.y = self.xyz[:,1]
         self.z = self.xyz[:,2]
-        self.nblines = len(self.xyz)        
-        
-        # with open(self.filename, 'r') as f:
-        #     self.nblines = sum(1 for line in f)
-        #     self.x = np.zeros(self.nblines)
-        #     self.y = np.zeros(self.nblines)
-        #     self.z = np.zeros(self.nblines)
-        #     f.seek(0)
-        #     self.nblines = 0
-        #     for line in f:
-        #         tmp = line.split()
-        #         if tmp:
-        #             if is_float(tmp[0]):
-        #                 self.x[self.nblines] = float(tmp[0])
-        #                 self.y[self.nblines] = float(tmp[1])
-        #                 self.z[self.nblines] = float(tmp[2])
-        #                 self.nblines += 1
 
     def fill_from_wolf_array(self, myarray,nullvalue=0.):
         """ Création d'un fichier xyz depuis les données d'un WOLF array """
-        self.nblines = myarray.nbx * myarray.nby
-        self.x = np.zeros(self.nblines)
-        self.y = np.zeros(self.nblines)
-        self.z = np.zeros(self.nblines)
-        self.nblines = 0
+
+        nbmaxlines = myarray.nbx * myarray.nby
+        self.x = np.zeros(nbmaxlines)
+        self.y = np.zeros(nbmaxlines)
+        self.z = np.zeros(nbmaxlines)
+
+        k=0
         for cury in range(myarray.nby):
             y = cury * myarray.dy + 0.5 * myarray.dy + myarray.origy + myarray.transly
             for curx in range(myarray.nbx):
                 z = myarray.array[curx, cury]
                 if z != nullvalue:
                     x = curx * myarray.dx + 0.5 * myarray.dx + myarray.origx + myarray.translx
-                    self.x[self.nblines] = x
-                    self.y[self.nblines] = y
-                    self.z[self.nblines] = z
-                    self.nblines += 1
+                    self.x[k] = x
+                    self.y[k] = y
+                    self.z[k] = z
+                    k+=1
+
+        # crop the arrays
+        self.x = self.x[:k]
+        self.y = self.y[:k]
+        self.z = self.z[:k]
 
     def write_to_file(self):
         """ Ecriture des informations dans un fichier """
+
         with open(self.filename, 'w') as f:
             for i in range(self.nblines):
                 f.write('{:.3f},{:.3f},{:.3f}\n'.format(self.x[i], self.y[i], self.z[i]))
 
     def get_extent(self):
         """ Retourne les limites du rectangle qui encadre le nuage de points """
+
         xlim = [np.min(self.x), np.max(self.x)]
         ylim = [np.min(self.y), np.max(self.y)]
         return (xlim, ylim)
 
-    def merge(self, xyz_list):
+    def merge(self, xyz_list:list["XYZFile"]):
         """ Merge des fichiers xyz en 1 seul """
-        for cur_xyz in xyz_list:
-            self.nblines += cur_xyz.nblines
-            
+
         newxyz = np.concatenate([cur.xyz for cur in xyz_list])
 
         if self.xyz is not None:
@@ -126,6 +150,7 @@ class XYZFile:
 
     def plot(self):
         """ Représentation graphique des points """
+
         plt.scatter(self.x, self.y, c=self.z, marker='.', cmap='viridis', edgecolors='none')
         plt.xlabel('x [m]')
         plt.ylabel('y [m]')
@@ -137,16 +162,17 @@ class XYZFile:
         plt.pause(0.1)
 
     def find_points(self,bounds):
-        
+
         if bounds is None:
             return self.xyz
-        
+
         xb=bounds[0]
         yb=bounds[1]
+
         # Get arrays which indicate invalid X, Y, or Z values.
         X_valid = (xb[0] <= self.x) & (xb[1] > self.x)
         Y_valid = (yb[0] <= self.y) & (yb[1] > self.y)
-        good_indices = np.where(X_valid & Y_valid)[0]          
+        good_indices = np.where(X_valid & Y_valid)[0]
         return self.xyz[good_indices]
 
 def is_float(s):
@@ -156,19 +182,33 @@ def is_float(s):
     except ValueError:
         return False
 
-def xyz_scandir(mydir,bounds):
-    
+def xyz_scandir(mydir:str, bounds:list, delimiter:str=',') -> np.ndarray:
+    """
+    Function that reads all the xyz files in a directory and its subdirectories
+
+    :param mydir: directory to scan
+    :dtype mydir: str
+    :param bounds: bounds of the area to consider [[x1,x2],[y1,y2]]
+    :dtype bounds: list
+    :return: list of points
+    """
+
     first=[]
     for curfile in listdir(mydir):
         if curfile.endswith('.xyz'):
-            mydata = XYZFile(join(mydir,curfile))
+            mydata = XYZFile(join(mydir,curfile), delimiter=delimiter)
             if mydata.test_bounds(bounds):
-                print(curfile)
+                if isinstance(mydir,str):
+                    logging.info(mydir)
+                else:
+                    logging.info(mydir.path)
+                logging.info(curfile)
                 first.append(mydata.find_points(bounds))
 
+    # if there is a subdirectory, we go deeper
     for entry in scandir(mydir):
         if entry.is_dir():
-            locf=xyz_scandir(entry,bounds)
+            locf=xyz_scandir(entry, bounds, delimiter)
             if len(locf)>0:
                 first.append(locf)
 

{wolfhece-2.1.98.dist-info → wolfhece-2.1.100.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.98
+Version: 2.1.100
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece