wolfhece 2.1.16__py3-none-any.whl → 2.1.18__py3-none-any.whl

wolfhece/hydrology/PyWatershed.py

@@ -130,6 +130,33 @@ class Node_Watershed:
 
         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
+        """
+
+        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:
+                continue
+
+            all_up.append(curup)
+            if curup.river:
+                all_rivers.append(curup)
+            else:
+                all_runoff.append(curup)
+
+            up, river, runoff = curup.get_up_nodes(excluded_node)
+            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"]=[]):
         """
         Get all upstream nodes in the same sub-basin
@@ -162,30 +189,50 @@ class Node_Watershed:
         
         return all_up, all_rivers, all_runoff
     
+    def get_up_runoff_nodes(self):
+        """
+        Get all upstream runoff nodes
+        """
+
+        all_up = [self]
+        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
         """
 
-        all_up = []
+        all_up = [self]
         for curup in self.up:
             if curup.sub == self.sub and not curup.river:
-                all_up.append(curup)
-
                 all_up += curup.get_up_runoff_nodes_same_sub()
         
         return all_up
 
+    
+    def get_up_rivernodes(self):
+        """
+        Get all upstream river nodes
+        """
+
+        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
         """
 
-        all_up = []
+        all_up = [self]
         for curup in self.upriver:
             if curup.sub == self.sub:
-                all_up.append(curup)
-
                 all_up += curup.get_up_rivernodes_same_sub()
         
         return all_up
@@ -214,6 +261,28 @@ class Node_Watershed:
 
         return np.unique(all_down).tolist() 
 
+    def get_down_nodes(self):
+        """
+        Get all downstream nodes
+        """
+
+        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):
+        """
+        Get all downstream nodes in the same sub-basin
+        """
+
+        all_down = [self]
+        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:
     """
@@ -1716,6 +1785,102 @@ class Watershed:
 
         return newsub
 
+    def get_xy_downstream_node(self, 
+                               starting_node:Node_Watershed,
+                               limit_to_sub:bool = False):
+        """
+        Récupération des coordonnées du noeud aval
+        """
+
+        if limit_to_sub:
+            down = starting_node.get_down_nodes_same_sub()
+        else:
+            down = starting_node.get_down_nodes()
+
+        return [[cur.x, cur.y] for cur in down]
+
+    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]]:
+        """
+        Récupération des coordonnées des noeuds amont
+        """
+
+        if limit_to_sub:
+
+            if limit_to_river:
+                up = starting_node.get_up_rivernodes_same_sub()
+            elif limit_to_runoff:
+                up = starting_node.get_up_runoff_nodes_same_sub()
+            else:
+                up, all_river, all_runoff = starting_node.get_up_nodes_same_sub()
+
+        else:
+            if limit_to_river:
+                up = starting_node.get_up_rivernodes()
+            elif limit_to_runoff:
+                up = starting_node.get_up_runoff_nodes()
+            else:
+                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, 
+                                     limit_to_sub:bool = False):
+        """
+        Récupération de l'array à partir d'un noeud amont
+        """
+
+        up = self.get_xy_upstream_node(starting_node, limit_to_sub=limit_to_sub)
+
+        xmin = min([x[0] for x in up])
+        xmax = max([x[0] for x in up])
+        ymin = min([x[1] for x in up])
+        ymax = max([x[1] for x in up])
+
+        newhead = header_wolf()
+        newhead.dx = self.header.dx
+        newhead.dy = self.header.dy
+
+        newhead.origx = xmin - self.header.dx/2. - self.header.dx
+        newhead.origy = ymin - self.header.dy/2. - self.header.dy
+
+        newhead.nbx = int(np.ceil((xmax - xmin) / self.header.dx) + 3)
+        newhead.nby = int(np.ceil((ymax - ymin) / self.header.dy) + 3)
+
+        if newhead.nbx == 0 or newhead.nby == 0:
+            logging.error(_('No upstream nodes found!'))
+            return None
+
+        newarray = WolfArray(srcheader=newhead)
+        newarray.array[:,:] = 0.
+
+        ij = newhead.xy2ij_np(up)
+
+        newarray.array[ij[:,0], ij[:,1]] = 1.
+
+        newarray.mask_data(0.)
+
+        return newarray
+    
+    def get_vector_from_upstream_node(self, 
+                                      starting_node:Node_Watershed,
+                                      limit_to_sub:bool = False):
+        """ Return a vector contouring the upstream area """
+
+        up_array = self.get_array_from_upstream_node(starting_node, limit_to_sub=limit_to_sub)
+
+        if up_array is None:
+            return None
+
+        __, __, vect, __ = up_array.suxsuy_contour()
+
+        vect.find_minmax()
+        return vect
+
     def get_subwatershed(self, idx_sorted_or_name:int | str) -> SubWatershed:
         """
         Récupération d'un sous-bassin sur base de l'index trié

wolfhece/wolf_array.py

@@ -357,12 +357,23 @@ class header_wolf():
         :return : numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)
         """
 
-        locxy = xy.copy()
+        if isinstance(xy,tuple):
+            if len(xy) == 2:
+                if (isinstance(xy[0],np.ndarray)) and (isinstance(xy[1],np.ndarray)):
+                    if len(xy[0]) == len(xy[1]):
+                        locxy = np.vstack((xy[0], xy[1])).T
+                        logging.warning(_('get_ij_from_xy_array - xy is a tuple of 2 arrays, it is converted to a 2D array'))
+            else:
+                locxy = np.array(xy)
+        elif isinstance(xy,list):
+            locxy = np.array(xy)
+        else:
+            locxy = xy.copy()
 
         if forcedims2:
-            locij = np.zeros((xy.shape[0],2), dtype=np.int32)
+            locij = np.zeros((locxy.shape[0],2), dtype=np.int32)
         else:
-            locij = np.zeros(xy.shape, dtype=np.int32)
+            locij = np.zeros(locxy.shape, dtype=np.int32)
 
         locxy[:,0] -= self.origx
         locxy[:,1] -= self.origy
@@ -446,7 +457,7 @@ class header_wolf():
         """
         Converts array coordinates (numpy cells) to this array's world coodinates.
 
-        :param ij = numpy array containing (i, j, [k]) indices
+        :param ij = numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)
         :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)
@@ -464,7 +475,18 @@ class header_wolf():
                     if len(ij[0]) == len(ij[1]):
                         ij = np.vstack((ij[0], ij[1])).T
                         logging.warning(_('get_xy_from_ij_array - ij is a tuple of 2 arrays, it is converted to a 2D array'))
-
+            else:
+                ij = np.array(ij)
+        
+        elif isinstance(ij,list):
+            if len(ij) == 2:
+                if (isinstance(ij[0],np.ndarray)) and (isinstance(ij[1],np.ndarray)):
+                    if len(ij[0]) == len(ij[1]):
+                        ij = np.vstack((ij[0], ij[1])).T
+                        logging.warning(_('get_xy_from_ij_array - ij is a list of 2 arrays, it is converted to a 2D array'))
+            else:
+                ij = np.array(ij)
+            
         if abs:
             tr_x = self.translx
             tr_y = self.transly
@@ -529,7 +551,7 @@ class header_wolf():
 
         :return : numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)
         """
-        return self.get_xy_from_ij_array(xy, scale, aswolf, abs)
+        return self.get_ij_from_xy_array(xy, scale, aswolf, abs)
 
     def xyz2ijk_np(self, xyz:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
         """ alias for get_xy_from_ij_array """
@@ -627,6 +649,49 @@ class header_wolf():
             filename = str(filename)
 
         if filename.endswith('.tif'):
+            from osgeo import gdal
+            
+            raster:gdal.Dataset
+            raster = gdal.Open(filename)
+            geotr = raster.GetGeoTransform()
+            self.dx = geotr[1]
+            self.dy = abs(geotr[5])
+            self.origx = geotr[0]
+            self.origy = geotr[3]
+            self.nbx = raster.RasterXSize
+            self.nby = raster.RasterYSize
+
+            """
+            https://docs.qgis.org/3.34/en/docs/user_manual/processing_algs/gdal/rasterconversion.html
+
+            0 — Use Input Layer Data Type
+            1 — Byte (Eight bit unsigned integer (quint8))
+            2 — Int16 (Sixteen bit signed integer (qint16))
+            3 — UInt16 (Sixteen bit unsigned integer (quint16))
+            4 — UInt32 (Thirty two bit unsigned integer (quint32))
+            5 — Int32 (Thirty two bit signed integer (qint32))
+            6 — Float32 (Thirty two bit floating point (float))
+            7 — Float64 (Sixty four bit floating point (double))
+            8 — CInt16 (Complex Int16)
+            9 — CInt32 (Complex Int32)
+            10 — CFloat32 (Complex Float32)
+            11 — CFloat64 (Complex Float64)
+            12 — Int8 (Eight bit signed integer (qint8))
+            """
+
+            dtype = raster.GetRasterBand(1).DataType
+
+            if dtype in [1, 4]:
+                self.wolftype = WOLF_ARRAY_FULL_INTEGER
+            elif dtype ==6:
+                self.wolftype = WOLF_ARRAY_FULL_SINGLE
+            elif dtype == 7:
+                self.wolftype = WOLF_ARRAY_FULL_DOUBLE
+            else:
+                logging.error(_('The datatype of the raster is not supported -- {}'.format(dtype)))
+                logging.error(_('Please convert the raster to a supported datatype - or upgrade the code to support this datatype'))
+                logging.error(_('See : read_txt_header and import_geotif in wolf_array.py'))
+                return
             return
 
         if filename.endswith('.flt'):
@@ -1192,8 +1257,10 @@ class Ops_Array(wx.Frame):
         self.vectmp = vector(name='tmp')
         self.fnsave = ''
 
-        self.myzonetmp.add_vector(self.vectmp)
-        self.myzones.add_zone(self.myzonetmp)
+        self.myzonetmp.add_vector(self.vectmp, forceparent=True)
+        self.myzones.add_zone(self.myzonetmp, forceparent=True)
+
+        self.myzones.mapviewer = mapviewer
 
         if self.wx_exists:
             self.set_GUI()
@@ -2123,14 +2190,22 @@ class Ops_Array(wx.Frame):
     def OnManageVectors(self, event:wx.MouseEvent):
         """ Open vector manager  """
 
+        self.show_structure_OpsVectors()
+
+    def show_structure_OpsVectors(self):
+        """ Show the structure of the vector manager """
+
         if self.mapviewer is not None:
             if self.mapviewer.linked:
+                # The viewer is linked to other viewers
                 if self.mapviewer.link_shareopsvect:
-                        if self.myzones.get_mapviewer() in self.mapviewer.linkedList:
-                            self.myzones.showstructure()
-                        return
+                    # The viewer shares the vector manager with the other viewers
+                    if self.myzones.get_mapviewer() in self.mapviewer.linkedList:
+                        # The viewer is in the active linked viewers
+                        self.myzones.showstructure()
+                    return
 
-        self.myzones.showstructure()
+        self.myzones.showstructure()   
 
     def OnLoadvec(self, event:wx.MouseEvent):
         """ Load vector file """
@@ -2593,6 +2668,12 @@ class SelectionData():
         self.hideselection = False
         self.numlist_select = 0 # OpenGL list index
 
+    def set_selection_from_list_xy(self, xylist: list[tuple[float, float]]):
+        """ Set the current selection from a list of (x, y) coordinates """
+
+        self.myselection = xylist
+        self.update_nb_nodes_selection()
+
     @property
     def dx(self) -> float:
         """ Resolution in x """
@@ -4285,6 +4366,11 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return self.mngselection
 
+    @property
+    def Operations(self) -> Ops_Array:
+        """ Return the operations on the array """
+        return self.myops
+
     @property
     def active_blocks(self) -> list["WolfArray"]:
         """ Return the active blocks """
@@ -4623,9 +4709,76 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if crop is not None :
             if os.path.exists(fn):
+
+                tmpdx = self.dx
+
+                fn_crop = fn + '_crop.tif'
+                if type(crop) is np.ndarray:
+                    pass
+                elif type(crop) is list:
+                    pass
+                else:
+                    if not self.wx_exists:
+                        logging.error(_('Crop must be a list or a numpy array with 4 values - xmin, xmax, ymin, ymax'))
+                        return
+
+                    raster:gdal.Dataset
+                    raster = gdal.Open(fn)
+                    geotr = raster.GetGeoTransform()
+                    self.dx = geotr[1]
+                    self.dy = abs(geotr[5])
+
+
+                    newcrop = CropDialog(None)
+
+                    if self.wx_exists:
+                        bounds = self.mapviewer.get_canvas_bounds()
+                        
+                        newcrop.dx.Value = str(self.dx)
+                        newcrop.dy.Value = str(self.dy)
+
+                        newcrop.dx.Enable(False)
+                        newcrop.dy.Enable(False)
+
+                        newcrop.ox.Value = str(float((bounds[0] // 50.) * 50.))
+                        newcrop.ex.Value = str(float((bounds[2] // 50.) * 50.))
+                        newcrop.oy.Value = str(float((bounds[1] // 50.) * 50.))
+                        newcrop.ey.Value = str(float((bounds[3] // 50.) * 50.))
+
+                    badvalues = True
+                    while badvalues:
+                        badvalues = False
+
+                        ret = newcrop.ShowModal()
+                        if ret == wx.ID_CANCEL:
+                            newcrop.Destroy()
+                            return
+                        else:
+                            crop = [float(newcrop.ox.Value), float(newcrop.ex.Value),
+                                    float(newcrop.oy.Value), float(newcrop.ey.Value)]
+                            
+                            tmpdx = float(newcrop.dx.Value)
+                            tmpdy = float(newcrop.dy.Value)
+
+                        if self.dx != tmpdx or self.dy != tmpdy:
+                            if tmpdx / self.dx != tmpdy / self.dy:
+                                badvalues = True
+
+                    newcrop.Destroy()
+
                 xmin, xmax, ymin, ymax = crop
-                gdal.Translate(fn+'_crop.tif', fn, projWin=[xmin, ymax, xmax, ymin])
-                fn +='_crop.tif'
+
+                with wx.FileDialog(None, _('Save the cropped file for later'), wildcard="Tiff files (*.tif)|*.tif",
+                                    style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT) as fileDialog:
+                    
+                    if fileDialog.ShowModal() == wx.ID_CANCEL:
+                        return
+                    
+                    fn_crop = fileDialog.GetPath()
+
+
+                gdal.Translate(fn_crop, fn, projWin=[xmin, ymax, xmax, ymin])
+                fn  = fn_crop
 
         raster:gdal.Dataset
         raster = gdal.Open(fn)
@@ -6409,6 +6562,13 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 newcrop = CropDialog(None)
 
+                if self.mapviewer is not None:
+                    bounds = self.mapviewer.get_canvas_bounds()
+                    newcrop.ox.Value = float((bounds[0] // 50.) * 50.)
+                    newcrop.ex.Value = float((bounds[2] // 50.) * 50.)
+                    newcrop.oy.Value = float((bounds[1] // 50.) * 50.)
+                    newcrop.ey.Value = float((bounds[3] // 50.) * 50.)
+
                 badvalues = True
                 while badvalues:
                     badvalues = False
@@ -7663,7 +7823,7 @@ class WolfArrayMB(WolfArray):
         """
 
         if copyarray:
-            arr = WolfArray(mold=arr)
+            arr = WolfArray(mold=arr, nullvalue=arr.nullvalue)
             force_idx = True
 
         if force_idx: