wolfhece 2.2.8__py3-none-any.whl → 2.2.10__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -53,6 +53,9 @@ from .matplotlib_fig import Matplotlib_Figure as MplFig
 from .PyPalette import wolfpalette
 
 class Triangulation(Element_To_Draw):
+    """ Triangulation based on a listof vertices
+    and triangles enumerated by their vertex indices """
+
     def __init__(self, fn='', pts=[], tri=[], idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
         super().__init__(idx, plotted, mapviewer, need_for_wx)
 
@@ -74,20 +77,24 @@ class Triangulation(Element_To_Draw):
             self.filename=fn
             self.read(fn)
         else:
-            self.valid_format()
+            self.validate_format()
         pass
 
-    def valid_format(self):
+    def validate_format(self):
+        """ Force the format of the data """
+
         if isinstance(self.pts,list):
             self.pts = np.asarray(self.pts)
         if isinstance(self.tri,list):
             self.tri = np.asarray(self.tri)
 
     def as_polydata(self) -> pv.PolyData:
+        """ Convert the triangulation to a PyVista PolyData object """
 
         return pv.PolyData(np.asarray(self.pts),np.column_stack([[3]*self.nb_tri,self.tri]), self.nb_tri)
 
-    def from_polydata(self,poly:pv.PolyData):
+    def from_polydata(self, poly:pv.PolyData):
+        """ Convert a PyVista PolyData object to the triangulation format """
 
         self.pts = np.asarray(poly.points.copy())
         self.tri = np.asarray(poly.faces.reshape([int(len(poly.faces)/4),4])[:,1:4])
@@ -95,7 +102,8 @@ class Triangulation(Element_To_Draw):
         self.nb_pts = len(self.pts)
         self.nb_tri = len(self.tri)
 
-    def clip_surface(self,other,invert=True,subdivide=0):
+    def clip_surface(self, other:"Triangulation", invert=True, subdivide=0):
+        """ Clip the triangulation with another one """
 
         if subdivide==0:
             mypoly = self.as_polydata()
@@ -104,14 +112,12 @@ class Triangulation(Element_To_Draw):
             mypoly = self.as_polydata().subdivide(subdivide)
             mycrop = other.as_polydata().subdivide(subdivide)
 
-        res = mypoly.clip_surface(mycrop,invert=invert)
+        res = mypoly.clip_surface(mycrop, invert=invert)
 
         if len(res.faces)>0:
             self.from_polydata(res)
-        else:
-            return None
 
-    def get_mask(self,eps=1e-10):
+    def get_mask(self, eps:float= 1e-10):
         """
         Teste si la surface de tous les triangles est positive
 
@@ -122,7 +128,7 @@ class Triangulation(Element_To_Draw):
             v1 = [self.pts[curtri[1]][:2] - self.pts[curtri[0]][:2] for curtri in self.tri]
             v2 = [self.pts[curtri[2]][:2] - self.pts[curtri[0]][:2] for curtri in self.tri]
             self.areas = np.cross(v2,v1,)/2
-            return self.areas<=eps
+            return self.areas <= eps
 
             # invalid_tri = np.sort(np.where(self.areas<=eps)[0])
             # for curinv in invalid_tri[::-1]:
@@ -131,8 +137,11 @@ class Triangulation(Element_To_Draw):
             # self.nb_tri = len(self.tri)
 
     def import_from_gltf(self, fn=''):
+        """ Import a GLTF file and convert it to the triangulation format """
 
-        if fn =='':
+        wx_exists = wx.GetApp() is not None
+
+        if fn =='' and wx_exists:
             dlg=wx.FileDialog(None,_('Choose filename'),wildcard='binary gltf2 (*.glb)|*.glb|gltf2 (*.gltf)|*.gltf|All (*.*)|*.*',style=wx.FD_OPEN)
             ret=dlg.ShowModal()
             if ret==wx.ID_CANCEL:
@@ -141,6 +150,8 @@ class Triangulation(Element_To_Draw):
 
             fn=dlg.GetPath()
             dlg.Destroy()
+        else:
+            fn = str(fn)
 
         gltf = pygltflib.GLTF2().load(fn)
 
@@ -216,6 +227,7 @@ class Triangulation(Element_To_Draw):
         self.nb_tri = len(self.tri)
 
     def export_to_gltf(self,fn=''):
+        """ Export the triangulation to a GLTF file """
 
         #on force les types de variables
         triangles = np.asarray(self.tri).astype(np.uint32)
@@ -302,7 +314,7 @@ class Triangulation(Element_To_Draw):
             return
 
         if fn!='':
-            self.filename=fn
+            self.filename = fn
 
         triangles = np.asarray(self.tri).astype(np.uint32)
         points = np.asarray(self.pts) #.astype(np.float64)
@@ -343,11 +355,13 @@ class Triangulation(Element_To_Draw):
                 buf = np.frombuffer(f.read(4 * self.nb_tri * 3), dtype=np.uint32)
                 self.tri = np.array(buf.copy(), dtype=np.uint32).reshape([self.nb_tri,3]).astype(np.int32)
 
-        self.valid_format()
+        self.validate_format()
         self.find_minmax(True)
         self.reset_plot()
 
     def reset_plot(self):
+        """ Reset the OpenGL plot """
+
         try:
             if self.id_list!=-99999:
                 glDeleteLists(self.id_list)
@@ -357,6 +371,7 @@ class Triangulation(Element_To_Draw):
         self.id_list = -99999
 
     def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None ):
+        """ Plot the triangulation in OpenGL """
 
         if self.id_list == -99999:
             try:
@@ -387,7 +402,25 @@ class Triangulation(Element_To_Draw):
         else:
             glCallList(self.id_list)
 
+    def plot_matplotlib(self, ax:Axes, color='black', alpha=1., lw=1.5, **kwargs):
+        """ Plot the triangulation in Matplotlib
+        """
+
+        if self.nb_tri>0:
+            for curtri in self.tri:
+                x = [self.pts[curtri[0]][0], self.pts[curtri[1]][0], self.pts[curtri[2]][0], self.pts[curtri[0]][0]]
+                y = [self.pts[curtri[0]][1], self.pts[curtri[1]][1], self.pts[curtri[2]][1], self.pts[curtri[0]][1]]
+                ax.plot(x, y, color=color, alpha=alpha, lw=lw, **kwargs)
+        else:
+            logging.warning('No triangles to plot')
+
+
     def find_minmax(self,force):
+        """ Find the min and max of the triangulation
+
+        :param force: force the min and max to be calculated
+        """
+
         if force:
             if self.nb_pts>0:
                 self.xmin=np.min(self.pts[:,0])
@@ -396,6 +429,8 @@ class Triangulation(Element_To_Draw):
                 self.ymax=np.max(self.pts[:,1])
 
     def import_dxf(self,fn):
+        """ Import a DXF file and convert it to the triangulation format """
+
         import ezdxf
 
         if not path.exists(fn):
@@ -431,7 +466,7 @@ class Triangulation(Element_To_Draw):
         self.pts = xyz_u
         self.nb_pts = len(self.pts)
         self.nb_tri = len(self.tri)
-        self.valid_format()
+        self.validate_format()
 
     def set_cache(self):
         """ Set the cache for the vertices """
@@ -4038,7 +4073,7 @@ class zone:
         self.add_vector(mypl,0)
         self.add_vector(mypr,2)
 
-    def createmultibin(self, nb=None, nb2=0) -> Triangulation:
+    def create_multibin(self, nb:int = None, nb2:int = 0) -> Triangulation:
         """
         Création d'une triangulation sur base des vecteurs
         Tient compte de l'ordre
@@ -4075,7 +4110,11 @@ class zone:
             nb=int(dlg.GetValue())
             dlg.Destroy()
         else:
-            logging.warning( _('Bad parameter nb'))
+            try:
+                nb=int(nb)
+            except:
+                logging.warning( _('Bad parameter nb'))
+                return None
 
         # redécoupage des polylines
         s = np.linspace(0.,1.,num=nb,endpoint=True)
@@ -4095,10 +4134,16 @@ class zone:
             ret=dlg.ShowModal()
             if ret==wx.ID_CANCEL:
                 dlg.Destroy()
-                return
+                return None
 
             nb2=int(dlg.GetValue())
             dlg.Destroy()
+        else:
+            try:
+                nb2=int(nb2)
+            except:
+                logging.warning( _('Bad parameter nb2'))
+                return None
 
         if nb2>0:
             finalls = []
@@ -4187,9 +4232,12 @@ class zone:
 
         return interp
 
-    def create_constrainedDelaunay(self, nb=None) -> Triangulation:
+    def create_constrainedDelaunay(self, nb:int = None) -> Triangulation:
         """
-        Création d'une triangulation Delaunay contrainte sur base des vecteurs
+        Création d'une triangulation Delaunay contrainte sur base des vecteurs de la zone.
+
+        Il est nécessaire de définir au moins un polygone définissant la zone de triangulation.
+        Les autres vecteurs seront utilisés comme contraintes de triangulation.
 
         Utilisation de la librairie "triangle" (https://www.cs.cmu.edu/~quake/triangle.delaunay.html)
 
@@ -4223,14 +4271,18 @@ class zone:
             nb=int(dlg.GetValue())
             dlg.Destroy()
         else:
-            logging.warning( _('Bad parameter nb'))
+            try:
+                nb=int(nb)
+            except:
+                logging.warning( _('Bad parameter nb'))
+                return None
 
         if nb==0:
             # no decimation
             newls = myls
         else:
             # redécoupage des polylines
-            s = np.linspace(0.,1.,num=nb,endpoint=True)
+            s = np.linspace(0., 1., num=nb, endpoint=True)
 
             newls = [LineString([curls.interpolate(curs,True) for curs in s]) for curls in myls if curls.length>0.]
 
@@ -7690,7 +7742,7 @@ class Zones(wx.Frame, Element_To_Draw):
                 dlg.Destroy()
                 return
 
-            mytri = myzone.createmultibin()
+            mytri = myzone.create_multibin()
 
             self.mapviewer.add_object('triangulation',newobj=mytri)
             self.mapviewer.Refresh()

wolfhece/__init__.py

@@ -1,11 +1,14 @@
 from . import _add_path
+from .PyTranslate import _
 
 try:
-    from osgeo import gdal, osr
+    from osgeo import gdal, osr, ogr
     gdal.UseExceptions()
+    ogr.UseExceptions()
+    osr.UseExceptions()
 except ImportError as e:
     print(e)
-    raise Exception(_('Error importing GDAL library'))
+    raise Exception(_('Error importing GDAL library\nPlease ensure GDAL is installed and the Python bindings are available\n\ngdal wheels can be found at https://github.com/cgohlke/geospatial-wheels'))
 
 from .apps.version import WolfVersion
 

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 2
-        self.patch = 8
+        self.patch = 10
 
     def __str__(self):
 

wolfhece/hydrology/Internal_variables.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+from typing import Optional
+from os.path import exists, join
+import numpy as np
+import logging
+from datetime import datetime as date
+from datetime import timezone
+from dataclasses import dataclass
+from . import read as rd
+from ..PyParams import Wolf_Param
+
+ALL_VAR = 0
+IV_VAR = 1
+FRAC_VAR = 2
+FINAL_OUT_VAR = 3
+OUT_VAR = 4
+DEFAULT_VAR = 5
+
+
+@dataclass(frozen=True)
+class Internal_Variable:
+    """
+    Class for managing internal variables in hydrological models.
+    """
+    name:str
+    file:str
+    type_of_var:int
+    linked_param:int
+
+
+    def get_time_serie(self, directory, prefix_file:str="", 
+                       interval:Optional[tuple[date, date]]=None) -> tuple[np.ndarray, np.ndarray]:
+        """
+        Get the time series of the internal variable.
+
+        :param interval: Optional interval for the time series.
+        :return: Time series of the internal variable.
+        """
+        filename, full_path = self.get_filename(directory, prefix=prefix_file)
+        if filename is None:
+            return None, None
+        time, cur_iv = rd.read_hydro_file(directory, fileName=filename)
+        # select the interval if needed
+        if interval is not None:
+            # Check if the datetime in interva are in UTC timezone
+            if interval[0].tzinfo == timezone.utc or interval[1].tzinfo == timezone.utc:
+                interval = (interval[0].replace(tzinfo=timezone.utc),
+                            interval[1].replace(tzinfo=timezone.utc))
+                t_start = interval[0].timestamp()
+                t_end = interval[1].timestamp()
+                time = time[(time >= t_start) & (time <= t_end)]
+                cur_iv = cur_iv[(time >= t_start) & (time <= t_end)]
+            else:
+                logging.error("Interval is not in UTC timezone!")
+
+        return time, cur_iv
+
+
+    def get_filename(self, directory:str, prefix:str="")->tuple[str, str]:
+        """
+        Get the filename of the internal variable.
+
+        :param directory: Directory where the file is located.
+        :param prefix: Prefix for the filename.
+        :return: Tuple containing the name of the file only and the full path of the internal variable.
+        """
+        filename = "".join([prefix,"_", self.file, ".dat"])
+        full_path = join(directory, filename)
+        # check if the file exists
+        if not exists(full_path):
+            logging.error(f"File {full_path} not found!")
+            return None, None
+
+        return filename, full_path
+
+
+# @dataclass(frozen=True)
+class Param_to_Activate:
+    """
+    Class for managing parameters to activate in hydrological models.
+    """
+    key: str
+    group: str
+    file: str
+    all_variables: list[Internal_Variable]
+
+    def __init__(self, key:str="", group:str="", file:str="", all_variables:list[Internal_Variable]=[]):
+        """
+        Initialize the Params_to_Activate class with parameters for different models.
+        """       
+        self.key = key
+        self.group = group
+        self.file = file
+        self.all_variables = all_variables
+
+    def add_param_info(self, key:str, group:str, file:str):
+        """
+        Add parameter information to the class.
+        """
+        self.key = key
+        self.group = group
+        self.file = file
+
+    def check_param_file(self, directory:str):
+        """
+        Define the working directory for the parameters.
+        """
+        cur_file = join(directory, self.file)
+        # check if the file exists
+        if not exists(cur_file):
+            logging.error(f"File {cur_file} not found!")
+            
+    def add_variable(self, variable:Internal_Variable|list[Internal_Variable]):
+        """
+        Add one or a list of internal variable(s) to the list of variables.
+        """
+        if isinstance(variable, list):
+            self.all_variables += variable
+        else:
+            self.all_variables.append(variable)
+        
+    def get_variables_names(self) -> list[str]:
+        """
+        Get the names of the internal variables.
+        """
+        return [var.name for var in self.all_variables]
+    
+    def get_variables_files(self) -> list[str]:
+        """
+        Get the files of the internal variables.
+        """
+        return [var.file for var in self.all_variables]
+    
+    def activate(self, directory:str, prefix_file:str="", type_of_var:int=ALL_VAR):
+        """
+        Activate the parameters for the internal variables.
+        """
+        if self.key is None or self.group is None:
+            return
+        
+        to_activate = False
+        if type_of_var == ALL_VAR:
+            to_activate = True
+        else:
+            for var in self.all_variables:
+                if var.type_of_var == type_of_var or type_of_var == ALL_VAR:
+                    to_activate = True
+                    break
+
+        if to_activate:
+            new_prefix = self._build_prefix(prefix_file)
+            filename = ".".join([new_prefix,"param"])
+            param_filename = join(directory, filename)            
+            param_file = Wolf_Param(to_read=True, filename=param_filename,toShow=False, init_GUI=False)
+            param_file.change_param(self.group, self.key, 1)
+            param_file.SavetoFile(None)
+            param_file.Reload(None)
+        else:
+            self.deactivate(directory, prefix_file)
+
+    def deactivate(self, directory:str, prefix_file:str=""):
+        """
+        Deactivate the parameters for the internal variables.
+        """
+        new_prefix = self._build_prefix(prefix_file)
+        filename = ".".join([new_prefix,"param"])
+        param_filename = join(directory, filename)
+        param_file = Wolf_Param(to_read=True, filename=param_filename,toShow=False, init_GUI=False)
+        param_file.change_param(self.group, self.key, 0)
+        param_file.SavetoFile(None)
+        param_file.Reload(None)
+
+    def get_iv_timeseries(self, directory:str, prefix_file:str="", interval:Optional[tuple[date, date]]=None, type_of_var:int=ALL_VAR) -> dict[str, np.ndarray]:
+        """
+        Get the time series of the internal variables.
+
+        :param directory: Directory where the file is located.
+        :param prefix_file: Prefix for the filename.
+        :param interval: Optional interval for the time series.
+        :return: List of tuples containing the time and internal variable data.
+        """
+
+        new_prefix = self._build_prefix(prefix_file)
+
+        all_timeseries = {var.name: 
+                          var.get_time_serie(directory, new_prefix, interval)[1]
+                          for var in self.all_variables 
+                          if var.type_of_var == type_of_var or type_of_var == ALL_VAR}
+
+        return all_timeseries
+    
+
+    def get_linked_params(self) -> dict[str, int]:
+        """
+        Get the linked parameters of the internal variables.
+
+        :return: Dictionary of linked parameters.
+        """
+        return {var.name: var.linked_param for var in self.all_variables if var.linked_param is not None}
+    
+    def _build_prefix(self, prefix_file:str) -> str:
+        """
+        Build the prefix for the filename.
+
+        :param prefix_file: Prefix for the filename.
+        :return: Prefix for the filename.
+        """
+        if self.file == "":
+            return prefix_file
+        else:
+            return "_".join([prefix_file, self.file])
+    
+
+
+class Group_to_Activate:
+    """
+    Class for managing groups of parameters to activate in hydrological models.
+    """
+    name: str
+    all_params: list[Param_to_Activate]
+
+    def __init__(self, name:str="", all_params:list[Param_to_Activate]=[]):
+        """
+        Initialize the Group_to_Activate class with parameters for different models.
+        """       
+        self.name = name
+        self.all_params = all_params
+
+    def get_keys(self) -> list[str]:
+        """
+        Get the keys of the parameters.
+        """
+        return [param.key for param in self.all_params]
+
+    def get_files_per_keys(self) -> list[str]:
+        """
+        Get the files of the parameters.
+        """
+        return [param.get_variables_files() for param in self.all_params]
+
+    def activate_all(self, directory:str, prefix_file:str="", type_of_var:int=ALL_VAR):
+        """
+        Activate all parameters in the group.
+        """
+        for param in self.all_params:
+            param.activate(directory, prefix_file, type_of_var)
+
+    def deactivate_all(self, directory:str, prefix_file:str=""):
+        """
+        Deactivate all parameters in the group.
+        """
+        for param in self.all_params:
+            param.deactivate(directory, prefix_file)
+
+    def get_all_iv_timeseries(self, directory:str, prefix_file:str="",
+                              interval:Optional[tuple[date, date]]=None,
+                              type_of_var:int=ALL_VAR) -> dict[str, np.ndarray]:
+        """
+        Get the time series of all internal variables in the group.
+
+        :param directory: Directory where the file is located.
+        :param prefix_file: Prefix for the filename.
+        :param interval: Optional interval for the time series.
+        :return: List of tuples containing the time and internal variable data.
+        """
+        all_timeseries = {}
+        for param in self.all_params:
+            all_timeseries.update(param.get_iv_timeseries(directory, prefix_file,
+                                                          interval, type_of_var))
+
+        return all_timeseries
+    
+    def get_all_linked_params(self) -> dict[str, int]:
+        """
+        Get the linked parameters of the internal variables.
+
+        :return: Dictionary of linked parameters.
+        """
+        all_linked_params = {}
+        for param in self.all_params:
+            all_linked_params.update(param.get_linked_params())
+
+        return all_linked_params