wolfhece 2.1.97__py3-none-any.whl → 2.1.99__py3-none-any.whl

wolfhece/PyParams.py

@@ -344,14 +344,14 @@ class Wolf_Param(wx.Frame):
 
         return self.sizer is not None
 
-    def ensure_prop(self, wxparent = None, show_in_active_if_default:bool = False):
+    def ensure_prop(self, wxparent = None, show_in_active_if_default:bool = False, height:int= 600):
         """ Ensure that the property grid is available """
 
         if self.wx_exists:
             if not self.has_prop:
                 self._set_only_prop(wxparent)
                 self.show_in_active_if_default = show_in_active_if_default
-                self.prop.SetSizeHints(0,600)
+                self.prop.SetSizeHints(0,height)
 
             self.Populate()
 
@@ -1034,12 +1034,17 @@ class Wolf_Param(wx.Frame):
                 page.Append(pg.IntProperty(label = param_name, name = locname, value = locvalue))
 
         elif param[key_Param.TYPE]==Type_Param.File:
-            page.Append(pg.FileProperty(label=param_name, name = locname, value = param[key_Param.VALUE]))
+
+            if param[key_Param.VALUE] is None:
+                page.Append(pg.FileProperty(label=param_name, name = locname, value = ''))
+            else:
+                page.Append(pg.FileProperty(label=param_name, name = locname, value = param[key_Param.VALUE]))
 
         elif param[key_Param.TYPE]==Type_Param.Directory:
-            page.Append(pg.DirProperty(label = param_name, name = locname, value = locvalue))
-            # newobj.SetLabel(param_name)
-            # page.Append(newobj)
+            if locvalue is None:
+                page.Append(pg.DirProperty(label = param_name, name = locname, value = ''))
+            else:
+                page.Append(pg.DirProperty(label = param_name, name = locname, value = locvalue))
 
         elif param[key_Param.TYPE]==Type_Param.Color:
             page.Append(pg.ColourProperty(label = param_name, name = locname, value = locvalue))
@@ -1325,9 +1330,13 @@ class Wolf_Param(wx.Frame):
     # File management without wx
     # ---------------------------
 
-    def apply_changes_to_memory(self):
+    def apply_changes_to_memory(self, verbosity:bool = True):
         """ Transfert des données en mémoire sans wx --> remplissage des dictionnaires """
 
+        if self.prop is None:
+            logging.debug("ERROR : wxPython is not running - Impossible to apply changes to memory")
+            return
+
         if self.prop.IsPageModified(0):
             #on boucle sur tous les paramètres pour les ajouter au dictionnaire si non présents
             for group in self.myparams_default.keys():
@@ -1339,7 +1348,8 @@ class Wolf_Param(wx.Frame):
             if not self._callback is None:
                 self._callback()
         else:
-            wx.MessageDialog(self,'Nothing to do!')
+            if verbosity:
+                logging.warning(_('Nothing to do!'))
 
     def save_automatically_to_file(self):
         """

wolfhece/PyVertex.py

@@ -40,11 +40,18 @@ from .wolf_texture import Text_Image_Texture
 def getRGBfromI(rgbint:int):
     """ Convert integer to RGB """
 
-    blue = rgbint & 255
-    green = (rgbint >> 8) & 255
-    red = (rgbint >> 16) & 255
-    return red, green, blue
-
+    if isinstance(rgbint, tuple):
+        return rgbint[0], rgbint[1], rgbint[2]
+    elif isinstance(rgbint, list):
+        return rgbint[0], rgbint[1], rgbint[2]
+    elif isinstance(rgbint, int):
+        blue = rgbint & 255
+        green = (rgbint >> 8) & 255
+        red = (rgbint >> 16) & 255
+        return red, green, blue
+    else:
+        logging.error('Error in getRGBfromI')
+        return 0, 0, 0
 
 def getIfromRGB(rgb:Union[list, tuple]):
     """ Convert RGB to integer """

wolfhece/PyVertexvectors.py

@@ -15,10 +15,10 @@ import triangle.tri
 import wx
 import wx._dataview
 from wx.dataview import *
-from wx.core import BoxSizer, FlexGridSizer, TreeItemId
+from wx.core import BoxSizer, TreeItemId
 from OpenGL.GL  import *
 from shapely.geometry import LineString, MultiLineString,Point,MultiPoint,Polygon,JOIN_STYLE, MultiPolygon
-from shapely.ops import nearest_points,substring, split, polygonize
+from shapely.ops import nearest_points
 from shapely import delaunay_triangles, prepare, is_prepared, destroy_prepared
 import pygltflib
 from scipy.interpolate import interp1d
@@ -37,13 +37,13 @@ from typing import Union, Literal
 from pathlib import Path
 import triangle
 
+
+
 from .wolf_texture import genericImagetexture
-from .textpillow import Font_Priority
 from .PyTranslate import _
 from .CpGrid import CpGrid
 from .PyVertex import wolfvertex,getIfromRGB,getRGBfromI, cloud_vertices
-from .PyParams import Wolf_Param, key_Param, Type_Param, new_json, new_infos_incr
-from .lazviewer.laz_viewer import myviewer
+from .PyParams import Wolf_Param, Type_Param, new_json
 from .wolf_texture import Text_Image_Texture,Text_Infos
 from .drawing_obj import Element_To_Draw
 
@@ -927,6 +927,7 @@ if :\n \
             else:
                 return 'Arial'
 
+
 class vector:
     """
     Objet de gestion d'informations vectorielles
@@ -1861,22 +1862,22 @@ class vector:
 
         self._reset_listogl()
 
-    def get_s2d(self):
+    def get_s2d(self) -> np.ndarray:
         """
         calcul et retour des positions curvilignes 2D
         """
-        s2d=np.zeros[self.nbvertices]
-        for k in range(1,self.nbvertices+1):
+        s2d=np.zeros(self.nbvertices)
+        for k in range(1,self.nbvertices):
             s2d[k]=s2d[k-1]+self.myvertices[k-1].dist2D(self.myvertices[k])
 
         return s2d
 
-    def get_s3d(self):
+    def get_s3d(self) -> np.ndarray:
         """
         calcul et retour des positions curvilignes 3D
         """
-        s3d=np.zeros[self.nbvertices]
-        for k in range(1,self.nbvertices+1):
+        s3d=np.zeros(self.nbvertices)
+        for k in range(1,self.nbvertices):
             s3d[k]=s3d[k-1]+self.myvertices[k-1].dist3D(self.myvertices[k])
 
         return s3d
@@ -2200,7 +2201,7 @@ class vector:
                     myvec=vector(name=curlabel,parentzone=myzone)
                     myzone.add_vector(myvec)
 
-                    ds = min(curarray.dx,curarray.dy)
+                    ds = curarray.get_dxdy_min()
 
                     pts = self._refine2D(ds)
 
@@ -2224,12 +2225,12 @@ class vector:
 
                     if filter_null:
                         for curpt in self.myvertices:
-                            locval = curarray.get_value(curpt.x, curpt.y, nullvalue=-9999)
+                            locval = curarray.get_value(curpt.x, curpt.y, nullvalue=-99999)
                             if locval !=-99999:
                                 myvec.add_vertex(wolfvertex(curpt.x, curpt.y, locval))
                     else:
                         for curpt in self.myvertices:
-                            locval = curarray.get_value(curpt.x, curpt.y, nullvalue=-9999)
+                            locval = curarray.get_value(curpt.x, curpt.y, nullvalue=-99999)
                             myvec.add_vertex(wolfvertex(curpt.x, curpt.y, locval))
 
         return myzone
@@ -2238,8 +2239,8 @@ class vector:
         """
         Graphique Matplolib de valeurs dans les matrices liées
         """
-        from .wolf_array import WolfArray
-        from .wolfresults_2D import Wolfresults_2D
+        # from .wolf_array import WolfArray
+        # from .wolfresults_2D import Wolfresults_2D
 
         colors=['red','blue','green']
 
@@ -2265,10 +2266,7 @@ class vector:
         for curlabel, curarray in linked_arrays.items():
             if curarray.plotted:
 
-                if isinstance(curarray, WolfArray):
-                    ds = min(curarray.dx,curarray.dy)
-                elif isinstance(curarray, Wolfresults_2D):
-                    ds = min(curarray[0].dx,curarray[0].dy)
+                ds = curarray.get_dxdy_min()
 
                 nb = int(np.ceil(length/ds*2))
 
@@ -2868,6 +2866,11 @@ class zone:
                 return self.myvectors[zone_names.index(keyvector)]
             return None
 
+    @property
+    def vector_names(self)->list[str]:
+        """ Return the list of vector names """
+        return [cur.myname for cur in self.myvectors]
+
     def __getitem__(self, ndx:Union[int,str]) -> vector:
         """ Permet de retrouver un vecteur sur base de son index """
         return self.get_vector(ndx)
@@ -2875,7 +2878,7 @@ class zone:
     def export_shape(self, fn:str = ''):
         """ Export to shapefile using GDAL/OGR """
 
-        from osgeo import gdal, osr, gdalconst,ogr
+        from osgeo import osr, ogr
 
         fn = str(fn)
 
@@ -4788,6 +4791,11 @@ class Zones(wx.Frame, Element_To_Draw):
         else:
             return self.get_zone(ndx)
 
+    @property
+    def zone_names(self) -> list[str]:
+        """ Return the list of zone names """
+        return [cur.myname for cur in self.myzones]
+
     def import_dxf(self, fn, imported_elts=['POLYLINE','LWPOLYLINE','LINE']):
         """
         Import d'un fichier DXF en tant qu'objets WOLF
@@ -5238,7 +5246,7 @@ class Zones(wx.Frame, Element_To_Draw):
             boxright.Add(self.getxyfromsz,0,wx.EXPAND) # Added
 
             self.butgetval = wx.Button(self,label=_('Get values (self or active array)'))
-            self.butgetval.SetToolTip(_("Get values of the attached/active array on each vertex of the active vector and update the editor"))
+            self.butgetval.SetToolTip(_("Get values of the attached/active array (not working with 2D results) on each vertex of the active vector and update the editor"))
             self.butgetval.Bind(wx.EVT_BUTTON,self.Ongetvalues)
             boxright.Add(self.butgetval,0,wx.EXPAND)
 

wolfhece/Results2DGPU.py

@@ -261,7 +261,7 @@ class wolfres2DGPU(Wolfresults_2D):
 
                         curblock.origx = curblock.top.origx
                         curblock.origy = curblock.top.origy
-                        
+
                     except:
                         logging.error(_('No spatial position (base_coord_x,base_coord_y) in parameters.json -- Results will not be spatially based'))
                         return -2
@@ -397,7 +397,7 @@ class wolfres2DGPU(Wolfresults_2D):
         qy_np = qy_np.T
 
         curblock = self.myblocks[getkeyblock(1,False)]
-        
+
         curblock.waterdepth.array.data[:,:] = curblock.waterdepth.nullvalue
         curblock.qx.array.data[:,:] = curblock.qx.nullvalue
         curblock.qy.array.data[:,:] = curblock.qy.nullvalue
@@ -405,16 +405,16 @@ class wolfres2DGPU(Wolfresults_2D):
         curblock.waterdepth.array.mask[:,:] = True
         curblock.qx.array.mask[:,:] = True
         curblock.qy.array.mask[:,:] = True
-        
+
         if self.epsilon > 0.:
             # curblock.waterdepth.array=ma.masked_less_equal(wd_np.astype(np.float32).T, self.epsilon)
-            
+
             ij = np.where(wd_np >= self.epsilon)
             curblock.waterdepth.array.data[ij] = wd_np[ij]
             curblock.waterdepth.array.mask[ij] = False
         else:
             # curblock.waterdepth.array=ma.masked_equal(wd_np.astype(np.float32).T, 0.)
-            
+
             ij = np.where(wd_np > 0.)
             curblock.waterdepth.array.data[ij] = wd_np[ij]
             curblock.waterdepth.array.mask[ij] = False
@@ -463,11 +463,11 @@ class wolfres2DGPU(Wolfresults_2D):
         wd_np = wd_np.T
 
         curblock = self.myblocks[getkeyblock(1,False)]
-        
+
         curblock.waterdepth.array.data[:,:] = curblock.waterdepth.nullvalue
 
         curblock.waterdepth.array.mask[:,:] = True
-        
+
         if self.epsilon > 0.:
             ij = np.where(wd_np >= self.epsilon)
             curblock.waterdepth.array.data[ij] = wd_np[ij]
@@ -529,6 +529,22 @@ class wolfres2DGPU(Wolfresults_2D):
             else:
                 return self.times, self.timesteps
 
+    @property
+    def all_dt(self):
+        return self._result_store.get_named_series(ResultType.LAST_DELTA_T)
+
+    @property
+    def all_mostly_dry_mesh(self):
+        return self._result_store.get_named_series(ResultType.NB_MOSTLY_DRY_MESHES)
+
+    @property
+    def all_clock_time(self):
+        return self._result_store.get_named_series(ResultType.CLOCK_T)
+
+    @property
+    def all_wet_meshes(self):
+        return self._result_store.get_named_series(ResultType.NB_WET_MESHES)
+
     # def read_previous(self):
     #     """
     #     Lecture du pas suivant

wolfhece/analyze_vect.py

@@ -0,0 +1,177 @@
+
+from pathlib import Path
+import numpy as np
+from shapely.geometry import Polygon, Point, LineString
+from shapely import prepare, is_prepared, destroy_prepared
+
+import wx
+import logging
+from tqdm import tqdm
+
+from .PyTranslate import _
+from .PyVertexvectors import Zones, zone, vector, wolfvertex
+from .matplotlib_fig import Matplotlib_Figure as mpl_plot, Matplotlib_ax_properties as mpl_ax, Matplolib_line_properties as mpl_line, Matplotlib_figure_properties as mpl_fig
+from .matplotlib_fig import PRESET_LAYOUTS
+from .wolf_array import WolfArray
+from .wolfresults_2D import Wolfresults_2D
+from .Results2DGPU import wolfres2DGPU
+
+class Compare_vectors():
+    """ Compare multiple vectors """
+
+    def __init__(self) -> None:
+
+        self.fig:mpl_plot = None
+
+        self._reference:vector = None
+        self._reference_ls:LineString = None
+        self._ref_s:np.ndarray = None
+        self._ref_obj:dict[str, WolfArray | wolfres2DGPU | Wolfresults_2D] = {}
+        self._ref_values:zone = None
+
+        self._to_compare:dict[vector, list[WolfArray | wolfres2DGPU | Wolfresults_2D]] = {}
+        self._compare_values:dict[vector, zone] = {}
+
+    @property
+    def layout(self):
+        """ Layout of the figure """
+        return self.fig.layout
+
+    @layout.setter
+    def layout(self, value:dict | tuple | list | str):
+        """ Set layout of the figure """
+        self.fig = mpl_plot(value)
+        self.fig.Show()
+
+    @property
+    def reference(self):
+        """ Reference vector """
+        return self._reference
+
+    @reference.setter
+    def reference(self, value:vector):
+        """ Set reference vector """
+        if not isinstance(value, vector):
+            logging.error(_('Reference must be a vector'))
+            return
+
+        self._reference = value
+        self._reference_ls = value.asshapely_ls()
+        prepare(self._reference_ls)
+        self._ref_s = self._reference.get_s2d()
+
+    def __del__(self):
+        """ Destructor """
+
+        if self._reference_ls is not None:
+            if is_prepared(self._reference_ls):
+                destroy_prepared(self._reference_ls)
+
+    def add_ref_values(self, values:WolfArray | wolfres2DGPU | Wolfresults_2D):
+        """ Add values to the reference vector """
+
+        self._ref_obj[values.idx] = values
+
+    def del_ref_values(self, which:int | str):
+        """ Pop values from the reference vector """
+
+        if isinstance(which, str):
+            if which in self._ref_obj:
+                self._ref_obj.pop(which)
+        elif isinstance(which, int):
+            if which < len(self._ref_obj):
+                self._ref_obj.pop(list(self._ref_obj.keys())[which])
+
+    def reset_ref_values(self):
+        """ Reset reference values """
+
+        self._ref_obj = {}
+
+    def get_ref_values(self):
+        """ Retrieve reference values """
+
+        self._ref_values = self.reference.get_values_linked(self._ref_obj)
+
+    def add_compare(self, support:vector, values:list[WolfArray | wolfres2DGPU | Wolfresults_2D] = None):
+        """ Add values to compare """
+
+        if not isinstance(support, vector):
+            logging.error(_('Support must be a vector'))
+            return
+
+        if values is not None:
+            if not isinstance(values, list):
+                values = [values]
+
+            if isinstance(values, list):
+                if not all(isinstance(x, WolfArray | wolfres2DGPU | Wolfresults_2D) for x in values):
+                    logging.error(_('Values must be a list of WolfArray, Wolfresults_2D or Wolfres2DGPU'))
+                    return
+
+        if support in self._to_compare:
+            self._to_compare[support] += values
+        else:
+            self._to_compare[support] = values
+
+    def reset_compare(self):
+        """ Reset comparison values """
+
+        self._to_compare = {}
+
+    def del_compare(self, which:int | str):
+        """ Pop values from the comparison vector """
+
+        if isinstance(which, str):
+            if which in self._to_compare:
+                self._to_compare.pop(which)
+        elif isinstance(which, int):
+            if which < len(self._to_compare):
+                self._to_compare.pop(list(self._to_compare.keys())[which])
+
+    def get_compare_values(self):
+        """ Retrieve comparison values """
+
+        for curvect in self._to_compare:
+            self._compare_values[curvect] = curvect.get_values_linked({cur.idx: cur for cur in self._to_compare[curvect]})
+
+    def plot_ref(self, axis:int = 0):
+        """ Plot reference vector """
+
+        if self.fig is None:
+            logging.error(_('No figure layout defined'))
+            return
+
+        for curvect in self._ref_values.myvectors:
+            xyz = curvect.asnparray3d()
+            x = [self._reference_ls.project(Point(x,y)) for x,y in xyz[:,0:2]]
+            y = xyz[:,2]
+
+            self.fig.plot(x=x, y=y, ax=axis, label=curvect.myname)
+
+    def plot_compare(self, axis:int = 0):
+        """ Plot comparison vectors along reference vector.
+
+        We must project comparison vectors on the reference vector and plot them.
+        """
+
+        if self.fig is None:
+            logging.error(_('No figure layout defined'))
+            return
+
+        for curvect in self._compare_values:
+            for curval in self._compare_values[curvect].myvectors:
+                xyz = curval.asnparray3d()
+                x = [self._reference_ls.project(Point(x,y)) for x,y in xyz[:,0:2]]
+                y = xyz[:,2]
+
+                self.fig.plot(x=x, y=y, ax=axis, label=curval.myname)
+
+    def set_x_bounds(self, smin:float, smax:float, axis:int = 0):
+        """ Set x bounds for the figure """
+
+        self.fig.set_x_bounds(smin, smax, axis)
+
+    def set_y_bounds(self, ymin:float, ymax:float, axis:int = 0):
+        """ Set y bounds for the figure """
+
+        self.fig.set_y_bounds(ymin, ymax, axis)

wolfhece/apps/version.py

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