wolfhece 2.1.126__py3-none-any.whl → 2.1.128__py3-none-any.whl

wolfhece/hydrology/PyWatershed.py

@@ -81,7 +81,7 @@ class Node_Watershed:
             self.cums=0.
         else:
             self.cums = self.down.cums+self.incrs
-        for curup in self.up:            
+        for curup in self.up:
             curup.incr_curvi()
 
     def mean_slope_up(self, threshold:float)-> float:
@@ -139,7 +139,7 @@ class Node_Watershed:
         """ Distance euclidienne """
 
         return np.sqrt(pow(self.x-x,2)+pow(self.y-y,2))
-    
+
     def get_up_nodes(self, excluded_node:list["Node_Watershed"]=[]):
         """
         Get all upstream nodes
@@ -148,7 +148,7 @@ class Node_Watershed:
         all_up = [self]
         all_rivers = [self] if self.river else []
         all_runoff = [] if self.river else [self]
-        
+
         for curup in self.up:
 
             if curup in excluded_node:
@@ -164,7 +164,7 @@ class Node_Watershed:
             all_up.extend(up)
             all_rivers.extend(river)
             all_runoff.extend(runoff)
-        
+
         return all_up, all_rivers, all_runoff
 
     def get_up_nodes_same_sub(self, excluded_node:list["Node_Watershed"]=[]):
@@ -175,7 +175,7 @@ class Node_Watershed:
         all_up = [self]
         all_rivers = [self] if self.river else []
         all_runoff = [] if self.river else [self]
-        
+
         for curup in self.up:
 
             if curup in excluded_node:
@@ -185,7 +185,7 @@ class Node_Watershed:
             if curup.sub == self.sub:
                 all_up.append(curup)
                 added = True
-            
+
             if curup.river:
                 all_rivers.append(curup)
             else:
@@ -196,9 +196,9 @@ class Node_Watershed:
                 all_up.extend(up)
                 all_rivers.extend(river)
                 all_runoff.extend(runoff)
-        
+
         return all_up, all_rivers, all_runoff
-    
+
     def get_up_runoff_nodes(self):
         """
         Get all upstream runoff nodes
@@ -208,9 +208,9 @@ class Node_Watershed:
         for curup in self.up:
             if not curup.river:
                 all_up += curup.get_up_runoff_nodes()
-        
+
         return all_up
-    
+
     def get_up_runoff_nodes_same_sub(self):
         """
         Get all upstream runoff nodes in the same sub-basin
@@ -220,10 +220,10 @@ class Node_Watershed:
         for curup in self.up:
             if curup.sub == self.sub and not curup.river:
                 all_up += curup.get_up_runoff_nodes_same_sub()
-        
+
         return all_up
 
-    
+
     def get_up_rivernodes(self):
         """
         Get all upstream river nodes
@@ -232,9 +232,9 @@ class Node_Watershed:
         all_up = [self]
         for curup in self.upriver:
             all_up += curup.get_up_rivernodes()
-        
+
         return all_up
-    
+
     def get_up_rivernodes_same_sub(self):
         """
         Get all upstream river nodes in the same sub-basin
@@ -244,9 +244,9 @@ class Node_Watershed:
         for curup in self.upriver:
             if curup.sub == self.sub:
                 all_up += curup.get_up_rivernodes_same_sub()
-        
+
         return all_up
-    
+
     def get_up_reaches_same_sub(self) -> list[int]:
         """
         Get all upstream reaches in the same sub-basin
@@ -258,7 +258,7 @@ class Node_Watershed:
                 all_up += curup.get_up_reaches_same_sub()
 
         return np.unique(all_up).tolist()
-    
+
     def get_down_reaches_same_sub(self) -> list[int]:
         """
         Get all downstream reaches in the same sub-basin
@@ -269,7 +269,7 @@ class Node_Watershed:
             if self.down.sub == self.sub:
                 all_down += self.down.get_down_reaches_same_sub()
 
-        return np.unique(all_down).tolist() 
+        return np.unique(all_down).tolist()
 
     def get_down_nodes(self):
         """
@@ -279,7 +279,7 @@ class Node_Watershed:
         all_down = [self]
         if self.down is not None:
             all_down += self.down.get_down_nodes()
-        
+
         return all_down
 
     def get_down_nodes_same_sub(self):
@@ -291,7 +291,7 @@ class Node_Watershed:
         if self.down is not None:
             if self.down.sub == self.sub:
                 all_down += self.down.get_down_nodes_same_sub()
-        
+
         return all_down
 
 class RiverSystem:
@@ -390,11 +390,11 @@ class RiverSystem:
 
         return
         """
-        
+
         if isinstance(xy, vector):
-            centroid = xy.asshapely_pol().centroid
+            centroid = xy.centroid
             xy = np.array([[centroid.x, centroid.y]])
-        
+
         dd, ii = self.kdtree.query(xy, nb)
 
         if isinstance(ii, int | np.int64):
@@ -404,7 +404,7 @@ class RiverSystem:
                 return dd[0], self.all_nodes[ii[0]]
             else:
                 return dd, [self.all_nodes[curi] for curi in ii]
-    
+
     def get_nodes_in_reaches(self, reaches:list[int])->list[Node_Watershed]:
         """
         Get nodes in a reaches
@@ -412,23 +412,23 @@ class RiverSystem:
         all_nodes = []
         for cur_reach in reaches:
             all_nodes.extend(self.reaches['reaches'][cur_reach]['baselist'])
-        
+
         return all_nodes
-    
+
     def get_downstream_node_in_reach(self, reach:int)->Node_Watershed:
         """
         Get downstream node in a reach
         """
 
         return self.reaches['reaches'][reach]['baselist'][0]
-    
+
     def get_upstream_node_in_reach(self, reach:int)->Node_Watershed:
         """
         Get upstream node in a reach
         """
 
         return self.reaches['reaches'][reach]['baselist'][-1]
-    
+
     def get_downstream_reaches(self, node:Node_Watershed)->list[int]:
         """
         Get index of downstream reaches
@@ -441,7 +441,7 @@ class RiverSystem:
             curnode = curnode.down
 
         return list(np.unique(downreaches))
-    
+
     def get_kdtree_downstream(self, node:Node_Watershed)-> tuple[list[Node_Watershed], KDTree]:
         """
         Get KDTree of downstream reaches
@@ -449,7 +449,7 @@ class RiverSystem:
 
         downreaches = self.get_downstream_reaches(node)
         return self.get_kdtree_from_reaches(downreaches)
-    
+
     def get_kdtree_from_reaches(self, reaches:list[int])->tuple[list[Node_Watershed], KDTree]:
         """
         Get KDTree from a list of reaches
@@ -458,7 +458,7 @@ class RiverSystem:
         nodes = self.get_nodes_in_reaches(reaches)
         xy = [[curnode.x, curnode.y]  for curnode in nodes]
         return nodes, KDTree(xy)
-    
+
     def get_downstream_reaches_excluded(self, node:Node_Watershed, excluded:list[int])->list[int]:
         """
         Get index of downstream reaches, excepted the excluded ones
@@ -488,7 +488,7 @@ class RiverSystem:
                 curnode = curnode.down
 
         return curnode
-    
+
     def get_cums(self, whichreach:int=None, whichup:int=None):
         """
         Récupération de la position curvi
@@ -576,7 +576,7 @@ class RiverSystem:
 
         xy = [[curnode.x, curnode.y]  for curnode in self.upstreams['list']]
         return np.array(xy)
-    
+
     def get_nearest_upstream(self, xy:np.ndarray, nb:int) -> tuple[np.ndarray, list[Node_Watershed]]:
         """
         Recherche des amonts les plus proches
@@ -587,7 +587,7 @@ class RiverSystem:
         dd, ii =loc_kd.query(xy, nb)
 
         return dd, [self.upstreams['list'][curi] for curi in ii]
-    
+
     def create_index(self):
         """
         Incrément d'index depuis l'amont jusque l'exutoire final
@@ -1427,11 +1427,11 @@ class SubWatershed:
         self.name:str           = name # name of the subwatershed
         self.mask:WolfArray     = mask # WolfArray of the subwatershed -- All nodes are masked except the subwatershed
         self.mask.count()
-        
+
         self.nodes:list[Node_Watershed]  = nodes    # all nodes in the subwatershed
         self.rivers:list[Node_Watershed] = rivers   # only rivers - sorted by dem value --> outlet is the first one
         self.runoff:list[Node_Watershed] = runoff
-        
+
         self.idx_reaches = np.unique(np.asarray([x.reach for x in rivers]))
 
         self._index_sorted = idx
@@ -1444,23 +1444,23 @@ class SubWatershed:
         """ Vérification si le sous-bassin est virtuel """
 
         return self._is_virtual
-    
+
     @property
     def surface(self) -> float:
         """ Surface du bassin versant en m² """
         return self.mask.nbnotnull * self.mask.dx * self.mask.dy
-    
+
     @property
     def area(self) -> float:
         """ Surface du bassin versant en km² """
         return self.surface / 1.e6
-    
+
     @property
     def area_outlet(self) -> float:
         """ Surface du bassin à l'exutoire """
 
         return self.outlet.uparea
-    
+
     @property
     def outlet(self) -> Node_Watershed:
         """ Outlet of the subbasin """
@@ -1471,7 +1471,7 @@ class SubWatershed:
         """ Vérification si un bief est dans le sous-bassin """
 
         return idx_reach in self.idx_reaches
-    
+
     def is_in_rivers(self, node:Node_Watershed) -> bool:
         """ Vérification si un noeud est dans les rivières """
 
@@ -1483,36 +1483,36 @@ class SubWatershed:
         """
 
         return [x for x in self.rivers if x.reach==idx_reach]
-    
+
     def get_nearest_river(self, x, y) -> Node_Watershed:
         """
         Récupération du noeud de rivière le plus proche
         """
 
         return min(self.rivers, key=lambda x: x.distance(x,y))
-    
+
     def get_max_area_in_reach(self, idx_reach:int) -> float:
         """
         Récupération de la surface maximale dans un bief
         """
 
         return max([x.uparea for x in self.get_list_nodes_river(idx_reach)])
-        
+
     def get_min_area_in_reach(self, idx_reach:int) -> float:
         """
         Récupération de la surface minimale dans un bief
         """
 
         return min([x.uparea for x in self.get_list_nodes_river(idx_reach)])
-    
-    def get_min_area_along_reaches(self, reaches:list[int], starting_node:Node_Watershed = None) -> float:    
+
+    def get_min_area_along_reaches(self, reaches:list[int], starting_node:Node_Watershed = None) -> float:
         """ Aire drainée à la limite amont du ss-bassin """
-        
+
         if starting_node is None:
             starting_node = self.outlet
-        
+
         upriver = starting_node.upriver
-        
+
         area_min = []
 
         idx_reach = 0
@@ -1525,12 +1525,12 @@ class SubWatershed:
             return None
         else:
             return min(area_min)
-        
+
     def get_up_rivernode_outside_sub(self, starting_node:Node_Watershed, reaches:list[int]) -> Node_Watershed:
         """ Récupération du noeud de rivière en amont du sous-bassin """
-        
-        def up_in_reaches(node:Node_Watershed, reaches:list[int]) -> Node_Watershed:            
-        
+
+        def up_in_reaches(node:Node_Watershed, reaches:list[int]) -> Node_Watershed:
+
             if len(node.upriver) == 0:
                 # No upstream node
                 return node
@@ -1539,8 +1539,8 @@ class SubWatershed:
                 for curup in node.upriver:
                     if curup.reach in reaches:
                         # If the reach is in the list, return the node
-                        return curup        
-                
+                        return curup
+
                 # No node found in the list of reaches
                 return node
 
@@ -1559,20 +1559,20 @@ class SubWatershed:
 
     def get_area_outside_sub_if_exists(self, starting_node:Node_Watershed, reaches:list[int]) -> float:
         """ Aire drainée en amont du sous-bassin """
-        
+
         up_outside = self.get_up_rivernode_outside_sub(starting_node, reaches)
-        
+
         if up_outside is None:
             return 0.
         else:
-            return up_outside.uparea        
-    
+            return up_outside.uparea
+
     def get_river_nodes_from_upareas(self, min_area:float, max_area:float) -> list[Node_Watershed]:
         """
         Récupération des noeuds de rivière entre deux surfacesde BV.
 
         Les surfaces sont exprimées en km².
-        
+
         Les bornes sont incluses.
 
         :param min_area: surface minimale
@@ -1584,12 +1584,12 @@ class SubWatershed:
     def is_in_subwatershed(self, vec:vector) -> bool:
         """ Vérification si un vecteur est dans le sous-bassin """
 
-        centroid = vec.asshapely_pol().centroid
+        centroid = vec.centroid
 
         i, j = self.mask.get_ij_from_xy(centroid.x, centroid.y)
 
         return self.mask.array.mask[i,j] == False
-    
+
     def filter_zones(self, zones_to_filter:Zones, force_virtual_if_any:bool = False) -> list[vector]:
         """
         Filtrage des zones pour ne garder que celle se trouvant dans le sous-bassin
@@ -1599,7 +1599,7 @@ class SubWatershed:
             return self._src_sub.filter_zones(zones_to_filter)
 
         return [curvec for curzone in zones_to_filter.myzones for curvec in curzone.myvectors if self.is_in_subwatershed(curvec)]
-    
+
     def get_virtual_subwatershed(self, outlet:Node_Watershed, excluded_nodes:list[Node_Watershed] = []) -> "SubWatershed":
         """
         Création d'un sous-bassin virtuel sur base d'une maille rivière aval
@@ -1617,20 +1617,20 @@ class SubWatershed:
         for curnode in all:
             mymask.array.mask[curnode.i,curnode.j] = False
 
-        newsub = SubWatershed(self.parent, 
-                            self.name + '_virtual', 
-                            self.parent.nb_subs + 1, 
-                            mymask, 
+        newsub = SubWatershed(self.parent,
+                            self.name + '_virtual',
+                            self.parent.nb_subs + 1,
+                            mymask,
                             all,
                             runoff,
-                            river, 
+                            river,
                             )
-        
+
         newsub._is_virtual = True
         newsub._src_sub = self
-        
+
         return newsub
-    
+
     def get_downstream_node_in_reach(self, reach:int) -> Node_Watershed:
         """
         Récupération du noeud aval dans un bief
@@ -1758,7 +1758,7 @@ class Watershed:
     @property
     def resolution(self):
         return self.header.dx
-    
+
     # def impose_sorted_index_subbasins(self, new_idx=list[int]):
     #     """
     #     Tri des sous-bassins
@@ -1776,7 +1776,7 @@ class Watershed:
             self.get_subwatershed(cursub).name  = curname
 
     def add_virtual_subwatershed(self, subwater:SubWatershed):
-        """     
+        """
         Ajout d'un sous-bassin virtuel
         """
 
@@ -1790,12 +1790,12 @@ class Watershed:
         """
 
         newsub = self.get_subwatershed(outlet.sub).get_virtual_subwatershed(outlet, excluded_nodes=excluded_nodes)
-        
+
         self.add_virtual_subwatershed(newsub)
 
         return newsub
 
-    def get_xy_downstream_node(self, 
+    def get_xy_downstream_node(self,
                                starting_node:Node_Watershed,
                                limit_to_sub:bool = False):
         """
@@ -1809,9 +1809,9 @@ class Watershed:
 
         return [[cur.x, cur.y] for cur in down]
 
-    def get_xy_upstream_node(self, 
-                             starting_node:Node_Watershed, 
-                             limit_to_sub:bool = False, 
+    def get_xy_upstream_node(self,
+                             starting_node:Node_Watershed,
+                             limit_to_sub:bool = False,
                              limit_to_river:bool = False,
                              limit_to_runoff:bool = False) -> list[list[float]]:
         """
@@ -1836,9 +1836,9 @@ class Watershed:
                 up, all_river, all_runoff = starting_node.get_up_nodes()
 
         return [[cur.x, cur.y] for cur in up]
-    
-    def get_array_from_upstream_node(self, 
-                                     starting_node:Node_Watershed, 
+
+    def get_array_from_upstream_node(self,
+                                     starting_node:Node_Watershed,
                                      limit_to_sub:bool = False):
         """
         Récupération de l'array à partir d'un noeud amont
@@ -1875,8 +1875,8 @@ class Watershed:
         newarray.mask_data(0.)
 
         return newarray
-    
-    def get_vector_from_upstream_node(self, 
+
+    def get_vector_from_upstream_node(self,
                                       starting_node:Node_Watershed,
                                       limit_to_sub:bool = False):
         """ Return a vector contouring the upstream area """
@@ -1895,29 +1895,29 @@ class Watershed:
         """
         Récupération d'un sous-bassin sur base de l'index trié
         """
-        
+
         if isinstance(idx_sorted_or_name, str):
             for cur_sub in self.subcatchments:
                 if cur_sub.name == idx_sorted_or_name:
                     return cur_sub
-                
+
             if len(self.virtualcatchments)>0:
                 for cur_sub in self.virtualcatchments:
                     if cur_sub.name == idx_sorted_or_name:
                         return cur_sub
-                        
-        elif isinstance(idx_sorted_or_name, int):        
+
+        elif isinstance(idx_sorted_or_name, int):
             for cur_sub in self.subcatchments:
                 if cur_sub._index_sorted+1 == idx_sorted_or_name:
-                    return cur_sub   
-                
+                    return cur_sub
+
             if len(self.virtualcatchments)>0:
                 for cur_sub in self.virtualcatchments:
                     if cur_sub._index_sorted+1 == idx_sorted_or_name:
                         return cur_sub
         else:
             logging.error(_('Index must be an integer or a string!'))
-        
+
         return None
 
     def get_node_from_ij(self, i:int,j:int):
@@ -2657,7 +2657,7 @@ class Watershed:
         idx_sub = self.subs_array.array[i,j]
 
         return self.subcatchments[idx_sub-1]
-    
+
     def get_subwatershed_from_xy(self, x:float, y:float) -> SubWatershed:
         """
         Récupération d'un sous-bassin sur base des coordonnées (x,y)
@@ -2667,7 +2667,7 @@ class Watershed:
 
         i,j = self.header.get_ij_from_xy(x,y)
         return self.get_subwatershed_from_ij(i,j)
-    
+
     def get_subwatershed_from_vector(self, vec:vector) -> tuple[SubWatershed, bool, list[SubWatershed]]:
         """
         Récupération d'un sous-bassin sur base d'un vecteur.
@@ -2679,7 +2679,7 @@ class Watershed:
         :return: tuple(SubWatershed, bool, list[SubWatershed]) : sous-bassin, entièrement dans le sous-bassin, autres sous-bassins
         """
 
-        centroid = vec.asshapely_pol().centroid
+        centroid = vec.centroid
 
         sub = self.get_subwatershed_from_xy(centroid.x, centroid.y)