wolfhece 2.2.43__py3-none-any.whl → 2.2.45__py3-none-any.whl

wolfhece/wolf_array.py

@@ -515,6 +515,15 @@ class header_wolf():
             return ([self.origx, self.origx + float(self.nbx) * self.dx],
                     [self.origy, self.origy + float(self.nby) * self.dy])
 
+    def get_scale_yoverx(self):
+        """
+        Return the scale of the array (height over width)
+        """
+        if self.dx == 0 or self.dy == 0 or self.nbx == 0 or self.nby == 0:
+            return 1.
+
+        return float((self.nby * self.dy) / (self.nbx * self.dx))
+
     def get_bounds_ij(self, abs=False):
         """
         Return bounds in indices
@@ -596,6 +605,9 @@ class header_wolf():
         else:
             locij = np.zeros(locxy.shape, dtype=np.int32)
 
+        if locxy.size == 0:
+            return locij
+
         locxy[:,0] -= self.origx
         locxy[:,1] -= self.origy
 
@@ -6485,10 +6497,15 @@ class WolfArray(Element_To_Draw, header_wolf):
             if hasattr(self, 'shaded'):
                 del self.shaded
 
-            if sys.meta_path is not None:
-                # Perform garbage collection if gc is available
-                import gc
-                gc.collect()
+            try:
+                if sys.meta_path is not None:
+                    # Perform garbage collection if gc is available
+                    import gc
+                    gc.collect()
+            except Exception:
+                # Try/except to avoid issues during interpreter shutdown
+                pass
+
         except Exception as e:
             print(f"Exception in WolfArray destructor: {e} -- Please report this issue")
 
@@ -7693,6 +7710,10 @@ class WolfArray(Element_To_Draw, header_wolf):
         depuis les vertices 3D du polygone
         """
 
+        if vector.area == 0.:
+            logging.error(_('The polygon has no area'))
+            return
+
         if keep not in ['all', 'below', 'above']:
             logging.error(_('keep must be "all", "below" or "above"'))
             raise ValueError
@@ -7702,7 +7723,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             raise ValueError
 
         if self.mngselection is None:
-            destxy = self.get_xy_inside_polygon(working_vector)
+            destxy = self.get_xy_inside_polygon(working_vector, method = 'shapely_strict')
             if len(destxy)==0:
                 logging.debug(_('No points to interpolate'))
                 return
@@ -7720,16 +7741,16 @@ class WolfArray(Element_To_Draw, header_wolf):
             destxy = self.ij2xy_np(destij)
         else:
             if self.SelectionData.nb == 0:
-                destxy = self.get_xy_inside_polygon(working_vector)
+                destxy = self.get_xy_inside_polygon(working_vector, method= 'shapely_strict')
+                if destxy.shape[0] == 0:
+                    logging.debug(_('No points to interpolate'))
+                    return
             else:
                 destxy = self.SelectionData.myselection
 
-                # if isinstance(destxy, list):
-                #     destxy = np.asarray(destxy)
-
-            if len(destxy)==0:
-                logging.debug(_('No points to interpolate'))
-                return
+                if len(destxy)==0:
+                    logging.debug(_('No points to interpolate'))
+                    return
 
             destij = self.xy2ij_np(destxy)
 
@@ -7813,6 +7834,56 @@ class WolfArray(Element_To_Draw, header_wolf):
         for curvec in working_zone.myvectors:
             self.interpolate_on_polygon(curvec, method, keep)
 
+    def interpolate_strictly_on_polyline(self, working_vector:vector, usemask=True, keep:Literal['all', 'below', 'above'] = 'all'):
+        """
+        Interpolation des mailles strictement sous une polyligne.
+
+        On utilise ensuite "interpolate" de shapely pour interpoler les altitudes des mailles
+        depuis les vertices 3D de la polyligne
+        """
+
+        vecls = working_vector.linestring
+        xy = self.get_xy_strictly_on_borders(working_vector, usemask=usemask)
+        if xy.shape[0] == 0:
+            logging.debug(_('No points to interpolate'))
+            return
+        ij = np.asarray([self.get_ij_from_xy(x, y) for x, y in xy])
+        newz = np.asarray([vecls.interpolate(vecls.project(Point(x, y))).z for x, y in xy])
+
+        if keep == 'all':
+            self.array.data[ij[:, 0], ij[:, 1]] = newz
+        elif keep == 'below':
+            locmask = np.where((newz != -99999.) & (newz < self.array.data[ij[:, 0], ij[:, 1]]))
+            self.array.data[ij[locmask][:, 0], ij[locmask][:, 1]] = newz[locmask]
+        elif keep == 'above':
+            locmask = np.where((newz != -99999.) & (newz > self.array.data[ij[:, 0], ij[:, 1]]))
+            self.array.data[ij[locmask][:, 0], ij[locmask][:, 1]] = newz[locmask]
+
+    def interpolate_strictly_on_vertices(self, working_vector:vector, usemask=True, keep:Literal['all', 'below', 'above'] = 'all'):
+        """
+        Interpolation des mailles strictement sous une polyligne.
+
+        On utilise ensuite "interpolate" de shapely pour interpoler les altitudes des mailles
+        depuis les vertices 3D de la polyligne
+        """
+
+        vecls = working_vector.linestring
+        xy = self.get_xy_strictly_on_vertices(working_vector, usemask=usemask)
+        if xy.shape[0] == 0:
+            logging.debug(_('No points to interpolate'))
+            return
+        ij = np.asarray([self.get_ij_from_xy(x, y) for x, y in xy])
+        newz = np.asarray([vecls.interpolate(vecls.project(Point(x, y))).z for x, y in xy])
+
+        if keep == 'all':
+            self.array.data[ij[:, 0], ij[:, 1]] = newz
+        elif keep == 'below':
+            locmask = np.where((newz != -99999.) & (newz < self.array.data[ij[:, 0], ij[:, 1]]))
+            self.array.data[ij[locmask][:, 0], ij[locmask][:, 1]] = newz[locmask]
+        elif keep == 'above':
+            locmask = np.where((newz != -99999.) & (newz > self.array.data[ij[:, 0], ij[:, 1]]))
+            self.array.data[ij[locmask][:, 0], ij[locmask][:, 1]] = newz[locmask]
+
     def interpolate_on_polyline(self, working_vector:vector, usemask=True):
         """
         Interpolation sous une polyligne
@@ -7889,8 +7960,9 @@ class WolfArray(Element_To_Draw, header_wolf):
     def interpolate_on_triangulation(self, coords, triangles,
                                      grid_x=None, grid_y = None,
                                      mask_tri=None,
-                                     interp_method:Literal['matplotlib','scipy'] = 'matplotlib',
-                                     keep:Literal['all', 'below', 'above'] = 'all'):
+                                     interp_method:Literal['matplotlib','scipy'] = 'scipy',
+                                     keep:Literal['all', 'below', 'above'] = 'all',
+                                     points_along_edges:bool = True):
         """
         Interpolation sur une triangulation.
 
@@ -7898,7 +7970,7 @@ class WolfArray(Element_To_Draw, header_wolf):
           - uniquement dans les mailles sélectionnées si elles existent
           - dans les mailles contenues dans la triangulation sinon
 
-        Matplotlib is used by default, but Scipy(griddata) can be used as well. If Matplotlib crashes, try with Scipy.
+        Scipy(griddata) is used by default (more robust), but Matplotlib can be used as well (more strict). If Matplotlib crashes, try with Scipy.
 
         **Matplotlib is more strict on the quality of the triangulation.**
 
@@ -8205,6 +8277,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                 #on force les valeurs masquées à nullvalue afin que l'interpolation n'applique pas ses effets dans cette zone
                 self.array.data[self.array.mask]= self.nullvalue
             except:
+                logging.error(_('Bad triangulation - We will try with Scipy'))
                 use_scipy=True
 
         if interp_method != 'matplotlib' or use_scipy:
@@ -8216,8 +8289,15 @@ class WolfArray(Element_To_Draw, header_wolf):
                     curvec.add_vertex(wolfvertex(coords[curpt,0], coords[curpt,1], coords[curpt,2]))
                 curvec.close_force()
 
+                # if bool(np.isnan(curvec.x).any() or np.isnan(curvec.y).any()):
+                #     continue
                 self.interpolate_on_polygon(curvec, "linear", keep)
 
+                if points_along_edges:
+                    # Test points along edges
+                    self.interpolate_strictly_on_polyline(curvec, usemask=True, keep=keep)
+                    # self.interpolate_strictly_on_vertices(curvec, usemask=True, keep=keep)
+
         self.reset_plot()
         return
 
@@ -9003,7 +9083,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.mask_reset()
 
     def interpolation2D(self, key:str='1'):
-        """ Interpolation 2D basde on selected points in key 1 """
+        """ Interpolation 2D based on selected points in key 1 """
 
         #FIXME : auhtorize interpolation on other keys
 
@@ -9576,6 +9656,113 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif method == 'rasterio':
             return self.get_xy_inside_polygon_rasterio(myvect, usemask)
 
+    def get_xy_strictly_on_borders(self, myvect: vector | Polygon | LineString, usemask:bool=True,
+                                  method:Literal['shapely']='shapely'):
+        """
+        Return the coordinates strictly on the borders of a polygon.
+
+        ATTENTION : Tests are performed numerically, so the results may not be exact
+        in the sense of pure geometry.
+
+        Do not confuse with "get_xy_under_polyline" which
+        "rasterize" the polyline to find useful coordinates.
+
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
+        :param method: method to use ('shapely' for now)
+        """
+
+        # As we will use Shapely(contains) to test if points are on the border,
+        # we need to use a Linestring or a Polygon.boundary.
+        if isinstance(myvect, vector):
+            myvect.find_minmax()
+            boundary = myvect.linestring
+        elif isinstance(myvect, Polygon):
+            boundary = myvect.boundary
+        elif isinstance(myvect, LineString):
+            boundary = myvect
+
+        if not is_prepared(boundary):
+            prepare(boundary) # Prepare the polygon for **faster** contains check -- VERY IMPORTANT
+            to_destroy = True
+        else:
+            to_destroy = False
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect)
+
+        points= np.array([Point(x,y) for x,y in mypointsxy])
+        on_border = list(map(lambda point: boundary.contains(point), points))
+
+        if to_destroy:
+            destroy_prepared(boundary) # Destroy the prepared polygon
+
+        to_keep = np.where(on_border)
+        mypointsxy = mypointsxy[to_keep]
+
+        if mypointsxy.shape[0] == 0:
+            return mypointsxy
+
+        if usemask:
+            mypointsij = mypointsij[to_keep]
+            mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
+            mypointsxy = mypointsxy[np.where(mymask)]
+
+        return mypointsxy
+
+    def get_xy_strictly_on_vertices(self, myvect: vector | Polygon | LineString, usemask:bool=True,
+                                  method:Literal['shapely']='shapely', eps:float = 1.e-4):
+        """
+        Return the coordinates strictly on the vertices of a polygon, Linestring or vector.
+
+        ATTENTION : Tests are performed numerically, so the results may not be exact
+        in the sense of pure geometry.
+
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
+        :param method: method to use ('shapely' for now)
+        """
+
+        # As we will use Shapely(contains) to test if points are on the border,
+        # we need to use a Linestring or a Polygon.boundary.
+        if isinstance(myvect, vector):
+            myvect.find_minmax()
+            boundary = myvect.linestring
+        elif isinstance(myvect, Polygon):
+            boundary = myvect.boundary
+        elif isinstance(myvect, LineString):
+            boundary = myvect
+
+        if not is_prepared(boundary):
+            prepare(boundary) # Prepare the polygon for **faster** contains check -- VERY IMPORTANT
+            to_destroy = True
+        else:
+            to_destroy = False
+
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect)
+
+        # Calculate distances to the vertices
+        # We use the vertices of the polygon or linestring to check if points are on the
+        # vertices.
+
+        points      = np.array([Point(x,y) for x,y in mypointsxy])
+        vertices    = [Point(pt[0], pt[1], pt[2]) for pt in boundary.coords]
+        on_vertices = list(map(lambda point: any(vert.distance(point) < eps for vert in vertices), points))
+
+        if to_destroy:
+            destroy_prepared(boundary) # Destroy the prepared polygon
+
+        to_keep = np.where(on_vertices)
+        mypointsxy = mypointsxy[to_keep]
+
+        if mypointsxy.shape[0] == 0:
+            return mypointsxy
+
+        if usemask:
+            mypointsij = mypointsij[to_keep]
+            mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
+            mypointsxy = mypointsxy[np.where(mymask)]
+
+        return mypointsxy
+
     def get_xy_inside_polygon_mpl(self, myvect: vector | Polygon, usemask:bool=True):
         """
         Return the coordinates inside a polygon
@@ -9641,10 +9828,14 @@ class WolfArray(Element_To_Draw, header_wolf):
         if to_destroy:
             destroy_prepared(polygon) # Destroy the prepared polygon
 
-        mypointsxy = mypointsxy[np.where(inside)]
+        to_keep = np.where(inside)
+        mypointsxy = mypointsxy[to_keep]
+
+        if mypointsxy.shape[0] == 0:
+            return mypointsxy
 
         if usemask:
-            mypointsij = mypointsij[np.where(inside)]
+            mypointsij = mypointsij[to_keep]
             mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
             mypointsxy = mypointsxy[np.where(mymask)]
 
@@ -9710,6 +9901,33 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif method == 'rasterio':
             return self._get_ij_inside_polygon_rasterio(myvect, usemask, eps)
 
+
+    def get_ij_inside_listofpolygons(self, myvects: list[vector | Polygon],
+                                        usemask:bool=True, eps:float = 0.,
+                                        method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict'):
+        """
+        Return the indices inside a list of polygons
+        :param myvects: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
+        :param eps: epsilon for the intersection
+        """
+        if isinstance(myvects, zone):
+            myvects = myvects.myvectors
+
+        alls = list(map(lambda vec: self.get_ij_inside_polygon(vec, usemask, method=method), myvects))
+        #remove empty arrays
+        alls = [cur for cur in alls if cur.shape[0] > 0]
+        if len(alls) == 0:
+            return np.empty((0, 2), dtype=int)
+        # Concatenate all arrays
+        mypointsij = np.concatenate(alls, axis=0)
+        # Remove duplicates
+        mypointsij = np.unique(mypointsij, axis=0)
+        if mypointsij.shape[0] == 0:
+            return np.empty((0, 2), dtype=int)
+        return mypointsij
+
+
     def get_ij_inside_polygon_mpl(self, myvect: vector | Polygon, usemask:bool=True, eps:float = 0.):
         """
         Return the indices inside a polygon
@@ -11683,16 +11901,16 @@ class WolfArray(Element_To_Draw, header_wolf):
                 try:
                     bounds = self.get_bounds()
 
-                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    scale_covery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
 
-                    if scale_xovery > 1.:
+                    if scale_covery > 1.:
                         # x is larger than y
                         w = 2000
-                        h = int(2000 / scale_xovery)
+                        h = int(2000 / scale_covery)
                     else:
                         # y is larger than x
                         h = 2000
-                        w = int(2000 * scale_xovery)
+                        w = int(2000 * scale_covery)
 
                     IO_image = getWalonmap(cat, bounds[0][0], bounds[1][0],
                                         bounds[0][1], bounds[1][1],
@@ -11716,15 +11934,15 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 try:
                     bounds = self.get_bounds()
-                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
-                    if scale_xovery > 1.:
+                    scale_covery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    if scale_covery > 1.:
                         # x is larger than y
                         w = 2000
-                        h = int(2000 / scale_xovery)
+                        h = int(2000 / scale_covery)
                     else:
                         # y is larger than x
                         h = 2000
-                        w = int(2000 * scale_xovery)
+                        w = int(2000 * scale_covery)
                     IO_image = getNGI(cat, bounds[0][0], bounds[1][0],
                                     bounds[0][1], bounds[1][1],
                                         w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
@@ -11744,15 +11962,15 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 try:
                     bounds = self.get_bounds()
-                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
-                    if scale_xovery > 1.:
+                    scale_covery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    if scale_covery > 1.:
                         # x is larger than y
                         w = 2000
-                        h = int(2000 / scale_xovery)
+                        h = int(2000 / scale_covery)
                     else:
                         # y is larger than x
                         h = 2000
-                        w = int(2000 * scale_xovery)
+                        w = int(2000 * scale_covery)
                     IO_image = getCartoweb(cat, bounds[0][0], bounds[1][0],
                                             bounds[0][1], bounds[1][1],
                                             w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
@@ -11779,8 +11997,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                                    self.origx + self.dx * self.nbx,
                                    self.origy,
                                    self.origy + self.dy * self.nby),
-                            alpha=np.select([self.array.mask.T, ~self.array.mask.T],
-                                            [np.zeros(self.shape).T, np.ones(self.shape).T]))
+                           alpha=np.select([self.array.mask.T, ~self.array.mask.T],
+                                            [np.zeros(self.shape).T, np.ones(self.shape).T * self.alpha]))
 
             if with_legend:
                 # add a legend in a new axis
@@ -11809,7 +12027,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                                    self.origy + self.dy * self.nby),
                            vmin=vmin, vmax=vmax,
                            alpha=np.select([self.array.mask.T, ~self.array.mask.T],
-                                           [np.zeros(self.shape).T, np.ones(self.shape).T])                           )
+                                           [np.zeros(self.shape).T, np.ones(self.shape).T * self.alpha]))
 
 
             if with_legend:

{wolfhece-2.2.43.dist-info → wolfhece-2.2.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.43
+Version: 2.2.45
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece
@@ -73,7 +73,7 @@ Requires-Dist: tabulate
 Requires-Dist: ipympl
 Requires-Dist: contextily
 Requires-Dist: pefile
-Requires-Dist: wolfpydike
+Requires-Dist: wolfpydike==0.1.3
 Requires-Dist: PyMuPDF
 Requires-Dist: eccodes
 Requires-Dist: dataframe_image

{wolfhece-2.2.43.dist-info → wolfhece-2.2.45.dist-info}/RECORD

@@ -1,15 +1,16 @@
+wolfhece/ChatwWOLF.py,sha256=B7MkwZiLYjR3OUNBcTIxDnYZzOBFDe52k880KTLUotc,10135
 wolfhece/Coordinates_operations.py,sha256=DSkzJ1Rm4y89I9tuyyAA9mp-EHp9vl5w2qGpNJ-e9qs,8215
 wolfhece/CpGrid.py,sha256=_piG1u-ua7NzWh_PHJYTmxuPJ43ZfeYKNEQgZIJwDJ8,10660
 wolfhece/GraphNotebook.py,sha256=_VZfakR5eXBZE-4Ztv2n12ZDO8zESoeDfCz_9k__T20,31509
 wolfhece/GraphProfile.py,sha256=PhdgRIt7jHWEM_msnVysk18-JpS1f55tnfJzq7fDTfM,69676
 wolfhece/Lidar2002.py,sha256=bX-nIzdpjD7rOfEgJpTeaW6rIdAXwDp_z4YTM9CgANY,6068
 wolfhece/ManageParams.py,sha256=EeuUI5Vvh9ixCvYf8YShMC1s1Yacc7OxOCN7q81gqiQ,517
-wolfhece/Model1D.py,sha256=snEmu8Uj2YGcp1ybPnly-4A389XRnuOujGduqInNcgw,477001
+wolfhece/Model1D.py,sha256=-2ibQLscVUsXlcnJWixCIScrBPqJ9BTirmwtGXEKI-4,571155
 wolfhece/MulticriteriAnalysis.py,sha256=vGmkzYagZohNe0XjwGJ6VUXcDPjOt80lNFthXpzxCF0,59572
 wolfhece/PandasGrid.py,sha256=etfVhIHzja4Z1EUY6BcDOKX-w7V-Xou1yaf0NMqmclo,4599
 wolfhece/PyConfig.py,sha256=13DDWjJdohYHwn1uRVHB0s8Jcwq_b9pwcwbAr8NlZyc,19667
-wolfhece/PyCrosssections.py,sha256=6K9xhupnIVXzLdsLTPN9e1v0xck9BdWZd0-EgpWg9us,133277
-wolfhece/PyDraw.py,sha256=jCXBonWGmqTQD9AXsii-yalFpUFLKTrfPP2wzh-57NE,741859
+wolfhece/PyCrosssections.py,sha256=tVAlYJjCjmaVzP2YFSmWX_0aJ3v9O2sh2O6NBgmUaww,176430
+wolfhece/PyDraw.py,sha256=a94Y827cyvjfDX76-k6qnITHVUVGqJ65jHD3z6qetm0,744062
 wolfhece/PyGui.py,sha256=GpVRxNpR8WNDFyHnDvhtHFFsq_cZZlyVgSkFiS-ARYI,185342
 wolfhece/PyGuiHydrology.py,sha256=dmBlRO8AljsvCPH6eVt0l9ZLx7g5j7Ubl9Srk7ECwyA,34693
 wolfhece/PyHydrographs.py,sha256=1P5XAURNqCvtSsMQXhOn1ihjTpr725sRsZdlCEhhk6M,3730
@@ -18,23 +19,23 @@ wolfhece/PyParams.py,sha256=900BIaS7hzFwddsrpowWshf5kjQJKYVhnFykMVTlRSM,102063
 wolfhece/PyPictures.py,sha256=qcKwyCmZA0V7Kcr1FiLmcMlVhX0BgIZsJawAIKt8qt4,18932
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=0KUzHc4ozuiZKuej6Xx4lyzE7vFOKeBO5dGk-K5LtHo,51893
-wolfhece/PyVertexvectors.py,sha256=HaOCora21-foEP0qYQbK-GqirYgiql8qd719xL-oilw,378066
+wolfhece/PyVertexvectors.py,sha256=vDY_ZBCM70n_PT7C5nXpoN0sAkY2soazPFiFOWKABS8,379402
 wolfhece/PyWMS.py,sha256=MOOikPo-jZv1oPUruGv6XR_Pn_W3h-eNBeRgi_pRNOc,32031
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
-wolfhece/RatingCurve_xml.py,sha256=cUjReVMHFKtakA2wVey5zz6lCgHlSr72y7ZfswZDvTM,33891
+wolfhece/RatingCurve_xml.py,sha256=XOzkCozGFVq5X7m_1lBJnv7Qwd307BFTyi_nCQ9PYx8,34395
 wolfhece/ReadDataDCENN.py,sha256=vm-I4YMryvRldjXTvRYEUCxZsjb_tM7U9yj6OaPyD0k,1538
 wolfhece/Results2DGPU.py,sha256=ljMEKHGMbmIAZE6UmMmYDMFqFAwjzxxVUmZdHHb6aME,32106
 wolfhece/__init__.py,sha256=bh5zzt90fGJcc97d0DiuZsV9VxwBEy9HUBfexHmQDJk,1978
 wolfhece/_add_path.py,sha256=mAyu85CQHk0KgUI6ZizweeQiw1Gdyea9OEjGLC6lLA4,916
-wolfhece/analyze_poly.py,sha256=LewmoMSCAr_5zTeqKR0C1eWwjWh7zPjsSdsDyAV-yuk,60874
+wolfhece/analyze_poly.py,sha256=pgZnAo_wBA5AcTgEueEoHF8kFE8X-2iqEmWuPXNNUTg,69307
 wolfhece/analyze_vect.py,sha256=3lkMwaQ4KRddBVRvlP9PcM66wZwwC0eCmypP91AW-os,6015
 wolfhece/cli.py,sha256=h1tSMHALiftktreyugKcjbASXfpJUm9UYMeVxR-MtG4,6424
 wolfhece/color_constants.py,sha256=Snc5RX11Ydi756EkBp_83C7DiAQ_Z1aHD9jFIBsosAU,37121
 wolfhece/compare_series.py,sha256=M8Xce8vexq3KyVoN-de7pcgCVW0A16vrvlYZegfbwBM,17674
-wolfhece/dike.py,sha256=eG9EDCRk46Nlzpg5OycUeOag_T8joyJ2wzTkQgAT5F0,30710
+wolfhece/dike.py,sha256=virm26hYnamBOWtFPSBrO2n1z6TmjN5aTTC9te24Pc8,42364
 wolfhece/drawing_obj.py,sha256=O_K9xlsiPn305YS_2oWTlv3-rBuGiCkwWEcYAwlJRGs,4514
-wolfhece/eikonal.py,sha256=iDeDs571sVXGe4IsPSJ1Sa4hX8Ri2jWE7u83xzvA2K8,23189
+wolfhece/eikonal.py,sha256=mxFHJIVJq4pLCI5q1_NaX7Y56ZYk7BN5aqx4xtVsxvc,23291
 wolfhece/flow_SPWMI.py,sha256=XDAelwAY-3rYOR0WKW3fgYJ_r8DU4IP6Y5xULW421tk,20956
 wolfhece/friction_law.py,sha256=_VrcFm2E--RfOvGjsazL5Zve_p5fIhzsT62AElI5E04,5501
 wolfhece/gpuview.py,sha256=Jql8pLZ0PpvZ_ScT-U4jsXANZ9j4-m_RWhsLA2HISuQ,24544
@@ -67,7 +68,7 @@ wolfhece/textpillow.py,sha256=7hgfsLYAaE_rNKD-g8xsON8sdWvoV8vbqnGGxIayShE,14137
 wolfhece/tools2d_dll.py,sha256=TfvvmyZUqEZIH0uHwUCJf0bdmCks_AiidDt23Unsp5w,13550
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
 wolfhece/toolshydrology_dll.py,sha256=cIGyhxV8H5f7GXhDqAamM7uC0W0hQTou3eTkqZdnqBE,5656
-wolfhece/wolf_array.py,sha256=39O7kYjksEbCC2yn0mu6AfabmVrBWrmoybbfjw4gfIQ,578890
+wolfhece/wolf_array.py,sha256=Vd_9Sp6wjTF9diu9NUOeVymjZNfTnuymYWx280Nx210,588231
 wolfhece/wolf_hist.py,sha256=fTEb60Q4TEwobdZsRU4CFXAId1eOKdWAqF8lnF1xEWc,3590
 wolfhece/wolf_texture.py,sha256=Pt1j_lX74p70Fj3y3qYxYMuN8gghVd8_ih1vFhTIdkA,23884
 wolfhece/wolf_tiles.py,sha256=v-HohqaWuMYdn75XLnA22dlloAG90iwnIqrgnB0ASQ4,10488
@@ -95,7 +96,7 @@ wolfhece/apps/curvedigitizer.py,sha256=lEJJwgAfulrrWQc-U6ij6sj59hWN3SZl4Yu1kQxVz
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=EdGDN9NhudIiP7c3gVqj7dp4MWFB8ySizM_tpMnsgpE,3091
-wolfhece/apps/version.py,sha256=kWgIrbzo3PaJpeEetSvb9-zhutuO1cGL5wg1gqsJFDM,388
+wolfhece/apps/version.py,sha256=VmZdb3DGqah-YZlqUibhAku2wmsYYuTt_7l5Hcf0xf0,388
 wolfhece/apps/wolf.py,sha256=mRnjYsUu4KIsRuamdQWAINFMuwN4eJgMo9erG-hkZ70,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -320,8 +321,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=u4C7CXe_bUyGKx7c_Bi0x9
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.2.43.dist-info/METADATA,sha256=6-h2-a9g7o3Tg99jRn5s_izELlJ5gWaMZSPzG6SlW0A,2785
-wolfhece-2.2.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wolfhece-2.2.43.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
-wolfhece-2.2.43.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.43.dist-info/RECORD,,
+wolfhece-2.2.45.dist-info/METADATA,sha256=eV92Icaf_qIZmocjxaECy1zeighi9PKM0imSWbAUXDM,2792
+wolfhece-2.2.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wolfhece-2.2.45.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
+wolfhece-2.2.45.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.45.dist-info/RECORD,,