wolfhece 2.1.113__py3-none-any.whl → 2.1.115__py3-none-any.whl

wolfhece/PyGui.py

@@ -2942,9 +2942,8 @@ class Wolf2DGPUModel(GenMapManager):
 
         if self._wp is not None:
             try:
-                if self._wp.Shown:
-                    self._sim.sim.from_wolfparam(self._wp)
-                    self._sim.sim._save_json()
+                self._sim.sim.from_wolfparam(self._wp)
+                self._sim.sim._save_json()
             except Exception as e:
                 self._wp = None
                 logging.debug(_('Error while saving parameters for simulation {}'.format(self._sim.sim.path.name)))
@@ -3047,6 +3046,14 @@ class Wolf2DGPUModel(GenMapManager):
 
         ret_infil=[]
         nmax = ma.max(self.arrays['infiltration_zones'].array)
+
+        if nmax == 99999:
+            logging.warning(_('Maximum index in infiltration zones is 99999. It seems to be a bad null value - Check the array !'))
+            logging.warning(_('Replacing 99999 by 0'))
+            self.arrays['infiltration_zones'].array[self.arrays['infiltration_zones'].array == 99999] = 0
+            nmax = ma.max(self.arrays['infiltration_zones'].array)
+            logging.info(_('New maximum index in infiltration zones is {}'.format(nmax)))
+
         nmin = ma.min(self.arrays['infiltration_zones'].array[self.arrays['infiltration_zones'].array > 0])
         l = ma.unique(self.arrays['infiltration_zones'].array[self.arrays['infiltration_zones'].array > 0]).tolist()
         chronos = self.sim.sim.infiltrations_chronology
@@ -3416,6 +3423,7 @@ class Wolf2DGPUModel(GenMapManager):
         """ Apply the changes """
 
         if self._wp is not None:
+            self._wp.apply_changes_to_memory()
             self._callbackwp()
 
     def show_properties(self):
@@ -3633,9 +3641,11 @@ class Wolf2DGPUModel(GenMapManager):
             # Apply changes
             # -------------
             self._btn_apply = wx.Button(self._panel, label=_('Apply changes'))
-            self._btn_apply.SetToolTip(_('Apply the changes to the memory (not saved on disk)'))
+            self._btn_apply.SetToolTip(_('Apply the changes to the memory (and save on disk)'))
             self._btn_apply.Bind(wx.EVT_BUTTON, self._apply_changes)
 
+            self._sizer_principal.Add(self._btn_apply, 1, wx.EXPAND)
+
             self._panel.SetSizer(self._sizer_gen)
 
             self._sizer_principal.Add(self._sizer_properties, 4, wx.EXPAND)

wolfhece/PyPalette.py

@@ -352,6 +352,8 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
             if fn != '' and fn is not None:
                 plt.savefig(fn[:-4]+'_h.png', format='png')
 
+        fig.set_visible(False)
+
         return fig, ax
 
     def plot(self, fig: Figure, ax: plt.Axes):

wolfhece/PyVertexvectors.py

@@ -59,7 +59,7 @@ class Triangulation(Element_To_Draw):
         self.nb_tri = len(tri)
         self.nb_pts = len(pts)
 
-        self._start_move = None
+        self._move_start = None
         self._move_step = None  # step for a move
         self._rotation_center = None
         self._rotation_step = None
@@ -580,6 +580,10 @@ class vectorproperties:
 
             self.used=True
 
+        # FIXME : to be changed
+        # if self.parent is not None:
+        #     self.closed = self.parent.closed
+
         self.init_extra()
 
     def init_extra(self):
@@ -716,7 +720,13 @@ class vectorproperties:
         self.color = getIfromRGB(props[('Draw','Color')])
         self.width = props[('Draw','Width')]
         self.style = props[('Draw','Style')]
+
+        old_closed = self.closed
         self.closed = props[('Draw','Closed')]
+
+        if old_closed != self.closed:
+            self.parent._reset_listogl()
+
         self.filled = props[('Draw','Filled')]
         self.transparent = props[('Draw','Transparent')]
         self.alpha = props[('Draw','Alpha')]
@@ -733,75 +743,15 @@ class vectorproperties:
         self.legendrelpos = props[('Legend','Relative position')]
 
         text = props[('Legend','Text')]
-        if text is _('Not used'):
-            pass
-        elif text == _('name'):
-            self.legendtext = self.parent.myname
-        elif text == _('first z'):
-            self.legendtext = str(self.parent.myvertices[0].z)
-        elif text == _('length2D'):
-            self.legendtext = str(self.parent.length2D)
-        elif text == _('length3D'):
-            self.legendtext = str(self.parent.length3D)
-        elif text == _('id'):
-            self.legendtext = str(self.parent.parentzone.myvectors.index(self.parent))
-        else:
-            self.legendtext = text
+
+        self.parent.set_legend_text(text)
 
         self.legendvisible = props[('Legend','Visible')]
 
         posx = props[('Legend','X')]
         posy = props[('Legend','Y')]
 
-        if posx == _('Not used'):
-            pass
-        elif posx.lower() == _('median'):
-            # valeur mediane selon x et y
-            xy = self.parent.asnparray()
-            self.legendx = np.median(xy[:,0])
-        elif posx.lower() == _('mean'):
-            # valeur moyenne selon x et y
-            xy = self.parent.asnparray()
-            self.legendx = np.mean(xy[:,0])
-        elif posx.lower() == _('min'):
-            # valeur minimale selon x et y
-            xy = self.parent.asnparray()
-            self.legendx = np.min(xy[:,0])
-        elif posx.lower() == _('max'):
-            # valeur maximale selon x et y
-            xy = self.parent.asnparray()
-            self.legendx = np.max(xy[:,0])
-        elif posx.lower() == _('first'):
-            self.legendx = self.parent.myvertices[0].x
-        elif posx.lower() == _('last'):
-            self.legendx = self.parent.myvertices[-1].x
-        else:
-            self.legendx = float(posx)
-
-        if posy == _('Not used'):
-            pass
-        elif posy.lower() == _('median'):
-            # valeur mediane selon x et y
-            xy = self.parent.asnparray()
-            self.legendy = np.median(xy[:,1])
-        elif posy.lower() == _('mean'):
-            # valeur moyenne selon x et y
-            xy = self.parent.asnparray()
-            self.legendy = np.mean(xy[:,1])
-        elif posy.lower() == _('min'):
-            # valeur minimale selon x et y
-            xy = self.parent.asnparray()
-            self.legendy = np.min(xy[:,1])
-        elif posy.lower() == _('max'):
-            # valeur maximale selon x et y
-            xy = self.parent.asnparray()
-            self.legendy = np.max(xy[:,1])
-        elif posy.lower() == _('first'):
-            self.legendy = self.parent.myvertices[0].y
-        elif posy.lower() == _('last'):
-            self.legendy = self.parent.myvertices[-1].y
-        else:
-            self.legendy = float(posy)
+        self.parent.set_legend_position(posx,posy)
 
         self.legendlength = props[('Legend','Length')]
         self.legendheight = props[('Legend','Height')]
@@ -816,9 +766,9 @@ class vectorproperties:
         move_step = props[('Move','Step [m]')]
 
         if posx != 99999. and posy != 99999.:
-            self.parent._start_move = (posx,posy)
+            self.parent._move_start = (posx,posy)
         else:
-            self.parent._start_move = None
+            self.parent._move_start = None
 
         if move_step != 99999.:
             self.parent._move_step = move_step
@@ -959,68 +909,7 @@ if :\n \
         Then, add the current properties to the UI
         """
         self._defaultprop()
-
-        self.myprops[('Draw','Color')]      = getRGBfromI(self.color)
-        self.myprops[('Draw','Width')]      = self.width
-        self.myprops[('Draw','Style')]      = self.style
-        self.myprops[('Draw','Closed')]     = self.closed
-        self.myprops[('Draw','Filled')]     = self.filled
-        self.myprops[('Draw','Transparent')]= self.transparent
-        self.myprops[('Draw','Alpha')]          = self.alpha
-        self.myprops[('Draw','Flash')]      = self.flash
-
-        self.myprops[('Legend','Visible')]  = self.legendvisible
-        self.myprops[('Legend','Text')]     = self.legendtext
-        self.myprops[('Legend','Relative position')]=self.legendrelpos
-        self.myprops[('Legend','X')]        = self.legendx
-        self.myprops[('Legend','Y')]        = self.legendy
-        self.myprops[('Legend','Bold')]     = self.legendbold
-        self.myprops[('Legend','Italic')]   = self.legenditalic
-
-        self.myprops[('Legend','Font name')]= self._convert_fontname2int(self.legendfontname)
-
-        self.myprops[('Legend','Font size')]= self.legendfontsize
-        self.myprops[('Legend','Color')]    = getRGBfromI(self.legendcolor)
-        self.myprops[('Legend','Underlined')]= self.legendunderlined
-
-        self.myprops[('Legend','Length')]     = self.legendlength
-        self.myprops[('Legend','Height')]     = self.legendheight
-        self.myprops[('Legend','Priority')]   = self.legendpriority
-        self.myprops[('Legend','Orientation')]= self.legendorientation
-
-        self.myprops[('Image','Attached image')] = str(self.attachedimage)
-        self.myprops[('Image','To show')] = self.imagevisible
-
-        if self.parent._rotation_center is not None:
-            self.myprops[('Rotation','center X')] = self.parent._rotation_center[0]
-            self.myprops[('Rotation','Center Y')] = self.parent._rotation_center[1]
-        else:
-            self.myprops[('Rotation','Center X')] = 99999.
-            self.myprops[('Rotation','Center Y')] = 99999.
-
-        if self.parent._rotation_step is not None:
-            self.myprops[('Rotation','Step [degree]')] = self.parent._rotation_step
-        else:
-            self.myprops[('Rotation','Step [degree]')] = 99999.
-
-        self.myprops[('Rotation', 'Angle [degree]')] = 0.
-
-        if self.parent._start_move is not None:
-            self.myprops[('Move','Start X')] = self.parent._start_move[0]
-            self.myprops[('Move','Start Y')] = self.parent._start_move[1]
-        else:
-            self.myprops[('Move','Start X')] = 99999.
-            self.myprops[('Move','Start Y')] = 99999.
-
-        if self.parent._move_step is not None:
-            self.myprops[('Move','Step [m]')] = self.parent._move_step
-        else:
-            self.myprops[('Move','Step [m]')] = 99999.
-
-        self.myprops[('Move','Delta X')] = 0.
-        self.myprops[('Move','Delta Y')] = 0.
-
-        self.myprops.Populate()
+        self.update_myprops()
         self.myprops.Layout()
         self.myprops.SetSizeHints(500,800)
         self.myprops.Show()
@@ -1068,7 +957,70 @@ if :\n \
             else:
                 return 'Arial'
 
+    def update_myprops(self):
+        """ Update the properties """
+
+        if self.myprops is not None:
+            self.myprops[('Draw','Color')]      = getRGBfromI(self.color)
+            self.myprops[('Draw','Width')]      = self.width
+            self.myprops[('Draw','Style')]      = self.style
+            self.myprops[('Draw','Closed')]     = self.closed
+            self.myprops[('Draw','Filled')]     = self.filled
+            self.myprops[('Draw','Transparent')]= self.transparent
+            self.myprops[('Draw','Alpha')]          = self.alpha
+            self.myprops[('Draw','Flash')]      = self.flash
+
+            self.myprops[('Legend','Visible')]  = self.legendvisible
+            self.myprops[('Legend','Text')]     = self.legendtext
+            self.myprops[('Legend','Relative position')]=self.legendrelpos
+            self.myprops[('Legend','X')]        = self.legendx
+            self.myprops[('Legend','Y')]        = self.legendy
+            self.myprops[('Legend','Bold')]     = self.legendbold
+            self.myprops[('Legend','Italic')]   = self.legenditalic
+
+            self.myprops[('Legend','Font name')]= self._convert_fontname2int(self.legendfontname)
+
+            self.myprops[('Legend','Font size')]= self.legendfontsize
+            self.myprops[('Legend','Color')]    = getRGBfromI(self.legendcolor)
+            self.myprops[('Legend','Underlined')]= self.legendunderlined
+
+            self.myprops[('Legend','Length')]     = self.legendlength
+            self.myprops[('Legend','Height')]     = self.legendheight
+            self.myprops[('Legend','Priority')]   = self.legendpriority
+            self.myprops[('Legend','Orientation')]= self.legendorientation
+
+            self.myprops[('Image','Attached image')] = str(self.attachedimage)
+            self.myprops[('Image','To show')] = self.imagevisible
+
+            if self.parent._rotation_center is not None:
+                self.myprops[('Rotation','center X')] = self.parent._rotation_center[0]
+                self.myprops[('Rotation','Center Y')] = self.parent._rotation_center[1]
+            else:
+                self.myprops[('Rotation','Center X')] = 99999.
+                self.myprops[('Rotation','Center Y')] = 99999.
 
+            if self.parent._rotation_step is not None:
+                self.myprops[('Rotation','Step [degree]')] = self.parent._rotation_step
+            else:
+                self.myprops[('Rotation','Step [degree]')] = 99999.
+
+            self.myprops[('Rotation', 'Angle [degree]')] = 0.
+
+            if self.parent._move_start is not None:
+                self.myprops[('Move','Start X')] = self.parent._move_start[0]
+                self.myprops[('Move','Start Y')] = self.parent._move_start[1]
+            else:
+                self.myprops[('Move','Start X')] = 99999.
+                self.myprops[('Move','Start Y')] = 99999.
+
+            if self.parent._move_step is not None:
+                self.myprops[('Move','Step [m]')] = self.parent._move_step
+            else:
+                self.myprops[('Move','Step [m]')] = 99999.
+
+            self.myprops[('Move','Delta X')] = 0.
+            self.myprops[('Move','Delta Y')] = 0.
+            self.myprops.Populate()
 class vector:
     """
     Objet de gestion d'informations vectorielles
@@ -1091,7 +1043,8 @@ class vector:
     mytree:TreeListCtrl
     myitem:TreeItemId
 
-    def __init__(self, lines:list=[], is2D=True, name='NoName', parentzone:"zone"=None, fromshapely=None) -> None:
+    def __init__(self, lines:list=[], is2D=True, name='NoName',
+                 parentzone:"zone"=None, fromshapely=None, fromnumpy:np.ndarray = None) -> None:
         """
 
         :param lines: utile pour lecture de fichier
@@ -1102,8 +1055,8 @@ class vector:
         """
 
         self.myname=''
-        self.is2D = is2D
-        self.closed=False
+        self.is2D = is2D  # Force a 2D interpretation of the vertices, even if a z coordinate is present.
+        # self.closed=False # True if the vector is a polygon. !! The last vertex is not necessarily the same as the first one. In this case, some routines will add a virtual segment at the end. !!
 
         self.mytree = None
 
@@ -1154,7 +1107,7 @@ class vector:
             self.myprop=vectorproperties(parent=self)
 
         self._cache_vertices = None
-        self._start_move = None
+        self._move_start = None
         self._move_step = None
 
         self._rotation_center = None
@@ -1172,6 +1125,106 @@ class vector:
         if fromshapely is not None:
             self.import_shapelyobj(fromshapely)
 
+        if fromnumpy is not None:
+            self.add_vertices_from_array(fromnumpy)
+
+    def set_legend_text(self, text:str):
+        """ Set the legend text """
+
+        if text is _('Not used'):
+            pass
+        elif text == _('name'):
+            self.myprop.legendtext = self.myname
+        elif text == _('first z'):
+            if self.nbvertices>0:
+                self.myprop.legendtext = str(self.myvertices[0].z)
+            else:
+                self.myprop.legendtext = ''
+        elif text == _('length2D'):
+            self.myprop.legendtext = str(self.length2D)
+        elif text == _('length3D'):
+            self.myprop.legendtext = str(self.length3D)
+        elif text == _('id'):
+            if self.parentzone is not None:
+                self.myprop.legendtext = str(self.parentzone.myvectors.index(self))
+            else:
+                self.myprop.legendtext = ''
+        else:
+            self.myprop.legendtext = str(text)
+
+        self.myprop.update_myprops()
+
+    def set_legend_position(self, x:str | float, y:str | float):
+        """ Set the legend position """
+
+        if isinstance(x, str):
+            if x == _('Not used'):
+                pass
+            elif x.lower() == _('median'):
+                # valeur mediane selon x et y
+                xy = self.asnparray()
+                self.myprop.legendx = np.median(xy[:,0])
+            elif x.lower() == _('mean'):
+                # valeur moyenne selon x et y
+                xy = self.asnparray()
+                self.myprop.legendx = np.mean(xy[:,0])
+            elif x.lower() == _('min'):
+                # valeur minimale selon x et y
+                xy = self.asnparray()
+                self.myprop.legendx = np.min(xy[:,0])
+            elif x.lower() == _('max'):
+                # valeur maximale selon x et y
+                xy = self.asnparray()
+                self.myprop.legendx = np.max(xy[:,0])
+            elif x.lower() == _('first'):
+                self.myprop.legendx = self.myvertices[0].x
+            elif x.lower() == _('last'):
+                self.myprop.legendx = self.myvertices[-1].x
+            else:
+                self.myprop.legendx = float(x)
+        elif isinstance(x, float):
+            self.myprop.legendx = x
+
+        if isinstance(y, str):
+            if y == _('Not used'):
+                pass
+            elif y.lower() == _('median'):
+                # valeur mediane selon x et y
+                xy = self.asnparray()
+                self.myprop.legendy = np.median(xy[:,1])
+            elif y.lower() == _('mean'):
+                # valeur moyenne selon x et y
+                xy = self.asnparray()
+                self.myprop.legendy = np.mean(xy[:,1])
+            elif y.lower() == _('min'):
+                # valeur minimale selon x et y
+                xy = self.asnparray()
+                self.myprop.legendy = np.min(xy[:,1])
+            elif y.lower() == _('max'):
+                # valeur maximale selon x et y
+                xy = self.asnparray()
+                self.myprop.legendy = np.max(xy[:,1])
+            elif y.lower() == _('first'):
+                self.myprop.legendy = self.myvertices[0].y
+            elif y.lower() == _('last'):
+                self.myprop.legendy = self.myvertices[-1].y
+            else:
+                self.myprop.legendy = float(y)
+        elif isinstance(y, float):
+            self.myprop.legendy = y
+
+        self.myprop.update_myprops()
+
+    @property
+    def closed(self) -> bool:
+        return self.myprop.closed
+
+    @closed.setter
+    def closed(self, value:bool):
+        self.myprop.closed = value
+        if self.myprop.myprops is not None:
+            self.myprop.myprops.Populate()
+
     def set_cache(self):
         """ Set the cache for the vertices """
 
@@ -1723,7 +1776,12 @@ class vector:
 
         if is_open:
             self.add_vertex(self.myvertices[0])
-            self.closed=True
+        self.closed=True
+
+    def force_to_close(self):
+        """ Force the vector to be closed """
+
+        self.close_force()
 
     def _nblines(self):
         """
@@ -1838,15 +1896,21 @@ class vector:
 
         return len(not_in_use) > 0
 
-    def get_subpolygons(self):
+    def get_subpolygons(self) -> list[list[wolfvertex]]:
         """
         Return a list of polygons from the vector
 
         If the vector has no interior, the list contains the whole vector as a polygon
         """
 
+        if self.nbvertices == 0:
+            return []
+
         if self.myprop.filled:
-            return [self.myvertices]
+            if self.myprop.closed and (self.myvertices[0].x != self.myvertices[-1].x or self.myvertices[0].y != self.myvertices[-1].y):
+                return [self.myvertices + [self.myvertices[0]]]
+            else:
+                return [self.myvertices]
 
         else:
             if self.has_interior:
@@ -1870,7 +1934,10 @@ class vector:
 
                 return alls
             else:
-                return [self.myvertices]
+                if self.myprop.closed and (self.myvertices[0].x != self.myvertices[-1].x or self.myvertices[0].y != self.myvertices[-1].y):
+                    return [self.myvertices + [self.myvertices[0]]]
+                else:
+                    return [self.myvertices]
 
     def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
         """
@@ -2991,6 +3058,45 @@ class vector:
 
         return cloud_inside, cloud_outside
 
+
+    def check_if_closed(self) -> bool:
+        """
+        Check if the vector is closed
+        """
+
+        return not self.check_if_open()
+
+
+    def check_if_open(self) -> bool:
+        """ Check if the vector is open """
+
+        is_open = not((self.myvertices[-1] is self.myvertices[0]) or \
+            (self.myvertices[-1].x==self.myvertices[0].x and \
+             self.myvertices[-1].y==self.myvertices[0].y))
+
+        if not self.is2D :
+            is_open = is_open or self.myvertices[-1].z!=self.myvertices[0].z
+
+        self.closed = not is_open
+
+        return is_open
+
+    @property
+    def surface(self):
+        """
+        Compute the surface of the vector
+        """
+
+        if self.closed:
+            return self.asshapely_pol().area
+        else:
+            return 0.
+
+    @property
+    def area(self):
+        """ Alias for surface """
+        return self.surface
+
 class zone:
     """
     Objet de gestion d'informations vectorielles
@@ -3034,7 +3140,7 @@ class zone:
         self.has_legend = False # indicate if at least one vector in the zone has a legend
         self.has_image  = False # indicate if at least one vector in the zone has an image
 
-        self._start_move = None # starting point for a move
+        self._move_start = None # starting point for a move
         self._move_step = None  # step for a move
         self._rotation_center = None # center of rotation
         self._rotation_step = None   # step for rotation
@@ -3072,6 +3178,27 @@ class zone:
             # Object can be created from a shapely object
             self.import_shapelyobj(fromshapely)
 
+    def set_legend_text(self, text:str):
+        """
+        Set the legend text for the zone
+        """
+
+        for curvect in self.myvectors:
+            curvect.set_legend_text(text)
+
+    def set_legend_position(self, x, y):
+        """
+        Set the legend position for the zone
+        """
+
+        for curvect in self.myvectors:
+            curvect.set_legend_position(x, y)
+
+    @property
+    def area(self):
+        """ Compute the area of the zone """
+        return sum([curvec.surface for curvec in self.myvectors])
+
     def set_cache(self):
         """
         Set the cache for the zone and all its vectors
@@ -3086,7 +3213,7 @@ class zone:
         for curvect in self.myvectors:
             curvect.clear_cache()
 
-        self._start_move = None
+        self._move_start = None
         self._move_step = None
         self._rotation_center = None
         self._rotation_step = None
@@ -3436,6 +3563,11 @@ class zone:
 
         inside : True = le point est contenu ; False = le point le plus proche
         """
+
+        if self.nbvectors==0:
+            logging.warning(_('No vector in zone -- {}').format(self.myname))
+            return
+
         curvect:vector
         self.selected_vectors.clear()
 
@@ -4932,7 +5064,7 @@ class Zones(wx.Frame, Element_To_Draw):
         self.ty=ty
         self.myzones=[]
 
-        self._start_move = None
+        self._move_start = None
         self._move_step = None
         self._rotation_center = None
         self._rotation_step = None
@@ -5087,6 +5219,21 @@ class Zones(wx.Frame, Element_To_Draw):
                 if names.count(curzone.myname)>1:
                     curzone.myname += '_'+str(idx)
 
+    def set_legend_text(self, text:str):
+        """
+        Set the legend text for the zones
+        """
+
+        for curzone in self.myzones:
+            curzone.set_legend_text(text)
+
+    def set_legend_position(self, x, y):
+        """
+        Set the legend position for the zones
+        """
+
+        for curzone in self.myzones:
+            curzone.set_legend_position(x, y)
 
     @property
     def nbzones(self):
@@ -7337,9 +7484,9 @@ class Zones(wx.Frame, Element_To_Draw):
         posx = self._myprops[('Move','Start X')]
         posy = self._myprops[('Move','Start Y')]
         if posx != 99999. and posy != 99999.:
-            self._start_move = (posx,posy)
+            self._move_start = (posx,posy)
         else:
-            self._start_move = None
+            self._move_start = None
 
         step = self._myprops[('Move','Step [m]')]
         if step != 99999.:
@@ -7408,9 +7555,9 @@ class Zones(wx.Frame, Element_To_Draw):
 
         self._myprops['Rotation', 'Angle [degree]'] = 0.
 
-        if self._start_move is not None:
-            self._myprops[('Move', 'Start X')] = self._start_move[0]
-            self._myprops[('Move', 'Start Y')] = self._start_move[1]
+        if self._move_start is not None:
+            self._myprops[('Move', 'Start X')] = self._move_start[0]
+            self._myprops[('Move', 'Start Y')] = self._move_start[1]
         else:
             self._myprops[('Move', 'Start X')] = 99999.
             self._myprops[('Move', 'Start Y')] = 99999.