wolfhece 1.8.8__py3-none-any.whl → 1.8.9__py3-none-any.whl

wolfhece/radar/wolfradar.py

@@ -1,41 +1,199 @@
-import wradlib
+import wradlib as wrl
+import wx
+from math import floor
+from ..PyVertexvectors import *
+from ..hydrology.read import *
 from datetime import datetime as date
+from datetime import timedelta as tdelta
+from datetime import timezone
 from os import path
-from osgeo import gdal
-from drawing_obj import Element_To_Draw
+from osgeo import gdal, osr
+from ..drawing_obj import Element_To_Draw
 
 
 class L08L72:
+    epsgL08:osr.SpatialReference
+    epsgL72:osr.SpatialReference
+    _conv_L08_2_L72:osr.CoordinateTransformation
+    _conv_L72_2_L08:osr.CoordinateTransformation
 
     def __init__(self) -> None:
-        pass
+        self.epsgL08 = osr.SpatialReference()
+        self.epsgL72 = osr.SpatialReference()
+        self.epsgL08.ImportFromEPSG(3812)
+        self.epsgL72.ImportFromEPSG(31370)
 
-    def L08_2_72(x:float, y:float):
-        pass
+        self._conv_L08_2_L72 = osr.CoordinateTransformation(self.epsgL08,self.epsgL72)
+        self._conv_L72_2_L08 = osr.CoordinateTransformation(self.epsgL72,self.epsgL08)
 
-    def L72_2_08(x:float, y:float):
-        pass
+    def L08_2_72(self, x:float, y:float):
+        return self._conv_L08_2_L72.TransformPoint(x, y)[0:2]
+
+    def L72_2_08(self, x:float, y:float):
+        return self._conv_L72_2_L08.TransformPoint(x, y)[0:2]
 
 
 
 class RadarIRM(Element_To_Draw):
     def __init__(self, idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
-        super().__init__(idx, plotted, mapviewer, need_for_wx)
+        super().__init__(idx=idx, plotted=plotted, mapviewer=mapviewer, need_for_wx=need_for_wx)
         pass
 
 
-    def convert2rain(self, coord1, coord2, dateBegin:date, dateEnd:date):
+    def convert2rain(self, coordMin:tuple, coordMax:tuple, dateBegin:date, dateEnd:date, deltaT:tdelta, 
+                     dirIn:str="", dirOut:str="", 
+                     check_all_polygons:bool=False):
+        
+        from datetime import datetime as date
+        # =================
+        # ALL VERIFICATIONS :
+
+        # Checking the validity of the repository to read and write :
+        isOk, dirIn = check_path(dirIn, applyCWD=True)
+        if not isOk:
+            logging.error("The directory chosen for IRM data does not exist. Please check your path! ")
+            return 
+        
+        isOk, dirOut = check_path(dirOut, applyCWD=True)
+        if not isOk:
+            logging.error("The directory chosen for IRM data does not exist. Please check your path! ")
+            return
+
+        
+        # Checking the validity of the dates :
+        dt = deltaT.total_seconds()
+        nb_intervals = floor((dateEnd - dateBegin).total_seconds() / dt)
+        time = [dateBegin + tdelta(seconds=dt*i) for i in range(nb_intervals + 1)]
+        # Prefix for dates
+        dt_str = "{:.0f}d".format(deltaT.days)*(deltaT.days>0) \
+                + "{:.0f}h".format(floor(deltaT.seconds)/3600)*(floor(deltaT.seconds/3600)>0) \
+                + "{:.0f}m".format(floor(deltaT.seconds%3600)/60)*(floor(deltaT.seconds%3600)/60>0)
+        suffix = "".join([".radclim.accum", dt_str, ".hdf"])
+        all_files = [os.path.join(dirIn,"".join([t.strftime("%Y%m%d%H%M%S"),suffix])) for t in time]
+        # are_present = np.all(np.array( \
+        #             [os.path.exists(os.path.join(dirIn,"".join([t.strftime("%Y%m%d%H%M%S"),suffix]))) for t in time] \
+        #             ))
+        
+        are_present = np.all(np.array( \
+                    [os.path.exists(el) for el in all_files] \
+                    ))
+        
+        if not are_present:
+            logging.error("Rain files present in the selected directory are does not contain all the information between the desired interval.")
+            return 
+        
+        # Creating the direcory results
+        # Directory of the shapefile
+        shpDir = os.path.join(dirOut,'Grid')
+        if not os.path.exists(shpDir):
+            try:
+                os.mkdir(shpDir)
+            except OSError:
+                print ("Creation of the directory %s failed" % shpDir)
+                return
+            else:
+                print ("Successfully created the directory %s" % shpDir)
+                shpFile = "Grid_radar.shp"
+                fileOut = os.path.join(shpDir, shpFile)
+        else:
+            shpFile = "Grid_radar.shp"
+            fileOut = os.path.join(shpDir, shpFile)
+        # # Directory of the of the time series
+        timeSeriesDir = os.path.join(dirOut,'IRM')
+        if not os.path.exists(timeSeriesDir):
+            try:
+                os.mkdir(timeSeriesDir)
+            except OSError:
+                print ("Creation of the directory %s failed" % timeSeriesDir)
+            else:
+                print ("Successfully created the directory %s" % timeSeriesDir)
+
+
+        # =================
+        # CORE PROCEDURE
+        # After all verifications, the core procedure can now start :
         # extract all the points in all the .hdf files and their values -> check whether to crop during this process of after
 
-        # create polygons out of the given points
+        # Definition of the domaine zone
+        limits = vector()
+        limits.add_vertex(wolfvertex(coordMin[0],coordMin[1]))
+        limits.add_vertex(wolfvertex(coordMax[0],coordMin[1]))
+        limits.add_vertex(wolfvertex(coordMax[0],coordMax[1]))
+        limits.add_vertex(wolfvertex(coordMin[0],coordMax[1]))
+
+        # The shape file will be based on the first file read
+        cur_file = all_files[0]
+        hdf_ds = gdal.Open(cur_file, gdal.GA_ReadOnly)
+        values, coord, proj = wrl.georef.raster.extract_raster_dataset(hdf_ds, mode="edge", nodata=0.0)
 
         # project the Lambert 2008 in Lambert 1972 coordinates -> let the possibility to crop either points or polygons
+        coord72 = np.zeros_like(coord)
+        proj72 = L08L72()
+        nbI, nbJ, nbC = np.shape(coord)
+        for i in range(nbI):
+            for j in range(nbJ):
+                coord72[i,j] = np.array(proj72.L08_2_72(coord[i,j,0],coord[i,j,1]))
+
+
+        # Creation of a list of polygons containing a list of vertices grouped in tuples
+        all_i, all_j = np.meshgrid(range(nbI-1),range(nbJ-1), indexing='ij')
+        polygons_list = [
+                    [tuple(coord72[i][j]), tuple(coord72[i+1][j]), 
+                     tuple(coord72[i+1][j+1]), tuple(coord72[i][j+1]),
+                     tuple(coord72[i][j])]
+
+                    for i,j,v in zip(all_i.reshape(-1),all_j.reshape(-1),coord72[:-1, :-1].reshape(-1))
+                    ]
+
+        # create polygons out of the given points
+        polygons = zone()
+        zones_indices = []
+        i_zone = 0
+        for cur_poly in polygons_list:
+            cur_vec = vector(name=" ".join(["Zone", str(polygons.nbvectors+1)]))
+            is_inside = False
+            for cur_point in cur_poly:
+                cur_vec.add_vertex(wolfvertex(cur_point[0],cur_point[1]))
+                if limits.isinside(cur_point[0], cur_point[1]):
+                    is_inside = True
+            if is_inside:
+                polygons.add_vector(cur_vec)
+                zones_indices.append(i_zone)
+            i_zone += 1
 
         # save the polygons in .shp shapefile
+        polygons.export_shape(fileOut)
 
-        # Create a folder with the time serie for each polygone
 
-        pass
+        # Create a folder with the time serie for each polygone
+        timeStps = [[str(t.day), str(t.month), str(t.year), str(t.hour), str(t.minute), str(t.second)] for t in time]
+
+        all_values = np.zeros((len(all_files), polygons.nbvectors))
+        for i in range(len(all_files)):
+            cur_file = all_files[i]
+            try:
+                hdf_ds = gdal.Open(cur_file, gdal.GA_ReadOnly)
+                values, coord, proj = wrl.georef.raster.extract_raster_dataset(hdf_ds, mode="edge", nodata=0.0)
+                vec_values = values.reshape(-1)
+                all_values[i,:] = np.nan_to_num([vec_values[i] for i in zones_indices], copy=False, nan=0.0)
+                # FIXME this following line -> to check !!!! -> Convert [mm/h] to accumulated rain [mm] at each time step
+                all_values[i,:] = all_values[i,:]*(dt/3600.0)
+            except:
+                logging.error("".join(["Something bad happened while reading hdf file :", cur_file]))
+                all_values[i,:] = 0.0
+            
+        # Writing the file
+        for iVec in range(polygons.nbvectors):            
+            with open(os.path.join(timeSeriesDir,"".join([str(iVec+1),".rain"])), 'w') as f:
+                f.write("".join([str(iVec+1),"\n"]))
+                f.write("".join([str(1),"\n"]))
+                f.write("".join([str(7),"\n"]))
+                f.write("".join([str(len(all_files)),"\n"]))
+                for cur_t in range(len(timeStps)):
+                    f.write("\t".join(timeStps[cur_t] + [str(all_values[cur_t,iVec])]) + "\n")
+
+                
+        print(are_present)
 
 
     # def plot(self):
@@ -45,3 +203,36 @@ class RadarIRM(Element_To_Draw):
         pass
 
     
+
+
+if __name__ == "__main__":
+
+    app = wx.App()
+    # Selection of the working directory
+    idir=wx.DirDialog(None,"Please choose a IRM rain directory")
+    if idir.ShowModal() == wx.ID_CANCEL:
+        print("Operation cancelled!")
+        idir.Destroy()
+    
+    readDir = idir.GetPath()
+    idir.Destroy()
+
+    idir=wx.DirDialog(None,"Please a directory to write results")
+    if idir.ShowModal() == wx.ID_CANCEL:
+        print("Operation cancelled!")
+        idir.Destroy()
+    
+    writeDir = idir.GetPath()
+    idir.Destroy()
+
+    irm = RadarIRM()
+    coord_min = (0.0, 0.0)
+    coord_max = (0.0, 0.0)
+    db = date(year=2021, month=7, day=1, tzinfo=timezone.utc)
+    de = date(year=2021, month=7, day=31, hour=23, minute=55, tzinfo=timezone.utc)
+    dt = tdelta(minutes=5)
+    print(db)
+
+    irm.convert2rain(coord_min, coord_max, dateBegin=db, dateEnd=de, deltaT=dt, dirIn=readDir, dirOut=writeDir)
+
+    print("The End!")

wolfhece/wolf_array.py

@@ -82,9 +82,12 @@ def getkeyblock(i, addone=True):
         return 'block' + str(i)
 
 class header_wolf():
-    """Header of WolfArray"""
-    # In case of a mutliblock, the header have informations
-    # about all the blocks.
+    """
+    Header of WolfArray
+
+    In case of a mutliblock, the header have informations about all the blocks in head_blocks dictionnary.
+    Keys are generated by "getkeyblock" function
+    """
 
     # FIXME It'd be wise to put the multiblock case into another class.
     # for example "header_wolf_MB" else one could construct hierearchies
@@ -119,11 +122,29 @@ class header_wolf():
         self.nb_blocks = 0
         self.head_blocks = {}
 
-    def set_orig(self, x, y, z):
+        self.nbdims = 0
+
+    def __get_item__(self, key=None):
+        """
+        return block header
+
+        :param key:int = block's index (0-based)
+        """
+        if key is None:
+            return self
+        else:
+            return self.head_blocks[getkeyblock(int(key))]
+
+    def set_orig(self, x:float, y:float, z:float):
         self.origx = x
         self.origy = y
         self.origz = z
 
+    def set_transl(self, tr_x:float, tr_y:float, tr_z:float):
+        self.translx = tr_x
+        self.transly = tr_y
+        self.translz = tr_z
+
     def get_bounds(self, abs=True):
         if abs:
             return ([self.origx + self.translx, self.origx + self.translx + float(self.nbx) * self.dx],
@@ -140,18 +161,174 @@ class header_wolf():
             [self.get_ij_from_xy(mybounds[0][0], mybounds[1][0]), self.get_ij_from_xy(mybounds[0][1], mybounds[0][0])],
             [self.get_ij_from_xy(mybounds[0][0], mybounds[1][1]), self.get_ij_from_xy(mybounds[0][1], mybounds[1][1])])
 
-    def get_ij_from_xy(self, x, y, abs=True):
+    def get_ij_from_xy(self, x:float, y:float, z:float=0., scale:float=1., aswolf:bool=False, abs:bool=True, forcedims2:bool=False) -> Union[tuple[np.int32,np.int32], tuple[np.int32,np.int32,np.int32]]:
+        """
+        Get indices from coordinates
+
+        :param x = X coordinate
+        :param y = Y coordinate
+        :param z = Z coordinate (optional)
+        :param scale = scaling of the spatial resolution (dx,dy,[dz])
+        :param aswolf = if True, return if one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
+        :param abs = if True, remove translation from (x, y, [z]) (coordinate from global space)
+        :param forcedims2 = if True, force to return only 2 indices even if z is supplied
+        """
 
         locx = np.float64(x) - self.origx
         locy = np.float64(y) - self.origy
+        locz = np.float64(z) - self.origz
         if abs:
             locx = locx - self.translx
             locy = locy - self.transly
+            locz = locz - self.translz
+
+        i = np.int32(locx / (self.dx * scale))
+        j = np.int32(locy / (self.dy * scale))
+
+        if aswolf:
+            i += 1
+            j += 1
+
+        if self.nbdims == 3 and not forcedims2:
+            k = np.int32(locz / (self.dz * scale))
+            if aswolf:
+                k += 1
+            return i, j, k
+        elif self.nbdims == 2 or forcedims2:
+            return i, j
+
+    def get_ij_from_xy_array(self, xy:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True, forcedims2:bool=False) -> np.ndarray:
+        """
+        Get indices from coordinates
+
+        :param xy = numpy array containing (x, y, [z]) coordinates
+        :param scale = scaling of the spatial resolution (dx,dy,[dz])
+        :param aswolf = if True, return if one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
+        :param abs = if True, remove translation from (x, y, [z]) (coordinate from global space)
+        :param forcedims2 = if True, force to return only 2 indices even if z is supplied
+        """
+
+        locxy = xy.copy()
+
+        if forcedims2:
+            locij = np.zeros((xy.shape[0],2), dtype=np.int32)
+        else:
+            locij = np.zeros(xy.shape, dtype=np.int32)
+
+        locxy[:,0] -= self.origx
+        locxy[:,1] -= self.origy
+
+        if abs:
+            locxy[:,0] -= self.translx
+            locxy[:,1] -= self.transly
+
+        i = np.int32(locxy[:,0] / (self.dx * scale))
+        j = np.int32(locxy[:,2] / (self.dy * scale))
+
+        if aswolf:
+            i += 1
+            j += 1
+
+        if self.nbdims == 3 and not forcedims2:
+            locxy[:,2] -= self.origz
+            if abs:
+                locxy[:,2] -= self.translz
+            k = np.int32(locxy[:,3] / (self.dz * scale))
+
+            if aswolf:
+                k += 1
+
+            locij[:,0] = i
+            locij[:,1] = j
+            locij[:,2] = k
+
+            return locij
+
+        elif self.nbdims == 2 or forcedims2:
+            locij[:,0] = i
+            locij[:,1] = j
+            return locij
+
+
+    def get_xy_from_ij(self, i:int, j:int, k:int=0, scale:float=1., aswolf:bool=False, abs:bool=True) -> Union[tuple[np.float64,np.float64], tuple[np.float64,np.float64,np.float64]]:
+        """
+        Get coordinates from indices
+
+        :param i = index along X coordinate
+        :param j = index along Y coordinate
+        :param k = index along Z coordinate (optional)
+        :param scale = scaling of the spatial resolution (dx,dy,[dz])
+        :param aswolf = if True, input is one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
+        :param abs = if True, add translation to results (x, y, [z]) (coordinate to global space)
+        """
+        i = np.int32(i)
+        j = np.int32(j)
+
+        if aswolf:
+            # FIXME Put assertion here.
+            i += -1
+            j += -1
+
+        if abs:
+            x = (np.float64(i) + .5) * (self.dx * scale) + self.origx + self.translx
+            y = (np.float64(j) + .5) * (self.dy * scale) + self.origy + self.transly
+        else:
+            x = (np.float64(i) + .5) * (self.dx * scale) + self.origx
+            y = (np.float64(j) + .5) * (self.dy * scale) + self.origy
+
+        if self.nbdims == 3:
+            k = np.int32(k)
+            if aswolf:
+                k += -1
+
+            if abs:
+                z = (np.float64(k) - .5) * (self.dz * scale) + self.origz + self.translz
+            else:
+                z = (np.float64(k) - .5) * (self.dz * scale) + self.origz
+
+            return x, y, z
 
-        i = np.int32(locx / self.dx)
-        j = np.int32(locy / self.dy)
+        elif self.nbdims == 2:
+            return x, y
+        else:
+            raise Exception(_("The number of coordinates is not correct"))
 
-        return i, j  # ATTENTION, Indices en numérotation Python --> WOLF ajouter +1
+    def get_xy_from_ij_array(self, ij:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
+        """
+        Converts array coordinates (numpy cells) to this array's world coodinates.
+
+        :param ij = numpy array containing (i, j, [k]) indices
+        :param scale = scaling of the spatial resolution (dx,dy,[dz])
+        :param aswolf = if True, input is one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
+        :param abs = if True, add translation to results (x, y, [z]) (coordinate to global space)
+        """
+
+        if abs:
+            tr_x = self.translx
+            tr_y = self.transly
+            tr_z = self.translz
+        else:
+            tr_x = 0.
+            tr_y = 0.
+            tr_z = 0.
+
+        if aswolf:
+            decali = -1
+            decalj = -1
+            decalk = -1
+        else:
+            decali = 0
+            decalj = 0
+            decalk = 0
+
+        xy = np.zeros(ij.shape)
+        xy[:,0] = (np.float64( (ij[:,0])+decali) + .5) * (self.dx*scale) + self.origx + tr_x
+        xy[:,1] = (np.float64( (ij[:,1])+decalj) + .5) * (self.dy*scale) + self.origy + tr_y
+
+        if self.nbdims == 3 and ij.shape[2]==3:
+            xy[:,2] = (np.float64( (ij[:,2])+decalk) + .5) * (self.dz*scale) + self.origz + tr_z
+
+        return xy
 
     def find_intersection(self, other, ij=False):
 
@@ -251,6 +428,8 @@ class header_wolf():
         test &= self.nby == other.nby
         test &= self.nbz == other.nbz
 
+        test &= self.nbdims == other.nbdims
+
         return test
 
 class NewArray(wx.Dialog):
@@ -2483,6 +2662,8 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         # Data type of the values
         self.nullvalue = band.GetNoDataValue()
+        if self.nullvalue is None:
+            self.nullvalue = 0.
 
         geotr = raster.GetGeoTransform()
         self.origx = geotr[0]
@@ -3271,6 +3452,8 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         curhead.head_blocks = self.head_blocks.copy()
 
+        curhead.nbdims = self.nbdims
+
         if abs:
             curhead.origx += curhead.translx
             curhead.origy += curhead.transly
@@ -3298,6 +3481,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.nby = header.nby
         self.nbz = header.nbz
 
+        self.nbdims = header.nbdims
+
         self.nb_blocks = header.nb_blocks
         self.head_blocks = header.head_blocks.copy()
 
@@ -4021,10 +4206,11 @@ class WolfArray(Element_To_Draw, header_wolf):
         if self.array is None:
             return
 
-        if np.isnan(value) or math.isnan(value):
-            self.array.mask = np.isnan(self.array.data)
-        else:
-            self.array.mask = self.array.data == value
+        if value is not None:
+            if np.isnan(value) or math.isnan(value):
+                self.array.mask = np.isnan(self.array.data)
+            else:
+                self.array.mask = self.array.data == value
         self.nbnotnull = self.array.count()
 
     def mask_lower(self, value):
@@ -4165,80 +4351,6 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return ([ox, ex], [oy, ey])
 
-    def get_ij_from_xy(self, x, y, z=0., scale=1., aswolf=False, abs=True, forcedims2=False):
-        # FIXME Use wolf_header's functions for 2D
-        # FIXME aswolf, abs, etc. seems too tricky to me
-
-        locx = np.float64(x) - self.origx
-        locy = np.float64(y) - self.origy
-        locz = np.float64(z) - self.origz
-        if abs:
-            locx = locx - self.translx
-            locy = locy - self.transly
-            locz = locz - self.translz
-
-        i = np.int32(locx / (self.dx * scale))
-        j = np.int32(locy / (self.dy * scale))
-
-        if aswolf:
-            i += 1
-            j += 1
-
-        if self.nbdims == 3 and not forcedims2:
-            k = np.int32(locz / (self.dz * scale))
-            if aswolf:
-                k += 1
-            return i, j, k  # ATTENTION, Indices en numérotation Python --> WOLF ajouter +1
-        elif self.nbdims == 2 or forcedims2:
-            return i, j  # ATTENTION, Indices en numérotation Python --> WOLF ajouter +1
-
-    def get_xy_from_ij(self, i, j, k=0, scale=1., aswolf=False, abs=True) -> Union[tuple[np.float64,np.float64], tuple[np.float64,np.float64,np.float64]]:
-        # i,j are expected to be zero-based, unless `aswolf` is True in which
-        # case they are expected to be one based
-
-        # FIXME Use wolf_header's functions for 2D ?
-        i = np.int32(i)
-        j = np.int32(j)
-
-        if aswolf:
-            # FIXME Put assertion here.
-            i += -1
-            j += -1
-
-        if abs:
-            x = (np.float64(i) + .5) * (self.dx * scale) + self.origx + self.translx
-            y = (np.float64(j) + .5) * (self.dy * scale) + self.origy + self.transly
-        else:
-            x = (np.float64(i) + .5) * (self.dx * scale) + self.origx
-            y = (np.float64(j) + .5) * (self.dy * scale) + self.origy
-
-        if self.nbdims == 3:
-            k = np.int32(k)
-            if aswolf:
-                k += -1
-
-            if abs:
-                z = (np.float64(k) - .5) * (self.dz * scale) + self.origz + self.translz
-            else:
-                z = (np.float64(k) - .5) * (self.dz * scale) + self.origz
-
-            return x, y, z
-
-        elif self.nbdims == 2:
-            return x, y
-        else:
-            raise Exception(_("The number of coordinates is not correct"))
-
-    def get_xy_from_ij_array(self, ij:np.ndarray):
-        # Converts array coordinates (numpy cells, 0-based)
-        # to this array's world coodinates.
-
-        xy = np.zeros(ij.shape)
-        xy[:,0] = (np.float64(ij[:,0]) + .5) * self.dx + self.origx + self.translx
-        xy[:,1] = (np.float64(ij[:,1]) + .5) * self.dy + self.origy + self.transly
-
-        return xy
-
     def get_value(self, x, y, z=0., nullvalue=-99999):
 
         if self.nbdims == 2:
@@ -4710,7 +4822,7 @@ class WolfArrayMB(WolfArray):
                 curarray = self.myblocks[getkeyblock(i)]
                 f.write(curarray.array.data.transpose().tobytes())
 
-    def get_ij_from_xy(self, x, y, z=0, scale=1, aswolf=False, abs=True, which_block=1):
+    def get_ij_from_xy(self, x:float, y:float, z:float=0., scale:float=1., aswolf:bool=False, abs:bool=True, which_block:int=1):
         return self.myblocks[getkeyblock(which_block, False)].get_ij_from_xy(x, y, z, scale, aswolf, abs)
 
     def get_values_as_wolf(self, i, j, which_block=1):

{wolfhece-1.8.8.dist-info → wolfhece-1.8.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 1.8.8
+Version: 1.8.9
 Summary: WOLF package
 Home-page: https://uee.uliege.be/hece
 Author: Pierre Archambeau
@@ -16,6 +16,7 @@ Requires-Dist: wxpython
 Requires-Dist: numpy
 Requires-Dist: pyopengl
 Requires-Dist: pandas
+Requires-Dist: geopandas
 Requires-Dist: scipy
 Requires-Dist: owslib
 Requires-Dist: pillow
@@ -43,6 +44,8 @@ Requires-Dist: pygltflib
 Requires-Dist: ezdxf
 Requires-Dist: pyvista
 Requires-Dist: tqdm
+Requires-Dist: osmnx
+Requires-Dist: tifffile
 
 Ce paquet contient l'interface graphique Python du logiciel WOLF (HECE - ULiège) de même que plusieurs outils de traitements topographique, hydraulique et hydrologique.