wolfhece 2.2.44__py3-none-any.whl → 2.2.46__py3-none-any.whl

wolfhece/PyCrosssections.py

@@ -728,9 +728,9 @@ class profile(vector):
 
         myxyz = self.parent.gridlaz.scan(mybounds)
 
-        prep_poly = prepare(mypoly)
-        mytests = [prep_poly.contains(Point(cur[:3])) for cur in myxyz]
-        destroy_prepared(prep_poly)
+        prepare(mypoly)
+        mytests = [mypoly.contains(Point(cur[:3])) for cur in myxyz]
+        destroy_prepared(mypoly)
 
         self.usedlaz = np.asarray(myxyz[mytests])
 
@@ -2170,7 +2170,7 @@ class profile(vector):
                 ds = min(curarray.dx,curarray.dy)
                 nb = int(np.ceil(length/ds*2))
 
-                alls = np.linspace(0,int(length),nb)
+                alls = np.linspace(0, length, nb, endpoint=True)
 
                 pts = [self.linestring.interpolate(curs) for curs in alls]
 
@@ -2227,6 +2227,25 @@ class profile(vector):
         if srd != -99999.:
             ax.plot(srd,yrd,'*g',alpha=alpha)
 
+    def _plot_only_cs_min_at_x0(self,
+                      fig:Figure=None, ax:Axes=None,
+                      label='', alpha=0.8, lw=1., style: str ='dashed',
+                      grid=True, col_ax: str = 'black'):
+
+        """ Plot only the cross section line on an existing axis.
+        We assume that the minimum elevation is at x=0.
+        """
+
+        x,y=self.get_sz()
+        x = x - x[np.argmin(y)]
+
+        ax.plot(x,y,color=col_ax,
+                lw=lw,
+                linestyle=style,
+                alpha=alpha,
+                label=label)
+
+
     def plot_cs(self,
                 fwl:float = None, show:bool = False, forceaspect:bool = True,
                 fig:Figure = None, ax:Axes = None,
@@ -2329,6 +2348,32 @@ class profile(vector):
 
         return sl,sb,sr,yl,yb,yr
 
+    def _plot_extremities(self, ax:plt.Axes, s:int = 50, colors:tuple[str, str] = ('blue', 'green')) -> None:
+        """
+        Plot the extremities of the cross-section on the given axes.
+        """
+        x_left = self[0].x
+        y_left = self[0].y
+        x_right = self[-1].x
+        y_right = self[-1].y
+
+        ax.scatter(x_left, y_left, color=colors[0], s=s, label='Left extremity')
+        ax.scatter(x_right, y_right, color=colors[1], s=s, label='Right extremity')
+        ax.legend()
+
+    def _plot_extremities_sz(self, ax:plt.Axes, s:int = 10, colors:tuple[str, str] = ('blue', 'green')) -> None:
+        """
+        Plot the extremities of the cross-section on the given axes.
+        """
+        x_left = 0. #self[0].x
+        y_left = self[0].z
+        x_right = self.length2D #self[-1].x
+        y_right = self[-1].z
+
+        ax.scatter(x_left, y_left, color=colors[0], s=s)
+        ax.scatter(x_right, y_right, color=colors[1], s=s)
+        ax.legend()
+
 
 class crosssections(Element_To_Draw):
     """
@@ -2395,6 +2440,9 @@ class crosssections(Element_To_Draw):
 
         """
 
+        self.dirlaz = None
+        self.gridlaz = None
+
         assert format in ['2000','2022','2025_xlsx','vecz','sxy', 'zones'], _('Format %s not supported!')%format
 
         super().__init__(idx=idx, plotted= plotted, mapviewer=mapviewer, need_for_wx=False)
@@ -2414,7 +2462,7 @@ class crosssections(Element_To_Draw):
         self.myzones=None
         self.myzone=None
 
-        if isinstance(dirlaz,str):
+        if isinstance(dirlaz, (str, Path)):
             if path.exists(dirlaz):
                 self.dirlaz=dirlaz
                 self.gridlaz = xyz_laz_grids(self.dirlaz)
@@ -2462,7 +2510,15 @@ class crosssections(Element_To_Draw):
         self.cloud_all = None
 
         self.multils = None
+
+        self.sorted:dict[str, dict['sorted': list[vector], 'support':LineString]]
+        # Dictionnaire des sections triées, peut contenir plusieurs tris selon différents vecteurs de tri.
+        # Ceci est utile pour créer des sous-groupes de sections le long d'un cours d'eau ou de cours d'eau différents.
+        # Chaque entrée est un dictionnaire avec les clés:
+        #     - 'sorted' : liste des sections triées
+        #     - 'support': LineString support du tri
         self.sorted = {}
+
         self.plotted = False
 
         if isinstance(lines, pd.DataFrame): # Format is '2025_xlsx'
@@ -2808,11 +2864,7 @@ class crosssections(Element_To_Draw):
                     curdict['right_down'] = None
 
                     index+=1
-                    curdict['cs']=profile(name=curvec.myname, parent=self)
-                    cursect:profile
-                    cursect=curdict['cs']
-
-                    cursect.myvertices = curvec.myvertices.copy()
+                    curdict['cs']=profile(name=curvec.myname, parent=self, data_sect=curvec.myvertices.copy())
 
         self.verif_bed()
         self.find_minmax(True)
@@ -2916,16 +2968,38 @@ class crosssections(Element_To_Draw):
                     keys = [curprof.myname for curprof in curlist]
                     if which_prof in keys:
                         return curlist[keys.index(which_prof)]
+                    else:
+                        logging.error(_('Profile %s not found in sorted dictionaries!')%which_prof)
+                        return None
+
                 elif isinstance(which_prof, int):
+                    if which_prof<0 or which_prof>=len(curlist):
+                        logging.error(_('Index %d out of range (0 to %d)!')%(which_prof,len(curlist)-1))
+                        return None
+
                     return curlist[which_prof]
+            else:
+                logging.error(_('Dictionary %s not found in sorted dictionaries!')%which_dict)
+                return None
 
         else:
             if isinstance(which_prof, str):
                 keys = self.myprofiles.keys()
                 if which_prof in keys:
                     return self.myprofiles[which_prof]['cs']
+                else:
+                    logging.error(_('Profile %s not found!')%which_prof)
+                    return None
+
             elif isinstance(which_prof, int):
+                if which_prof<0 or which_prof>=len(self.myprofiles):
+                    logging.error(_('Index %d out of range (0 to %d)!')%(which_prof,len(self.myprofiles)-1))
+                    return None
+
                 return self.myprofiles[list(self.myprofiles.keys())[which_prof]]['cs']
+            else:
+                logging.error(_('which_prof must be a string or an integer!'))
+                return None
 
         return None
 
@@ -2961,6 +3035,103 @@ class crosssections(Element_To_Draw):
 
         self.cloud.find_minmax(True)
 
+    def create_vector_from_centers(self, which_dict:str=None):
+        """ Create a vector from the centers of the cross-sections."""
+
+        if which_dict is not None:
+            if which_dict not in self.sorted.keys():
+                logging.error(_('Dictionary %s not found in sorted dictionaries!')%which_dict)
+                return vector(name='center', is2D=False)
+
+            curslist = self.sorted[which_dict]['sorted']
+            centers = [curs.linestring.interpolate(0.5, normalized=True) for curs in curslist]
+        else:
+            centers = [curs['cs'].linestring.interpolate(0.5, normalized=True) for idx,curs in self.myprofiles.items()]
+
+        newvec = vector(name='center', is2D=False)
+        newvec.add_vertex([wolfvertex(pt.x, pt.y) for pt in centers])
+        return newvec
+
+    def create_vector_from_lefts(self, copy:bool=True, which_dict:str=None):
+        """ Create a vector from the left (first vertex) of the cross-sections.
+
+        :param copy: If True, create a copy of the left vertices. If False, use the original vertices.
+        :type copy: bool
+        """
+
+        if which_dict is not None:
+            if which_dict not in self.sorted.keys():
+                logging.error(_('Dictionary %s not found in sorted dictionaries!')%which_dict)
+                return vector(name='left', is2D=False)
+
+            curslist = self.sorted[which_dict]['sorted']
+
+        else:
+            curslist = self.myprofiles.values()
+
+        if copy:
+            lefts = [curs['cs'][0].copy() for curs in curslist]
+        else:
+            lefts = [curs['cs'][0] for curs in curslist]
+
+        newvec = vector(name='left', is2D=False)
+        newvec.add_vertex(lefts)
+        return newvec
+
+    def create_vector_from_rights(self, copy:bool=True, which_dict:str=None):
+        """ Create a vector from the right (last vertex) of the cross-sections.
+
+        :param copy: If True, create a copy of the right vertices. If False, use the original vertices.
+        :type copy: bool
+        """
+
+        if which_dict is not None:
+            if which_dict not in self.sorted.keys():
+                logging.error(_('Dictionary %s not found in sorted dictionaries!')%which_dict)
+                return vector(name='right', is2D=False)
+
+            curslist = self.sorted[which_dict]['sorted']
+        else:
+            curslist = self.myprofiles.values()
+
+        if copy:
+            rights = [curs['cs'][-1].copy() for curs in curslist]
+        else:
+            rights = [curs['cs'][-1] for curs in curslist]
+
+        newvec = vector(name='right', is2D=False)
+        newvec.add_vertex(rights)
+        return newvec
+
+    def check_left_right_coherence(self):
+        """ Check the coherence of left and right banks in the cross-sections.
+
+        :return: -2 if both banks intersect the center line, -1 if only left bank intersects, 1 if only right bank intersects, 0 if no intersection.
+        :rtype: int
+        """
+
+        center = self.create_vector_from_centers()
+        left = self.create_vector_from_lefts(copy=False)
+        right = self.create_vector_from_rights(copy=False)
+
+        # If the left bank intersects the center line, we have a problem.
+        # If it is the case, the right bank must intersect the center line too.
+
+        if center.linestring.intersects(left.linestring):
+            if not center.linestring.intersects(right.linestring):
+                logging.warning(_('Left bank intersects the center line, but right bank does not!'))
+                return -1
+            else:
+                logging.info(_('Left and right banks intersect the center line. Please check the profiles.'))
+                return -2
+        else:
+            if center.linestring.intersects(right.linestring):
+                logging.warning(_('Right bank intersects the center line, but left bank does not!'))
+                return 1
+            else:
+                logging.info(_('Left and right banks do not intersect the center line.'))
+        return 0
+
     def create_zone_from_banksbed(self):
         """ Create a zone from the banks and bed of the cross-sections."""
 
@@ -3012,13 +3183,13 @@ class crosssections(Element_To_Draw):
                     curlinkprop = myvec.myname
 
                 myvecls = myvec.asshapely_ls()
-                prepls=prepare(myvecls)
+                prepare(myvecls)
 
                 for cursname in self.myprofiles.values():
                     curs:profile
                     curs=cursname['cs']
                     cursls = curs.asshapely_ls()
-                    if prepls.intersects(cursls):
+                    if myvecls.intersects(cursls):
                         pt = myvecls.intersection(cursls)
 
                         if pt.geom_type=='MultiPoint':
@@ -3041,7 +3212,7 @@ class crosssections(Element_To_Draw):
                             curs.refpoints[curlinkprop]=myvert
 
                         cursname[curlinkprop]=myvert
-                destroy_prepared(prepls)
+                destroy_prepared(myvecls)
 
         self.update_cloud()
 
@@ -3221,8 +3392,8 @@ class crosssections(Element_To_Draw):
 
     def get_upstream(self) -> dict['cs':profile, 'index':int, 'left':wolfvertex | None, 'bed':wolfvertex | None, 'right':wolfvertex | None, 'left_down':wolfvertex | None, 'right_down':wolfvertex | None]:
         """ Get the upstream profile of the cross-sections."""
-        curprof:profile
-        curprof=self.myprofiles[list(self.myprofiles.keys())[0]]['cs']
+
+        curprof = self[0]
 
         while curprof.up is not curprof:
             curprof = curprof.up
@@ -3231,8 +3402,8 @@ class crosssections(Element_To_Draw):
 
     def get_downstream(self) -> dict['cs':profile, 'index':int, 'left':wolfvertex | None, 'bed':wolfvertex | None, 'right':wolfvertex | None, 'left_down':wolfvertex | None, 'right_down':wolfvertex | None]:
         """ Get the downstream profile of the cross-sections. """
-        curprof:profile
-        curprof=self.myprofiles[list(self.myprofiles.keys())[0]]['cs']
+
+        curprof = self[0]
 
         while curprof.down is not curprof:
             curprof = curprof.down
@@ -3427,36 +3598,56 @@ class crosssections(Element_To_Draw):
 
         self.multils = self.asshapely_ls()
 
-    def sort_along(self,vecsupport:LineString,name:str,downfirst=True):
+    def sort_along(self, vecsupport:LineString | vector, name:str, downfirst=True):
         """
         Sélectionne les sections qui intersectent un vecteur support
         et les trie selon l'abscisse curviligne
         """
 
+        if isinstance(vecsupport, vector):
+            vecsupport = vecsupport.linestring
+            to_destroy = False
+        elif isinstance(vecsupport, LineString):
+            prepare(vecsupport) #Prepare le vecteur support aux opérations récurrentes
+            to_destroy = True
+        else:
+            raise TypeError(_('vecsupport must be a LineString or a vector.'))
+
         curdict = self.sorted[name]={}
         curdict['support'] = vecsupport
         mysorted = curdict['sorted']  = []
         length = vecsupport.length
 
-        prepsup=prepare(vecsupport) #Prepare le vecteur support aux opérations récurrentes
         curvect:profile
         for idx,curv in self.myprofiles.items():
             #bouclage sur les sections
             curvect=curv['cs']
             #obtention de la section sous forme d'un objet Shapely
-            myline = curvect.asshapely_ls()
-            if prepsup.intersects(myline):
-                #le vecteur intersecte --> on calcule le point d'intersection
+            myline = curvect.linestring
+            if vecsupport.intersects(myline):
+                # le vecteur intersecte --> on calcule le point d'intersection
                 myintersect = vecsupport.intersection(myline)
+
+                if myintersect.geom_type=='MultiPoint':
+                    myintersect=myintersect.geoms[0]
+                elif myintersect.geom_type=='GeometryCollection':
+                    myintersect=myintersect.centroid
+
                 #on projette l'intersection sur le support pour trouver l'abscisse curvi
-                mydist = vecsupport.project(myintersect)
+                try:
+                    mydist = vecsupport.project(myintersect)
+                except:
+                    pass
+
                 #on ajoute le vecteur à la liste
                 mysorted.append(curvect)
                 if downfirst:
                     curvect.s = length - mydist
                 else:
                     curvect.s = mydist
-        destroy_prepared(prepsup)
+
+        if to_destroy:
+            destroy_prepared(vecsupport)
 
         #on trie le résultat en place
         mysorted.sort(key=lambda x:x.s)

wolfhece/PyDraw.py

@@ -484,7 +484,7 @@ class Memory_Views_GUI(wx.Frame):
         self.CenterOnScreen()
 
         icon = wx.Icon()
-        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent / "apps/wolf.ico"
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self.SetIcon(icon)
 
@@ -696,7 +696,7 @@ class Colors_1to9(wx.Frame):
         self.Bind(wx.EVT_BUTTON, self.OnSave, cmdSave)
 
         icon = wx.Icon()
-        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent / "apps/wolf.ico"
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self.SetIcon(icon)
 
@@ -967,7 +967,7 @@ class Sim_Explorer(wx.Frame):
         self.Fit()
         self.Show()
 
-        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf_logo2.bmp")))
+        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf.ico")))
 
         self._set_all(0)
 
@@ -1216,7 +1216,7 @@ class Sim_Explorer(wx.Frame):
 
         self._slider_steps.SetMax(nb)
         self._step_idx.Set([str(i) for i in range(1,nb+1)])
-        self._step_time.Set(['{:.3f} - {}'.format(i, datetime.strftime(self._starting_date + timedelta(seconds=i), '%Y-%m-%d %H:%M:%S')) for i in self._all_times_steps[0]])
+        self._step_time.Set(['{:.3f} - {}'.format(i, datetime.strftime(self._starting_date + timedelta(seconds=float(i)), '%Y-%m-%d %H:%M:%S')) for i in self._all_times_steps[0]])
         self._step_num.Set([str(i) for i in self._all_times_steps[1]])
 
 
@@ -1338,7 +1338,7 @@ class Sim_VideoCreation(wx.Dialog):
         self.tc9.Bind(wx.EVT_CHOICE, self.OnValidate)
 
         icon = wx.Icon()
-        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent / "apps/wolf.ico"
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self.SetIcon(icon)
         self.CenterOnScreen()
@@ -1516,7 +1516,7 @@ class Drowning_Explorer(wx.Frame):
         self.Fit()
         self.Show()
 
-        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf_logo2.bmp")))
+        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf.ico")))
 
         self._set_all(0)
 
@@ -1800,7 +1800,7 @@ class Select_Begin_end_interval_step(wx.Dialog):
 
         self.CenterOnScreen()
 
-        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf_logo2.bmp")))
+        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf.ico")))
 
         self.Show()
 
@@ -1930,7 +1930,7 @@ class Precomputed_DEM_DTM_Dialog(wx.Dialog):
 
         self.CenterOnScreen()
 
-        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf_logo2.bmp")))
+        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf.ico")))
 
         self.Show()
 
@@ -13952,6 +13952,10 @@ class WolfMapViewer(wx.Frame):
             self.active_vector.find_minmax()
             self.active_zone.find_minmax()
 
+            # Update the ogl list
+            self.active_zone.reset_listogl()
+            self.active_vector.reset_linestring()
+
         elif self.action == 'offset/scale image':
 
             if self.active_vector is None:
@@ -14074,7 +14078,7 @@ class WolfMapViewer(wx.Frame):
             if self.active_vertex is None:
                 self.active_vertex = self.active_vector.find_nearest_vert(x, y)
             else:
-                self.active_vertex.limit2bounds(self.active_vector.mylimits)
+                self.active_vertex.limit2bounds(self.active_vector._mylimits)
 
                 if ctrl:
                     if self.active_array is not None:
@@ -14927,6 +14931,9 @@ class WolfMapViewer(wx.Frame):
                     self.active_vector.myvertices[-1].x = x
                     self.active_vector.myvertices[-1].y = y
 
+                    self.active_vector.reset_linestring()
+                    self.active_vector.parentzone.reset_listogl()
+
             if self.action == 'modify vertices' or \
                self.action == 'insert vertices':
                 if self.active_vertex is not None:
@@ -14955,7 +14962,7 @@ class WolfMapViewer(wx.Frame):
                         self.active_vertex.x = x
                         self.active_vertex.y = y
 
-                    self.active_vertex.limit2bounds(self.active_vector.mylimits)
+                    self.active_vertex.limit2bounds(self.active_vector._mylimits)
 
             elif self.action == 'dynamic parallel':
                 self.active_zone.parallel_active(self.dynapar_dist)
@@ -15544,7 +15551,7 @@ class WolfMapViewer(wx.Frame):
             frame.SetSizer(sizer)
 
             icon = wx.Icon()
-            icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+            icon_path = Path(__file__).parent / "apps/wolf.ico"
             icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
             frame.SetIcon(icon)
 

wolfhece/PyGui.py

@@ -168,7 +168,7 @@ class MapManager(GenMapManager):
 
         icon = wx.Icon()
 
-        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent / "apps/wolf.ico"
 
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
 

wolfhece/PyVertexvectors.py

@@ -1160,7 +1160,7 @@ if :\n \
         self.myprops.SetTitle(_('Vector properties - {}'.format(self.parent.myname)))
 
         icon = wx.Icon()
-        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon_path = Path(__file__).parent / "apps/wolf.ico"
         icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
         self.myprops.SetIcon(icon)
 
@@ -1347,7 +1347,7 @@ class vector:
         self.xmax=-99999.
         self.ymax=-99999.
 
-        self.mylimits = None
+        self._mylimits = None # ((xmin,xmax),(ymin,ymax)) --> Useful for wolf2dprev/block_contour objects
 
         self.textimage:Text_Image_Texture=None
 
@@ -1410,6 +1410,15 @@ class vector:
         if fromnumpy is not None:
             self.add_vertices_from_array(fromnumpy)
 
+    def _set_limits(self):
+        """ Retain current limits before any modification """
+
+        # Set self.minx, self.maxx), (self.miny, self.maxy)
+        # on basis of the self.myvertices
+
+        self.find_minmax()
+        self._mylimits = ((self.xmin, self.xmax), (self.ymin, self.ymax))
+
     def __add__(self, other:"vector") -> "vector":
         """ Add two vectors together """
         if not isinstance(other, vector):
@@ -1892,6 +1901,9 @@ class vector:
         Conversion des coordonnées en Polygon Shapely
         """
 
+        if self.nbvertices<3:
+            return Polygon()
+
         coords=self.asnparray()
         return Polygon(coords)
 
@@ -1900,6 +1912,9 @@ class vector:
         Conversion des coordonnées en Polygon Shapely
         """
 
+        if self.nbvertices<3:
+            return Polygon()
+
         coords=self.asnparray3d()
         return Polygon(coords)
 
@@ -1972,9 +1987,12 @@ class vector:
 
         if prepare_shapely:
             if linestring:
-                prepare(self._linestring)
+                if not self._linestring.is_empty:
+                    prepare(self._linestring)
             if polygon:
-                prepare(self._polygon)
+                # Test if empty or not
+                if not self._polygon.is_empty:
+                    prepare(self._polygon)
 
 
     def projectontrace(self, trace:"vector"):
@@ -2394,6 +2412,7 @@ class vector:
         """
 
         if self.nbvertices == 0:
+            logging.debug(_('Vector {} has no vertices -- cannot create subpolygons').format(self.myname))
             return []
 
         if self.myprop.filled:
@@ -2414,26 +2433,30 @@ class vector:
                     else:
                         return [self.myvertices]
                 else:
-                    xx, yy = self.polygon.exterior.xy
+                    if self.polygon.area == 0:
+                        logging.debug(_('Vector {} has no area -- cannot create triangulation').format(self.myname))
+                        return []
+                    else:
+                        xx, yy = self.polygon.exterior.xy
 
-                    # On translate les coordonnées pour éviter les erreurs de triangulation
-                    tr_x = np.array(xx).min()
-                    tr_y = np.array(yy).min()
+                        # On translate les coordonnées pour éviter les erreurs de triangulation
+                        tr_x = np.array(xx).min()
+                        tr_y = np.array(yy).min()
 
-                    xx = np.array(xx)-tr_x
-                    yy = np.array(yy)-tr_y
+                        xx = np.array(xx)-tr_x
+                        yy = np.array(yy)-tr_y
 
-                    geom = {'vertices' : [[x,y] for x,y in zip(xx[:-1],yy[:-1])], 'segments' : [[i,i+1] for i in range(len(xx)-2)]+[[len(xx)-2,0]]}
+                        geom = {'vertices' : [[x,y] for x,y in zip(xx[:-1],yy[:-1])], 'segments' : [[i,i+1] for i in range(len(xx)-2)]+[[len(xx)-2,0]]}
 
-                    try:
-                        delaunay = triangle.triangulate(geom, 'p')
-                        tri = []
-                        for curtri in delaunay['triangles']:
-                            # on traduit les coordonnées pour revenir dans le monde réel
-                            tri.append([wolfvertex(delaunay['vertices'][curtri[i]][0] + tr_x, delaunay['vertices'][curtri[i]][1] + tr_y) for i in range(3)])
-                        return tri
-                    except:
-                        pass
+                        try:
+                            delaunay = triangle.triangulate(geom, 'p')
+                            tri = []
+                            for curtri in delaunay['triangles']:
+                                # on traduit les coordonnées pour revenir dans le monde réel
+                                tri.append([wolfvertex(delaunay['vertices'][curtri[i]][0] + tr_x, delaunay['vertices'][curtri[i]][1] + tr_y) for i in range(3)])
+                            return tri
+                        except:
+                            pass
 
         else:
             if self.has_interior:
@@ -2585,7 +2608,7 @@ class vector:
 
             if self.myprop.filled:
 
-                ls = self.polygon
+                # ls = self.polygon
 
                 if False:
 
@@ -7912,7 +7935,7 @@ class Zones(wx.Frame, Element_To_Draw):
             self.SetSizer(box)
 
             icon = wx.Icon()
-            icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+            icon_path = Path(__file__).parent / "apps/wolf.ico"
             icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
             self.SetIcon(icon)
 

wolfhece/apps/version.py

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