wolfhece 2.2.35__py3-none-any.whl → 2.2.37__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -28,6 +28,7 @@ from matplotlib.figure import Figure
 from matplotlib import cm
 from matplotlib.colors import Colormap
 from matplotlib.tri import Triangulation as mpl_tri
+import warnings
 
 import struct
 import pyvista as pv
@@ -66,13 +67,17 @@ class Triangulation(Element_To_Draw):
         super().__init__(idx, plotted, mapviewer, need_for_wx)
 
         self.filename = ''
+
         self.tri= tri
         self.pts = pts
+
         self.id_list = -99999
 
         self.nb_tri = len(tri)
         self.nb_pts = len(pts)
 
+        self._used_tri = [True] * self.nb_tri
+
         self._move_start = None
         self._move_step = None  # step for a move
         self._rotation_center = None
@@ -408,10 +413,17 @@ class Triangulation(Element_To_Draw):
         else:
             glCallList(self.id_list)
 
-    def plot_matplotlib(self, ax:Axes, color='black', alpha=1., lw=1.5, **kwargs):
+    def plot_matplotlib(self, ax:Axes | tuple[Figure, Axes] = None, color='black', alpha=1., lw=1.5, **kwargs):
         """ Plot the triangulation in Matplotlib
         """
 
+        if isinstance(ax, tuple):
+            fig, ax = ax
+        elif ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
         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]]
@@ -420,6 +432,8 @@ class Triangulation(Element_To_Draw):
         else:
             logging.warning('No triangles to plot')
 
+        return fig, ax
+
     @property
     def mpl_triangulation(self) -> mpl_tri:
         """ Return the triangulation as a Matplotlib Triangulation object """
@@ -429,13 +443,24 @@ class Triangulation(Element_To_Draw):
             logging.warning('No triangles to plot')
             return None
 
-    def plot_matplotlib_3D(self, ax:Axes, color='black', alpha=0.2, lw=1.5, edgecolor='k', shade=True, **kwargs):
+    def plot_matplotlib_3D(self, ax:Axes | tuple[Figure, Axes] = None, color='black', alpha=0.2, lw=1.5, edgecolor='k', shade=True, **kwargs):
         """ Plot the triangulation in Matplotlib 3D
         """
+
         if self.nb_tri>0:
+            if isinstance(ax, tuple):
+                fig, ax = ax
+            elif ax is None:
+                fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+            else:
+                fig = ax.figure
+
             ax.plot_trisurf(self.mpl_triangulation, Z=self.pts[:,2], color=color, alpha=alpha, lw=lw, edgecolor=edgecolor, shade=shade, **kwargs)
+
+            return fig, ax
         else:
             logging.warning('No triangles to plot')
+            return None, None
 
     def find_minmax(self,force):
         """ Find the min and max of the triangulation
@@ -550,6 +575,45 @@ class Triangulation(Element_To_Draw):
             angle = np.round(angle/self._rotation_step)*self._rotation_step
 
         return self.rotate(-angle, center=self._rotation_center, use_cache=use_cache)
+
+    def _get_polygons(self) -> list[Polygon]:
+        """ Get the polygons from the triangulation """
+        polygons = []
+        for curtri in self.tri:
+            if len(curtri) == 3:
+                poly = Polygon([self.pts[curtri[0]][:2], self.pts[curtri[1]][:2], self.pts[curtri[2]][:2]])
+                if poly.is_valid:
+                    polygons.append(poly)
+                else:
+                    logging.warning('Invalid polygon found in triangulation: {}'.format(poly))
+            else:
+                logging.warning('Triangle with {} vertices found in triangulation: {}'.format(len(curtri), curtri))
+        return polygons
+
+    def unuse_triangles_containing_points(self, points:list[Point]):
+        """ Unuse triangles containing points """
+
+        polys = self._get_polygons()
+        for point in points:
+            for i, poly in enumerate(polys):
+                if poly.contains(point):
+                    self._used_tri[i] = False
+
+    def get_triangles_as_listwolfvertices(self, used_only:bool=True) -> list[list[wolfvertex]]:
+        """ Get the triangles as a list of wolfvertex objects """
+
+        triangles = []
+        for i, curtri in enumerate(self.tri):
+            if not used_only or (used_only and self._used_tri[i]):
+                if len(curtri) == 3:
+                    v1 = wolfvertex(self.pts[curtri[0]][0], self.pts[curtri[0]][1], self.pts[curtri[0]][2])
+                    v2 = wolfvertex(self.pts[curtri[1]][0], self.pts[curtri[1]][1], self.pts[curtri[1]][2])
+                    v3 = wolfvertex(self.pts[curtri[2]][0], self.pts[curtri[2]][1], self.pts[curtri[2]][2])
+                    triangles.append([v1, v2, v3])
+                else:
+                    logging.warning('Triangle with {} vertices found in triangulation: {}'.format(len(curtri), curtri))
+        return triangles
+
 class vectorproperties:
     """ Vector properties """
     used:bool
@@ -2212,6 +2276,81 @@ class vector:
 
         return len(not_in_use) > 0
 
+    def check_if_interior_exists(self):
+        """ Check if the vector has an interior and adapt in_use accordingly.
+
+        The verification is only made in 2D, as the interior is defined as a pair of segments that correspond exactly to the same coordinates.
+        Z coordinates are not taken into account in this verification.
+
+                """
+
+        xy = self.xy
+        if self.closed and (xy[0,0] == xy[-1,0] and xy[0,1] == xy[-1,1]):
+            # If the vector is closed, we remove the last vertex to avoid checking it
+            xy = xy[:-1]
+
+        xy_unique, inverse, count = np.unique(xy, return_inverse=True, return_counts=True, axis=0)
+
+        duplicate_found = False
+
+        if xy.shape[0] != xy_unique.shape[0]:
+            # There are duplicates, we need to test if the duplicate form a segment
+
+            # Find the duplicate indices
+            duplicate_indices = np.where(count > 1)[0]
+            # Find the inverse indices of the duplicates
+            duplicate_indices = np.where(np.isin(inverse, duplicate_indices))[0]
+            diff = np.diff(duplicate_indices)
+
+            for i in range(len(diff)):
+                # Set the in_use property to False for the vertices that are not used
+                if diff[i] == 1:
+                    self.myvertices[duplicate_indices[i+1]].in_use = False
+                    duplicate_found = True
+
+        if duplicate_found:
+            self.reset_linestring()
+            self._reset_listogl()
+
+
+    @property
+    def nb_interiors(self) -> int:
+        """ Return the number of interiors in the vector.
+
+        If the vector is filled, it returns the number of pairs of vertices not in use.
+        If the vector is not filled, it returns the number of vertices not in use.
+        """
+        not_in_use = [curvert for curvert in self.myvertices if not curvert.in_use]
+
+        return len(not_in_use) // 2 if self.myprop.filled else len(not_in_use)
+
+    @property
+    def _parts(self) -> "zone":
+        """ Return the parts of the vector as a zone.
+
+        Useful for creating subpolygons or triangulation.
+        """
+        self.find_minmax()
+
+        parts = zone()
+        current_part = vector()
+        for curvert in self.myvertices:
+            if curvert.in_use:
+                current_part.add_vertex(curvert)
+            else:
+                if current_part.nbvertices > 0:
+                    if parts.nbvectors > 0:
+                        current_part.force_to_close()
+                    parts.add_vector(current_part)
+                current_part = vector()
+
+        for curvert in current_part.myvertices:
+            parts.myvectors[0].add_vertex(curvert)
+
+        parts.myvectors[0].force_to_close()
+
+        return parts
+
     def get_subpolygons(self) -> list[list[wolfvertex]]:
         """
         Return a list of polygons from the vector
@@ -2223,10 +2362,41 @@ class vector:
             return []
 
         if self.myprop.filled:
-            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]]]
+            if self.has_interior:
+                #En attendant de lier WOLF-Fortran, on utilise la triangulation contrainte de la librairie Triangle -- https://rufat.be/triangle/
+
+                parts = self._parts
+                tri = parts.create_constrainedDelaunay(nb = 0)
+                centroid_interiors = [part.centroid for part in parts.myvectors[1:]]
+                tri.unuse_triangles_containing_points(centroid_interiors)
+
+                return tri.get_triangles_as_listwolfvertices()
+
             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]
+                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()
+
+                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]]}
+
+                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:
@@ -2396,28 +2566,35 @@ class vector:
                             logging.debug(_('Polygon not in Polygon'))
 
                 else:
-                    #En attendant de lier WOLF-Fortran, on utilise la triangulation contrainte de la librairie Triangle -- https://rufat.be/triangle/
-                    xx, yy = ls.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()
-
-                    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]]}
-
-                    try:
-                        delaunay = triangle.triangulate(geom, 'p')
-                        for curtri in delaunay['triangles']:
-                            glBegin(GL_POLYGON)
-                            for i in range(3):
-                                # on retraduit les coordonnées pour revenir dans le monde réel
-                                glVertex2d(delaunay['vertices'][curtri[i]][0] + tr_x, delaunay['vertices'][curtri[i]][1] + tr_y)
-                            glEnd()
-                    except:
-                        pass
+                    # #En attendant de lier WOLF-Fortran, on utilise la triangulation contrainte de la librairie Triangle -- https://rufat.be/triangle/
+                    # xx, yy = ls.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()
+
+                    # 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]]}
+
+                    # try:
+                    #     delaunay = triangle.triangulate(geom, 'p')
+                    #     for curtri in delaunay['triangles']:
+                    #         glBegin(GL_POLYGON)
+                    #         for i in range(3):
+                    #             # on retraduit les coordonnées pour revenir dans le monde réel
+                    #             glVertex2d(delaunay['vertices'][curtri[i]][0] + tr_x, delaunay['vertices'][curtri[i]][1] + tr_y)
+                    #         glEnd()
+                    # except:
+                    #     pass
+
+                    all_polys = self.get_subpolygons()
+                    for curpoly in all_polys:
+                        glBegin(GL_POLYGON)
+                        for curvertex in curpoly:
+                            glVertex2d(curvertex.x, curvertex.y)
+                        glEnd()
 
             else:
                 all_polys = self.get_subpolygons()
@@ -2488,19 +2665,32 @@ class vector:
             else:
                 logging.warning(_('No image texture available for plot'))
 
-    def plot_matplotlib(self, ax:plt.Axes):
+    def plot_matplotlib(self, ax:plt.Axes | tuple[Figure, Axes] = None):
         """
-        Plot Matplotlib
+        Plot Matplotlib - XY coordinates ONLY
+
+        :param ax: Matplotlib Axes to plot on or a tuple (fig, ax) where fig is the figure and ax is the axes.
+        If ax is None, a new figure and axes will be created.
         """
 
+        if isinstance(ax, tuple):
+            # if ax is a tuple, we assume it is (fig, ax)
+            fig, ax = ax
+        elif ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
         if self.myprop.used:
 
             if self.myprop.filled:
                 rgb=getRGBfromI(self.myprop.color)
-                if self.myprop.transparent:
-                    ax.fill([curvert.x for curvert in self.myvertices], [curvert.y for curvert in self.myvertices], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.,self.myprop.alpha))
-                else:
-                    ax.fill([curvert.x for curvert in self.myvertices], [curvert.y for curvert in self.myvertices], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.))
+                subpoly = self.get_subpolygons()
+                for curpoly in subpoly:
+                    if self.myprop.transparent:
+                        ax.fill([curvert.x for curvert in curpoly], [curvert.y for curvert in curpoly], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.,self.myprop.alpha))
+                    else:
+                        ax.fill([curvert.x for curvert in curpoly], [curvert.y for curvert in curpoly], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.))
             else:
                 rgb=getRGBfromI(self.myprop.color)
                 subpoly = self.get_subpolygons()
@@ -2512,164 +2702,438 @@ class vector:
 
             self.plot_legend_mpl(ax)
 
-    def _get_textfont(self):
-        """ Retunr a 'Text_Infos' instance for the legend """
-
-        r,g,b = getRGBfromI(self.myprop.legendcolor)
-        tinfos =  Text_Infos(self.myprop.legendpriority,
-                             (np.cos(self.myprop.legendorientation/180*np.pi),
-                              np.sin(self.myprop.legendorientation/180*np.pi)),
-                             self.myprop.legendfontname,
-                             self.myprop.legendfontsize,
-                             colour=(r,g,b,255),
-                             dimsreal=(self.myprop.legendlength,
-                                       self.myprop.legendheight),
-                             relative_position=self.myprop.legendrelpos)
+        return fig, ax
 
-        return tinfos
+    def plot_matplotlib_sz(self, ax:plt.Axes | tuple[Figure, Axes] = None):
+        """
+        Plot Matplotlib - SZ coordinates ONLY.
 
-    def _get_textfont_idx(self):
-        """ Retunr a 'Text_Infos' instance for the legend """
+        S is the curvilinear abscissa, Z is the elevation.
 
-        r,g,b = getRGBfromI(self.myprop.color)
-        tinfos =  Text_Infos(3,
-                             (1., 0.),
-                             self.myprop.legendfontname,
-                             12,
-                             colour=(r,g,b,255),
-                             dimsreal=(self.myprop.legendlength,
-                                       self.myprop.legendheight),
-                             relative_position=7)
+        :param ax: Matplotlib Axes to plot on or a tuple (fig, ax) where fig is the figure and ax is the axes.
+        If ax is None, a new figure and axes will be created.
+        """
 
-        return tinfos
+        if isinstance(ax, tuple):
+            # if ax is a tuple, we assume it is (fig, ax)
+            fig, ax = ax
+        elif ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
 
-    def add2tree(self, tree:TreeListCtrl, root):
-        """
-        Ajout de l'objte à un TreeListCtrl wx
-        """
-        self.mytree=tree
-        self.myitem=tree.AppendItem(root, self.myname,data=self)
         if self.myprop.used:
-            tree.CheckItem(self.myitem)
+            s,z = self.sz_curvi
 
-    def unuse(self):
-        """
-        L'objet n'est plus à utiliser
-        """
-        self.myprop.used=False
-        if self.mytree is not None:
-            self.mytree.UncheckItem(self.myitem)
+            rgb=getRGBfromI(self.myprop.color)
+            if self.myprop.transparent:
+                ax.plot(s, z, color=(rgb[0]/255., rgb[1]/255., rgb[2]/255., self.myprop.alpha), linewidth=self.myprop.width)
+            else:
+                ax.plot(s, z, color=(rgb[0]/255., rgb[1]/255., rgb[2]/255.), linewidth=self.myprop.width)
 
-        self._reset_listogl()
+        return fig, ax
 
-    def use(self):
+    def plot_linked(self, fig, ax, linked_arrays:dict):
         """
-        L'objet n'est plus à utiliser
+        Graphique Matplolib de valeurs dans les matrices liées
         """
-        self.myprop.used=True
-        if self.mytree is not None:
-            self.mytree.CheckItem(self.myitem)
-
+        # from .wolf_array import WolfArray
+        # from .wolfresults_2D import Wolfresults_2D
 
-        self._reset_listogl()
+        colors=['red','blue','green']
 
-    def fillgrid(self, gridto:CpGrid):
-        """
-        Remplissage d'un CpGrid
-        """
-        curv:wolfvertex
+        exit=True
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+                exit=False
 
-        gridto.SetColLabelValue(0,'X')
-        gridto.SetColLabelValue(1,'Y')
-        gridto.SetColLabelValue(2,'Z')
-        gridto.SetColLabelValue(3,'value')
-        gridto.SetColLabelValue(4,'s curvi')
-        gridto.SetColLabelValue(5,'in use')
+        if exit:
+            logging.warning(_('No plotted linked arrays'))
+            return
 
-        nb=gridto.GetNumberRows()
-        if len(self.myvertices)-nb>0:
-            gridto.AppendRows(len(self.myvertices)-nb)
         k=0
-        for curv in self.myvertices:
-           gridto.SetCellValue(k,0,str(curv.x))
-           gridto.SetCellValue(k,1,str(curv.y))
-           gridto.SetCellValue(k,2,str(curv.z))
-           gridto.SetCellValue(k,5,'1' if curv.in_use else '0')
-           k+=1
 
-    def updatefromgrid(self,gridfrom:CpGrid):
-        """
-        Mise à jour depuis un CpGrid
-        """
-        curv:wolfvertex
+        myls = self.asshapely_ls()
+        length = myls.length
+        tol=length/10.
+        ax.set_xlim(0-tol,length+tol)
 
-        nbl=gridfrom.GetNumberRows()
-        k=0
-        while k<nbl:
-            x=gridfrom.GetCellValue(k,0)
-            y=gridfrom.GetCellValue(k,1)
-            z=gridfrom.GetCellValue(k,2)
-            inuse = gridfrom.GetCellValue(k,5)
-            if z=='':
-                z=0.
-            if x!='':
-                if k<self.nbvertices:
-                    self.myvertices[k].x=float(x)
-                    self.myvertices[k].y=float(y)
-                    self.myvertices[k].z=float(z)
-                    self.myvertices[k].in_use = inuse=='1'
-                else:
-                    newvert=wolfvertex(float(x),float(y),float(z))
-                    self.add_vertex(newvert)
-                k+=1
-            else:
-                break
+        zmin=99999.
+        zmax=-99999.
+        nullvalue = -99999
 
-        while k<self.nbvertices:
-            self.myvertices.pop(k)
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
 
-        if self._linestring is not None or self._polygon is not None:
-            self.prepare_shapely()
+                ds = curarray.get_dxdy_min()
 
-        self._reset_listogl()
+                nb = int(np.ceil(length/ds*2))
 
-    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):
-            s2d[k]=s2d[k-1]+self.myvertices[k-1].dist2D(self.myvertices[k])
+                alls = np.linspace(0,int(length),nb)
 
-        return s2d
+                pts = [myls.interpolate(curs) for curs in alls]
 
-    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):
-            s3d[k]=s3d[k-1]+self.myvertices[k-1].dist3D(self.myvertices[k])
+                allz = np.asarray([curarray.get_value(curpt.x,curpt.y, nullvalue= nullvalue) for curpt in pts])
 
-        return s3d
+                zmaxloc=np.max(allz[allz!=nullvalue])
+                zminloc=np.min(allz[allz!=nullvalue])
 
-    def get_sz(self, cumul=True):
-        """
-        Calcule et retourne la distance horizontale cumulée ou non
-        de chaque point vis-à-vis du premier point
+                zmax=max(zmax,zmaxloc)
+                zmin=min(zmin,zminloc)
 
-        Utile pour le tracé de sections en travers ou des vérifications de position
+                if np.max(allz)>nullvalue:
+                    # select parts
+                    if nullvalue in allz:
+                        # find all parts separated by nullvalue
+                        nulls = np.argwhere(allz==nullvalue)
+                        nulls = np.insert(nulls,0,-1)
+                        nulls = np.append(nulls,len(allz))
 
-        :param cumul: si True, retourne la distance cumulée 2D. si False, retourne la distance 2D entre chaque point et le premier.
-        """
-        z = np.asarray([self.myvertices[i].z for i in range(self.nbvertices)])
+                        addlabel = True
+                        for i in range(len(nulls)-1):
+                            if nulls[i+1]-nulls[i]>1:
+                                ax.plot(alls[nulls[i]+1:nulls[i+1]],allz[nulls[i]+1:nulls[i+1]],
+                                        color=colors[np.mod(k,3)],
+                                        lw=2.0,
+                                        label=curlabel if addlabel else None)
+                                addlabel = False
 
-        nb = len(z)
-        s = np.zeros(nb)
+                    else:
+                        ax.plot(alls,allz,
+                                color=colors[np.mod(k,3)],
+                                lw=2.0,
+                                label=curlabel)
+                k+=1
 
-        if cumul:
-            x1 = self.myvertices[0].x
-            y1 = self.myvertices[0].y
+        ax.set_ylim(zmin,zmax)
+        ax.legend()
+        ax.grid()
+        fig.canvas.draw()
+
+        return fig,ax
+
+    def plot_linked_wx(self, fig:MplFig, linked_arrays:dict):
+        """
+        Graphique Matplolib de valeurs dans les matrices liées.
+
+        Version pour wxPython
+        """
+
+        colors=['red','blue','green']
+
+        exit=True
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+                exit=False
+
+        if exit:
+            return
+
+        k=0
+
+        myls = self.asshapely_ls()
+        length = myls.length
+        tol=length/10.
+        fig.cur_ax.set_xlim(0-tol,length+tol)
+
+        zmin=99999.
+        zmax=-99999.
+        nullvalue = -99999
+
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+
+                ds = curarray.get_dxdy_min()
+
+                nb = int(np.ceil(length/ds*2))
+
+                alls = np.linspace(0,int(length),nb)
+
+                pts = [myls.interpolate(curs) for curs in alls]
+
+                allz = np.asarray([curarray.get_value(curpt.x,curpt.y, nullvalue= nullvalue) for curpt in pts])
+
+                zmaxloc=np.max(allz[allz!=nullvalue])
+                zminloc=np.min(allz[allz!=nullvalue])
+
+                zmax=max(zmax,zmaxloc)
+                zmin=min(zmin,zminloc)
+
+                if np.max(allz)>nullvalue:
+                    # select parts
+                    if nullvalue in allz:
+                        # find all parts separated by nullvalue
+                        nulls = np.argwhere(allz==nullvalue)
+                        nulls = np.insert(nulls,0,-1)
+                        nulls = np.append(nulls,len(allz))
+
+                        addlabel = True
+                        for i in range(len(nulls)-1):
+                            if nulls[i+1]-nulls[i]>1:
+                                fig.plot(alls[nulls[i]+1:nulls[i+1]],allz[nulls[i]+1:nulls[i+1]],
+                                        color=colors[np.mod(k,3)],
+                                        lw=2.0,
+                                        label=curlabel if addlabel else None)
+                                addlabel = False
+
+                    else:
+                        fig.plot(alls,allz,
+                                color=colors[np.mod(k,3)],
+                                lw=2.0,
+                                label=curlabel)
+                k+=1
+
+        fig.cur_ax.set_ylim(zmin,zmax)
+        fig.cur_ax.legend()
+        fig.cur_ax.grid()
+
+        return fig
+
+    def plot_mpl(self, show=False,
+                 forceaspect=True,
+                 fig:Figure=None,
+                 ax:Axes=None,
+                 labels:dict={},
+                 clear_ax:bool =True):
+        """
+        Graphique Matplolib du vecteur - SZ coordinates ONLY
+
+        DEPRECATED: Use plot_matplotlib_sz instead.
+        """
+        warnings.warn("plot_mpl is deprecated, use plot_matplotlib_sz instead", DeprecationWarning, stacklevel=2)
+
+        x,y=self.get_sz()
+
+        xmin=x[0]
+        xmax=x[-1]
+        ymin=np.min(y)
+        ymax=np.max(y)
+
+        if ax is None:
+            redraw=False
+            fig = plt.figure()
+            ax=fig.add_subplot(111)
+        else:
+            redraw=True
+            if clear_ax:
+                # Clear the axes if specified
+                ax.cla()
+
+        if 'title' in labels.keys():
+            ax.set_title(labels['title'])
+        if 'xlabel' in labels.keys():
+            ax.set_xlabel(labels['xlabel'])
+        if 'ylabel' in labels.keys():
+            ax.set_ylabel(labels['ylabel'])
+
+        if ymax>-99999.:
+
+            dy=ymax-ymin
+            ymin-=dy/4.
+            ymax+=dy/4.
+
+            ax.plot(x,y,color='black',
+                    lw=2.0,
+                    label=self.myname)
+
+            ax.legend()
+
+            tol=(xmax-xmin)/10.
+            ax.set_xlim(xmin-tol,xmax+tol)
+            ax.set_ylim(ymin,ymax)
+
+            if forceaspect:
+                aspect=1.0*(ymax-ymin)/(xmax-xmin)*(ax.get_xlim()[1] - ax.get_xlim()[0]) / (ax.get_ylim()[1] - ax.get_ylim()[0])
+                ax.set_aspect(aspect)
+
+        if show:
+            fig.show()
+
+        if redraw:
+            fig.canvas.draw()
+
+        return fig,ax
+
+    def _get_textfont(self):
+        """ Retunr a 'Text_Infos' instance for the legend """
+
+        r,g,b = getRGBfromI(self.myprop.legendcolor)
+        tinfos =  Text_Infos(self.myprop.legendpriority,
+                             (np.cos(self.myprop.legendorientation/180*np.pi),
+                              np.sin(self.myprop.legendorientation/180*np.pi)),
+                             self.myprop.legendfontname,
+                             self.myprop.legendfontsize,
+                             colour=(r,g,b,255),
+                             dimsreal=(self.myprop.legendlength,
+                                       self.myprop.legendheight),
+                             relative_position=self.myprop.legendrelpos)
+
+        return tinfos
+
+    def _get_textfont_idx(self):
+        """ Retunr a 'Text_Infos' instance for the legend """
+
+        r,g,b = getRGBfromI(self.myprop.color)
+        tinfos =  Text_Infos(3,
+                             (1., 0.),
+                             self.myprop.legendfontname,
+                             12,
+                             colour=(r,g,b,255),
+                             dimsreal=(self.myprop.legendlength,
+                                       self.myprop.legendheight),
+                             relative_position=7)
+
+        return tinfos
+
+    def add2tree(self, tree:TreeListCtrl, root):
+        """
+        Ajout de l'objte à un TreeListCtrl wx
+        """
+        self.mytree=tree
+        self.myitem=tree.AppendItem(root, self.myname,data=self)
+        if self.myprop.used:
+            tree.CheckItem(self.myitem)
+
+    def unuse(self):
+        """
+        L'objet n'est plus à utiliser
+        """
+        self.myprop.used=False
+        if self.mytree is not None:
+            self.mytree.UncheckItem(self.myitem)
+
+        self._reset_listogl()
+
+    def use(self):
+        """
+        L'objet n'est plus à utiliser
+        """
+        self.myprop.used=True
+        if self.mytree is not None:
+            self.mytree.CheckItem(self.myitem)
+
+
+        self._reset_listogl()
+
+    def fillgrid(self, gridto:CpGrid):
+        """
+        Remplissage d'un CpGrid
+        """
+        curv:wolfvertex
+
+        gridto.SetColLabelValue(0,'X')
+        gridto.SetColLabelValue(1,'Y')
+        gridto.SetColLabelValue(2,'Z')
+        gridto.SetColLabelValue(3,'value')
+        gridto.SetColLabelValue(4,'s curvi')
+        gridto.SetColLabelValue(5,'in use')
+
+        nb=gridto.GetNumberRows()
+        if len(self.myvertices)-nb>0:
+            gridto.AppendRows(len(self.myvertices)-nb)
+        k=0
+        for curv in self.myvertices:
+           gridto.SetCellValue(k,0,str(curv.x))
+           gridto.SetCellValue(k,1,str(curv.y))
+           gridto.SetCellValue(k,2,str(curv.z))
+           gridto.SetCellValue(k,5,'1' if curv.in_use else '0')
+           k+=1
+
+    def _fillgrid_only_i(self, gridto:CpGrid):
+        """
+        Remplissage d'un CpGrid
+        """
+        curv:wolfvertex
+
+        gridto.SetColLabelValue(0,'X')
+        gridto.SetColLabelValue(1,'Y')
+        gridto.SetColLabelValue(2,'Z')
+        gridto.SetColLabelValue(3,'value')
+        gridto.SetColLabelValue(4,'s curvi')
+        gridto.SetColLabelValue(5,'in use')
+
+        nb=gridto.GetNumberRows()
+        if len(self.myvertices)-nb>0:
+            gridto.AppendRows(len(self.myvertices)-nb)
+        k=0
+
+        for curv in self.myvertices:
+           gridto.SetCellValue(k, 5, '1' if curv.in_use else '0')
+           k+=1
+
+    def updatefromgrid(self,gridfrom:CpGrid):
+        """
+        Mise à jour depuis un CpGrid
+        """
+        curv:wolfvertex
+
+        nbl=gridfrom.GetNumberRows()
+        k=0
+        while k<nbl:
+            x=gridfrom.GetCellValue(k,0)
+            y=gridfrom.GetCellValue(k,1)
+            z=gridfrom.GetCellValue(k,2)
+            inuse = gridfrom.GetCellValue(k,5)
+            if z=='':
+                z=0.
+            if x!='':
+                if k<self.nbvertices:
+                    self.myvertices[k].x=float(x)
+                    self.myvertices[k].y=float(y)
+                    self.myvertices[k].z=float(z)
+                    self.myvertices[k].in_use = inuse=='1'
+                else:
+                    newvert=wolfvertex(float(x),float(y),float(z))
+                    self.add_vertex(newvert)
+                k+=1
+            else:
+                break
+
+        while k<self.nbvertices:
+            self.myvertices.pop(k)
+
+        if self._linestring is not None or self._polygon is not None:
+            self.prepare_shapely()
+
+        self._reset_listogl()
+
+    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):
+            s2d[k]=s2d[k-1]+self.myvertices[k-1].dist2D(self.myvertices[k])
+
+        return s2d
+
+    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):
+            s3d[k]=s3d[k-1]+self.myvertices[k-1].dist3D(self.myvertices[k])
+
+        return s3d
+
+    def get_sz(self, cumul=True):
+        """
+        Calcule et retourne la distance horizontale cumulée ou non
+        de chaque point vis-à-vis du premier point
+
+        Utile pour le tracé de sections en travers ou des vérifications de position
+
+        :param cumul: si True, retourne la distance cumulée 2D. si False, retourne la distance 2D entre chaque point et le premier.
+        """
+        z = np.asarray([self.myvertices[i].z for i in range(self.nbvertices)])
+
+        nb = len(z)
+        s = np.zeros(nb)
+
+        if cumul:
+            x1 = self.myvertices[0].x
+            y1 = self.myvertices[0].y
             for i in range(nb-1):
                 x2 = self.myvertices[i+1].x
                 y2 = self.myvertices[i+1].y
@@ -2878,346 +3342,135 @@ class vector:
             else:
                 for k in range(k1+1,k2+1,-1):
                     if self.myvertices[k].dist2D(newvec.myvertices[-1])!=0.:
-                        newvec.add_vertex(self.myvertices[k])
-
-        if [v2.x,v2.y,v2.z] != [newvec.myvertices[-1].x,newvec.myvertices[-1].y,newvec.myvertices[-1].z]:
-            newvec.add_vertex(v2)
-
-        # if newvec.nbvertices==0:
-        #     a=1
-        # if newvec.nbvertices==1:
-        #     a=1
-        # newvec.update_lengths()
-        # if np.min(newvec._lengthparts2D)==0.:
-        #     a=1
-        return newvec
-
-    def get_values_linked_polygon(self, linked_arrays:list, getxy=False) -> dict:
-        """
-        Retourne les valeurs contenue dans le polygone
-
-        linked_arrays : liste Python d'objet matriciels WolfArray (ou surcharge)
-        """
-        vals={}
-
-        for curarray in linked_arrays:
-            if curarray.plotted:
-                vals[curarray.idx] = curarray.get_values_insidepoly(self, getxy=getxy)
-            else:
-                vals[curarray.idx] = None
-
-        return vals
-
-    def get_all_values_linked_polygon(self, linked_arrays, getxy=False) -> dict:
-        """
-        Retourne toutes les valeurs contenue dans le polygone --> utile au moins pour les résultats WOLF2D
-
-        linked_arrays : liste Python d'objet matriciels WolfArray (ou surcharge)
-        """
-        vals={}
-
-        for curarray in linked_arrays:
-            if curarray.plotted:
-                vals[curarray.idx] = curarray.get_all_values_insidepoly(self, getxy=getxy)
-            else:
-                vals[curarray.idx] = None
-
-        return vals
-
-    def get_all_values_linked_polyline(self,linked_arrays, getxy=True) -> dict:
-        """
-        Retourne toutes les valeurs sous la polyligne --> utile au moins pour les résultats WOLF2D
-
-        linked_arrays : liste Python d'objet matriciels WolfArray (ou surcharge)
-        """
-        vals={}
-
-        for curarray in linked_arrays:
-            if curarray.plotted:
-                vals[curarray.idx], xy = curarray.get_all_values_underpoly(self, getxy=getxy)
-            else:
-                vals[curarray.idx] = None
-
-        return vals
-
-    def get_values_on_vertices(self,curarray):
-        """
-        Récupération des valeurs sous les vertices et stockage dans la coordonnée 'z'
-        """
-        if not curarray.plotted:
-            return
-
-        for curpt in self.myvertices:
-            curpt.z = curarray.get_value(curpt.x,curpt.y)
-
-    def get_values_linked(self, linked_arrays:dict, refine=True, filter_null = False):
-        """
-        Récupération des valeurs dans les matrices liées sous les vertices et stockage dans la coordonnée 'z'
-        Possibilité de raffiner la discrétisation pour obtenir au moins une valeur par maille
-        """
-
-        exit=True
-        for curlabel, curarray in linked_arrays.items():
-            if curarray.plotted:
-                # at least one plotted array
-                exit=False
-
-        if exit:
-            return
-
-        if refine:
-            myzone=zone(name='linked_arrays - fine step')
-
-            for curlabel, curarray in linked_arrays.items():
-                if curarray.plotted:
-
-                    myvec=vector(name=curlabel,parentzone=myzone)
-                    myzone.add_vector(myvec)
-
-                    ds = curarray.get_dxdy_min()
-
-                    pts = self._refine2D(ds)
-
-                    allz = [curarray.get_value(curpt.x, curpt.y, nullvalue=-99999) for curpt in pts]
-
-                    if filter_null:
-                        for curpt,curz in zip(pts,allz):
-                            if curz!=-99999:
-                                myvec.add_vertex(wolfvertex(curpt.x,curpt.y,curz))
-                    else:
-                        for curpt,curz in zip(pts,allz):
-                            myvec.add_vertex(wolfvertex(curpt.x,curpt.y,curz))
-
-        else:
-            myzone=zone(name='linked_arrays')
-            for curlabel, curarray in linked_arrays.items():
-                if curarray.plotted:
-
-                    myvec=vector(name=curlabel,parentzone=myzone)
-                    myzone.add_vector(myvec)
-
-                    if filter_null:
-                        for curpt in self.myvertices:
-                            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=-99999)
-                            myvec.add_vertex(wolfvertex(curpt.x, curpt.y, locval))
-
-        return myzone
-
-    def plot_linked(self, fig, ax, linked_arrays:dict):
-        """
-        Graphique Matplolib de valeurs dans les matrices liées
-        """
-        # from .wolf_array import WolfArray
-        # from .wolfresults_2D import Wolfresults_2D
-
-        colors=['red','blue','green']
-
-        exit=True
-        for curlabel, curarray in linked_arrays.items():
-            if curarray.plotted:
-                exit=False
-
-        if exit:
-            logging.warning(_('No plotted linked arrays'))
-            return
-
-        k=0
-
-        myls = self.asshapely_ls()
-        length = myls.length
-        tol=length/10.
-        ax.set_xlim(0-tol,length+tol)
-
-        zmin=99999.
-        zmax=-99999.
-        nullvalue = -99999
-
-        for curlabel, curarray in linked_arrays.items():
-            if curarray.plotted:
-
-                ds = curarray.get_dxdy_min()
-
-                nb = int(np.ceil(length/ds*2))
-
-                alls = np.linspace(0,int(length),nb)
-
-                pts = [myls.interpolate(curs) for curs in alls]
-
-                allz = np.asarray([curarray.get_value(curpt.x,curpt.y, nullvalue= nullvalue) for curpt in pts])
-
-                zmaxloc=np.max(allz[allz!=nullvalue])
-                zminloc=np.min(allz[allz!=nullvalue])
-
-                zmax=max(zmax,zmaxloc)
-                zmin=min(zmin,zminloc)
-
-                if np.max(allz)>nullvalue:
-                    # select parts
-                    if nullvalue in allz:
-                        # find all parts separated by nullvalue
-                        nulls = np.argwhere(allz==nullvalue)
-                        nulls = np.insert(nulls,0,-1)
-                        nulls = np.append(nulls,len(allz))
-
-                        addlabel = True
-                        for i in range(len(nulls)-1):
-                            if nulls[i+1]-nulls[i]>1:
-                                ax.plot(alls[nulls[i]+1:nulls[i+1]],allz[nulls[i]+1:nulls[i+1]],
-                                        color=colors[np.mod(k,3)],
-                                        lw=2.0,
-                                        label=curlabel if addlabel else None)
-                                addlabel = False
-
-                    else:
-                        ax.plot(alls,allz,
-                                color=colors[np.mod(k,3)],
-                                lw=2.0,
-                                label=curlabel)
-                k+=1
+                        newvec.add_vertex(self.myvertices[k])
 
-        ax.set_ylim(zmin,zmax)
-        ax.legend()
-        ax.grid()
-        fig.canvas.draw()
+        if [v2.x,v2.y,v2.z] != [newvec.myvertices[-1].x,newvec.myvertices[-1].y,newvec.myvertices[-1].z]:
+            newvec.add_vertex(v2)
 
-        return fig,ax
+        # if newvec.nbvertices==0:
+        #     a=1
+        # if newvec.nbvertices==1:
+        #     a=1
+        # newvec.update_lengths()
+        # if np.min(newvec._lengthparts2D)==0.:
+        #     a=1
+        return newvec
 
-    def plot_linked_wx(self, fig:MplFig, linked_arrays:dict):
+    def get_values_linked_polygon(self, linked_arrays:list, getxy=False) -> dict:
         """
-        Graphique Matplolib de valeurs dans les matrices liées.
+        Retourne les valeurs contenue dans le polygone
 
-        Version pour wxPython
+        linked_arrays : liste Python d'objet matriciels WolfArray (ou surcharge)
         """
+        vals={}
 
-        colors=['red','blue','green']
-
-        exit=True
-        for curlabel, curarray in linked_arrays.items():
+        for curarray in linked_arrays:
             if curarray.plotted:
-                exit=False
-
-        if exit:
-            return
+                vals[curarray.idx] = curarray.get_values_insidepoly(self, getxy=getxy)
+            else:
+                vals[curarray.idx] = None
 
-        k=0
+        return vals
 
-        myls = self.asshapely_ls()
-        length = myls.length
-        tol=length/10.
-        fig.cur_ax.set_xlim(0-tol,length+tol)
+    def get_all_values_linked_polygon(self, linked_arrays, getxy=False) -> dict:
+        """
+        Retourne toutes les valeurs contenue dans le polygone --> utile au moins pour les résultats WOLF2D
 
-        zmin=99999.
-        zmax=-99999.
-        nullvalue = -99999
+        linked_arrays : liste Python d'objet matriciels WolfArray (ou surcharge)
+        """
+        vals={}
 
-        for curlabel, curarray in linked_arrays.items():
+        for curarray in linked_arrays:
             if curarray.plotted:
+                vals[curarray.idx] = curarray.get_all_values_insidepoly(self, getxy=getxy)
+            else:
+                vals[curarray.idx] = None
 
-                ds = curarray.get_dxdy_min()
-
-                nb = int(np.ceil(length/ds*2))
-
-                alls = np.linspace(0,int(length),nb)
-
-                pts = [myls.interpolate(curs) for curs in alls]
-
-                allz = np.asarray([curarray.get_value(curpt.x,curpt.y, nullvalue= nullvalue) for curpt in pts])
-
-                zmaxloc=np.max(allz[allz!=nullvalue])
-                zminloc=np.min(allz[allz!=nullvalue])
+        return vals
 
-                zmax=max(zmax,zmaxloc)
-                zmin=min(zmin,zminloc)
+    def get_all_values_linked_polyline(self,linked_arrays, getxy=True) -> dict:
+        """
+        Retourne toutes les valeurs sous la polyligne --> utile au moins pour les résultats WOLF2D
 
-                if np.max(allz)>nullvalue:
-                    # select parts
-                    if nullvalue in allz:
-                        # find all parts separated by nullvalue
-                        nulls = np.argwhere(allz==nullvalue)
-                        nulls = np.insert(nulls,0,-1)
-                        nulls = np.append(nulls,len(allz))
+        linked_arrays : liste Python d'objet matriciels WolfArray (ou surcharge)
+        """
+        vals={}
 
-                        addlabel = True
-                        for i in range(len(nulls)-1):
-                            if nulls[i+1]-nulls[i]>1:
-                                fig.plot(alls[nulls[i]+1:nulls[i+1]],allz[nulls[i]+1:nulls[i+1]],
-                                        color=colors[np.mod(k,3)],
-                                        lw=2.0,
-                                        label=curlabel if addlabel else None)
-                                addlabel = False
+        for curarray in linked_arrays:
+            if curarray.plotted:
+                vals[curarray.idx], xy = curarray.get_all_values_underpoly(self, getxy=getxy)
+            else:
+                vals[curarray.idx] = None
 
-                    else:
-                        fig.plot(alls,allz,
-                                color=colors[np.mod(k,3)],
-                                lw=2.0,
-                                label=curlabel)
-                k+=1
+        return vals
 
-        fig.cur_ax.set_ylim(zmin,zmax)
-        fig.cur_ax.legend()
-        fig.cur_ax.grid()
+    def get_values_on_vertices(self,curarray):
+        """
+        Récupération des valeurs sous les vertices et stockage dans la coordonnée 'z'
+        """
+        if not curarray.plotted:
+            return
 
-        return fig
+        for curpt in self.myvertices:
+            curpt.z = curarray.get_value(curpt.x,curpt.y)
 
-    def plot_mpl(self,show=False,forceaspect=True,fig:Figure=None,ax:Axes=None,labels:dict={}):
+    def get_values_linked(self, linked_arrays:dict, refine=True, filter_null = False):
         """
-        Graphique Matplolib du vecteur
+        Récupération des valeurs dans les matrices liées sous les vertices et stockage dans la coordonnée 'z'
+        Possibilité de raffiner la discrétisation pour obtenir au moins une valeur par maille
         """
 
-        x,y=self.get_sz()
+        exit=True
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+                # at least one plotted array
+                exit=False
 
-        xmin=x[0]
-        xmax=x[-1]
-        ymin=np.min(y)
-        ymax=np.max(y)
+        if exit:
+            return
 
-        if ax is None:
-            redraw=False
-            fig = plt.figure()
-            ax=fig.add_subplot(111)
-        else:
-            redraw=True
-            ax.cla()
+        if refine:
+            myzone=zone(name='linked_arrays - fine step')
 
-        if 'title' in labels.keys():
-            ax.set_title(labels['title'])
-        if 'xlabel' in labels.keys():
-            ax.set_xlabel(labels['xlabel'])
-        if 'ylabel' in labels.keys():
-            ax.set_ylabel(labels['ylabel'])
+            for curlabel, curarray in linked_arrays.items():
+                if curarray.plotted:
 
-        if ymax>-99999.:
+                    myvec=vector(name=curlabel,parentzone=myzone)
+                    myzone.add_vector(myvec)
 
-            dy=ymax-ymin
-            ymin-=dy/4.
-            ymax+=dy/4.
+                    ds = curarray.get_dxdy_min()
 
-            ax.plot(x,y,color='black',
-                    lw=2.0,
-                    label=self.myname)
+                    pts = self._refine2D(ds)
 
-            ax.legend()
+                    allz = [curarray.get_value(curpt.x, curpt.y, nullvalue=-99999) for curpt in pts]
 
-            tol=(xmax-xmin)/10.
-            ax.set_xlim(xmin-tol,xmax+tol)
-            ax.set_ylim(ymin,ymax)
+                    if filter_null:
+                        for curpt,curz in zip(pts,allz):
+                            if curz!=-99999:
+                                myvec.add_vertex(wolfvertex(curpt.x,curpt.y,curz))
+                    else:
+                        for curpt,curz in zip(pts,allz):
+                            myvec.add_vertex(wolfvertex(curpt.x,curpt.y,curz))
 
-            if forceaspect:
-                aspect=1.0*(ymax-ymin)/(xmax-xmin)*(ax.get_xlim()[1] - ax.get_xlim()[0]) / (ax.get_ylim()[1] - ax.get_ylim()[0])
-                ax.set_aspect(aspect)
+        else:
+            myzone=zone(name='linked_arrays')
+            for curlabel, curarray in linked_arrays.items():
+                if curarray.plotted:
 
-        if show:
-            fig.show()
+                    myvec=vector(name=curlabel,parentzone=myzone)
+                    myzone.add_vector(myvec)
 
-        if redraw:
-            fig.canvas.draw()
+                    if filter_null:
+                        for curpt in self.myvertices:
+                            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=-99999)
+                            myvec.add_vertex(wolfvertex(curpt.x, curpt.y, locval))
 
-        return fig,ax
+        return myzone
 
     def deepcopy_vector(self, name: str = None, parentzone = None) -> 'vector':
         """
@@ -3279,10 +3532,13 @@ class vector:
 
     def set_z(self, new_z:np.ndarray):
         """ Set the z values of the vertices """
+        warnings.warn(_('This method is deprecated, use the z property instead.'), DeprecationWarning, stacklevel=2)
+
         self.z = new_z
 
     @property
     def z(self):
+        """ Return the z values of the vertices as a numpy array. """
         z = np.asarray([curvert.z for curvert in self.myvertices])
         if self.add_zdatum:
             z+=self.zdatum
@@ -3290,30 +3546,37 @@ class vector:
 
     @property
     def x(self):
+        """ Return the x values of the vertices as a numpy array. """
         return np.asarray([curvert.x for curvert in self.myvertices])
 
     @property
     def y(self):
+        """ Return the y values of the vertices as a numpy array. """
         return np.asarray([curvert.y for curvert in self.myvertices])
 
     @property
     def xy(self):
+        """ Return the x, y values of the vertices as a 2D numpy array. """
         return np.asarray([[curvert.x, curvert.y] for curvert in self.myvertices])
 
     @property
     def xz(self):
+        """ Return the x, z values of the vertices as a 2D numpy array. """
         return np.asarray([[curvert.x, curvert.z] for curvert in self.myvertices])
 
     @property
     def xyz(self):
+        """ Return the x, y, z values of the vertices as a 3D numpy array. """
         return self.asnparray3d()
 
     @property
     def i(self):
+        """ Return the in_use values of the vertices. """
         return np.asarray([curvert.in_use for curvert in self.myvertices])
 
     @property
     def xyzi(self):
+        """ Return the x, y, z and in_use values of the vertices. """
         x = self.x
         y = self.y
         z = self.z
@@ -3322,20 +3585,27 @@ class vector:
 
     @property
     def xyi(self):
+        """ Return the x, y and in_use values of the vertices. """
         return np.asarray([[curvert.x, curvert.y, curvert.in_use] for curvert in self.myvertices])
 
     @property
     def sz_curvi(self):
+        """ Return the curvilinear abscissa and thz Z-value of the vector. """
         return self.get_sz()
 
     @property
     def s_curvi(self):
+        """ Return the curvilinear abscissa of the vector. """
         sz = self.get_sz()
         return sz[0]
 
     @x.setter
     def x(self, new_x:np.ndarray | list):
-        """ Set the x values of the vertices """
+        """ Set the x values of the vertices.
+
+        :param new_x: numpy array or list with x values - must have the same length as the number of vertices
+        :type new_x: np.ndarray | list
+        """
 
         if isinstance(new_x, list):
             new_x = np.array(new_x)
@@ -3352,7 +3622,11 @@ class vector:
 
     @y.setter
     def y(self, new_y:np.ndarray | list):
-        """ Set the y values of the vertices """
+        """ Set the y values of the vertices.
+
+        :param new_y: numpy array or list with y values - must have the same length as the number of vertices
+        :type new_y: np.ndarray | list
+        """
 
         if isinstance(new_y, list):
             new_y = np.array(new_y)
@@ -3371,7 +3645,8 @@ class vector:
     def z(self, new_z:np.ndarray | float | list):
         """ Set the z values of the vertices
 
-        /PARAM new_z: numpy array, float or list (but WolfArray is supported too)
+        :param new_z: numpy array, float or list (but WolfArray is supported too)
+        :type new_z: np.ndarray | float | list | WolfArray
         """
         from .wolf_array import WolfArray
 
@@ -3405,7 +3680,11 @@ class vector:
 
     @xyz.setter
     def xyz(self, new_xyz:np.ndarray | list):
-        """ Set the x, y, z values of the vertices """
+        """ Set the x, y, z values of the vertices.
+
+        :param new_xyz: numpy array or list with x, y, z values - must have the same length as the number of vertices
+        :type new_xyz: np.ndarray | list
+        """
 
         if isinstance(new_xyz, list):
             new_xyz = np.array(new_xyz)
@@ -3431,7 +3710,11 @@ class vector:
 
     @xy.setter
     def xy(self, new_xy:np.ndarray | list):
-        """ Set the x, y values of the vertices """
+        """ Set the x, y values of the vertices.
+
+        :param new_xy: numpy array or list with x, y values - must have the same length as the number of vertices
+        :type new_xy: np.ndarray | list
+        """
 
         if isinstance(new_xy, list):
             new_xy = np.array(new_xy)
@@ -3449,7 +3732,11 @@ class vector:
 
     @xz.setter
     def xz(self, new_xz:np.ndarray | list):
-        """ Set the x, z values of the vertices """
+        """ Set the x, z values of the vertices.
+
+        :param new_xz: numpy array or list with x, z values - must have the same length as the number of vertices
+        :type new_xz: np.ndarray | list
+        """
 
         if isinstance(new_xz, list):
             new_xz = np.array(new_xz)
@@ -3472,7 +3759,11 @@ class vector:
 
     @xyzi.setter
     def xyzi(self, new_xyzi:np.ndarray | list):
-        """ Set the x, y, z, in_use values of the vertices """
+        """ Set the x, y, z, in_use values of the vertices.
+
+        :param new_xyzi: numpy array or list with x, y, z, in_use values - must have the same length as the number of vertices
+        :type new_xyzi: np.ndarray | list
+        """
 
         if isinstance(new_xyzi, list):
             new_xyzi = np.array(new_xyzi)
@@ -3492,7 +3783,11 @@ class vector:
 
     @xyi.setter
     def xyi(self, new_xyi:np.ndarray | list):
-        """ Set the x, y, in_use values of the vertices """
+        """ Set the x, y, in_use values of the vertices.
+
+        :param new_xyi: numpy array or list with x, y, in_use values - must have the same length as the number of vertices
+        :type new_xyi: np.ndarray | list
+        """
 
         if isinstance(new_xyi, list):
             new_xyi = np.array(new_xyi)
@@ -3511,7 +3806,11 @@ class vector:
 
     @i.setter
     def i(self, new_i:np.ndarray | list):
-        """ Set the in_use values of the vertices """
+        """ Set the in_use values of the vertices.
+
+        :param new_i: numpy array or list with in_use values - must have the same length as the number of vertices
+        :type new_i: np.ndarray | list
+        """
 
         if isinstance(new_i, list):
             new_i = np.array(new_i)
@@ -3528,7 +3827,11 @@ class vector:
 
     @sz_curvi.setter
     def sz_curvi(self, sz_new:np.ndarray | list):
-        """ Interpolate the vertices based on the curvilinear abscissa """
+        """ Interpolate the vertice Z-coordinates based on a polyline defined as curvilinear abscissa and Z-value.
+
+        :param sz_new: numpy array or list with curvilinear abscissa and Z-value pairs
+        :type sz_new: np.ndarray | list
+        """
 
         if isinstance(sz_new, list):
             sz_new = np.array(sz_new)
@@ -3542,6 +3845,30 @@ class vector:
         self._reset_listogl()
         self.reset_linestring()
 
+    @s_curvi.setter
+    def s_curvi(self, new_s:np.ndarray | list):
+        """ Replace the vertice XY-coordinates based on the curvilinear abscissa.
+
+        :param new_s: numpy array or list with curvilinear abscissa values - must have the same length as the number of vertices
+        :type new_s: np.ndarray | list
+        """
+
+        if isinstance(new_s, list):
+            new_s = np.array(new_s)
+
+        if len(new_s) != self.nbvertices:
+            logging.warning(_('New s values have not the same length as the number of vertices'))
+            return
+
+        poly = self.linestring
+
+        for idx, curvert in enumerate(self.myvertices):
+            curvert.x, curvert.y = poly.interpolate(new_s[idx]).xy
+
+        self._reset_listogl()
+        self.reset_linestring()
+
+
     def __str__(self):
         return self.myname
 
@@ -3804,6 +4131,11 @@ class zone:
             # Object can be created from a shapely object
             self.import_shapelyobj(fromshapely)
 
+    def check_if_interior_exists(self):
+        """ Check if the zone has at least one vector with interior points """
+        for curvec in self.myvectors:
+            curvec.check_if_interior_exists()
+
     def add_values(self, key:str, values:np.ndarray):
         """ add values to the zone """
 
@@ -4251,7 +4583,7 @@ class zone:
             for curvect in self.myvectors:
                 curvect.plot_legend(sx, sy, xmin, ymin, xmax, ymax, size)
 
-    def plot_matplotlib(self, ax:plt.Axes):
+    def plot_matplotlib(self, ax:plt.Axes | tuple[Figure, Axes] = None, **kwargs):
         """
         Plot the zone using matplotlib
 
@@ -4259,9 +4591,18 @@ class zone:
         :param kwargs: additional arguments
         """
 
+        if isinstance(ax, tuple):
+            fig, ax = ax
+        elif ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
         for curvect in self.myvectors:
             curvect.plot_matplotlib(ax)
 
+        return fig, ax
+
     def select_vectors_from_point(self,x:float,y:float,inside=True):
         """
         Sélection du vecteur de la zone sur base d'une coordonnée (x,y) -- en 2D
@@ -6160,6 +6501,11 @@ class Zones(wx.Frame, Element_To_Draw):
 
         return [curzone.myname for curzone in self.myzones]
 
+    def check_if_interior_exists(self):
+        """ Check if the zone has at least one vector with interior points """
+        for curzone in self.myzones:
+            curzone.check_if_interior_exists()
+
     def add_values(self, key:str, values:np.ndarray | dict):
         """
         Add values to the zones
@@ -6660,7 +7006,7 @@ class Zones(wx.Frame, Element_To_Draw):
                 curvect.myprop.color = curcolor
                 curvect.myprop.alpha = 180
                 curvect.myprop.transparent = True
-                curvect.myprop.filled = filled
+                curvect.myprop.filled = filled and curvect.closed
 
     def set_width(self, width:int) -> None:
         """ Change with of all vectors in all zones """
@@ -6708,23 +7054,36 @@ class Zones(wx.Frame, Element_To_Draw):
 
     def import_dxf(self, fn, imported_elts=['POLYLINE','LWPOLYLINE','LINE']):
         """
-        Import d'un fichier DXF en tant qu'objets WOLF
+        Import of a DXF file as a 'Zones'.
+
+        The DXF file is read and the elements are stored in zones based on their layers.
+
+        The supported elements are POLYLINE, LWPOLYLINE and LINE.
+        If you want to import other elements, you must upgrade this routine `import_dxf`.
+
+        :param fn: name of the DXF file to import
+        :param imported_elts: list of DXF elements to import. Default is ['POLYLINE','LWPOLYLINE','LINE'].
+        :return: None
         """
         import ezdxf
 
         if not path.exists(fn):
-            try:
-                logging.warning(_('File not found !') + ' ' + fn)
-            except:
-                pass
+            logging.warning(_('File not found !') + ' ' + fn)
             return
 
+        for elt in imported_elts:
+            assert elt in ['POLYLINE', 'LWPOLYLINE', 'LINE'], _('Unsupported DXF element: {}').format(elt)
+
+        self.is2D = False # we assume it's a 3D DXF
+
         # Lecture du fichier dxf et identification du modelspace
         doc = ezdxf.readfile(fn)
         msp = doc.modelspace()
-        layers = doc.layers
+        # layers = doc.layers
 
         used_layers = {}
+        notloaded = {}
+
         # Bouclage sur les éléments du DXF pour identifier les layers utiles et ensuite créer les zones adhoc
         for e in msp:
             if doc.layers.get(e.dxf.layer).is_on():
@@ -6750,14 +7109,23 @@ class Zones(wx.Frame, Element_To_Draw):
                             curlayer = used_layers[e.dxf.layer]
                         curlayer[e.dxftype().lower()]=0
                 else:
-                    logging.warning(_('DXF element not supported : ') + e.dxftype())
+                    if not e.dxftype() in notloaded.keys():
+                        notloaded[e.dxftype()] = 0
+
+                    notloaded[e.dxftype()] += 1
+                    logging.debug(_('DXF element not supported : ') + e.dxftype())
             else:
                 logging.info(_('Layer {} is off'.format(e.dxf.layer)))
 
+        if len(notloaded)>0:
+            logging.warning(_('Not loaded DXF elements : '))
+            for curtype in notloaded.keys():
+                logging.warning(_('  {} : {}'.format(curtype, notloaded[curtype])))
+
         # Création des zones
         for curlayer in used_layers.keys():
             for curtype in used_layers[curlayer].keys():
-                curzone = used_layers[curlayer][curtype] = zone(name = '{} - {}'.format(curlayer,curtype),is2D=self.is2D,parent=self)
+                curzone = used_layers[curlayer][curtype] = zone(name = '{} - {}'.format(curlayer,curtype), is2D=self.is2D, parent=self)
                 self.add_zone(curzone)
 
         # Nouveau bouclage sur les éléments du DXF pour remplissage
@@ -6974,12 +7342,21 @@ class Zones(wx.Frame, Element_To_Draw):
         for curzone in self.myzones:
             curzone.plot(sx=sx, sy=sy, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, size=size)
 
-    def plot_matplotlib(self, ax:plt.Axes):
+    def plot_matplotlib(self, ax:Axes | tuple[Figure, Axes] = None):
         """ Plot with matplotlib """
 
+        if isinstance(ax, tuple):
+            fig, ax = ax
+        elif ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
         for curzone in self.myzones:
             curzone.plot_matplotlib(ax)
 
+        return fig, ax
+
     def select_vectors_from_point(self, x:float, y:float, inside=True):
         """
         Sélection de vecteurs dans chaque zones sur base d'une coordonnée
@@ -7070,6 +7447,10 @@ class Zones(wx.Frame, Element_To_Draw):
             self.updatevertices.SetToolTip(_("Transfer the coordinates from the editor to the memory and update the plot"))
             self.updatevertices.Bind(wx.EVT_BUTTON,self.Onupdatevertices)
 
+            self._test_interior = wx.Button(self,label=_('Test interior'))
+            self._test_interior.SetToolTip(_("Test if some segments of the active vector are exactly the same"))
+            self._test_interior.Bind(wx.EVT_BUTTON,self.Ontest_interior)
+
             self.plot_mpl = wx.Button(self,label=_('Plot xy'))
             self.plot_mpl.SetToolTip(_("Plot the active vector in a new window (matplotlib)"))
             self.plot_mpl.Bind(wx.EVT_BUTTON,self.Onplotmpl)
@@ -7079,7 +7460,7 @@ class Zones(wx.Frame, Element_To_Draw):
             self.plot_mplsz.Bind(wx.EVT_BUTTON,self.Onplotmplsz)
 
             sizer_add_update.Add(self.addrows,1, wx.EXPAND)
-            sizer_add_update.Add(self.updatevertices,3, wx.EXPAND)
+            sizer_add_update.Add(self.updatevertices, 1, wx.EXPAND)
             sizer_add_update.Add(self.plot_mpl,1, wx.EXPAND)
             sizer_add_update.Add(self.plot_mplsz,1, wx.EXPAND)
 
@@ -7235,6 +7616,8 @@ class Zones(wx.Frame, Element_To_Draw):
 
             box_interp_indices = wx.BoxSizer(wx.HORIZONTAL)
             box_interp_indices.Add(self.interpxyz,1,wx.EXPAND)
+            box_interp_indices.Add(self._test_interior, 1, wx.EXPAND)
+
 
             boxright.Add(box_interp_indices,0,wx.EXPAND)
 
@@ -7410,7 +7793,7 @@ class Zones(wx.Frame, Element_To_Draw):
             self.fill_structure()
 
             self.treelist.SetSize(200,500)
-            self.SetSize(600,700)
+            self.SetSize(650,700)
 
             self.SetSizer(box)
 
@@ -8781,6 +9164,18 @@ class Zones(wx.Frame, Element_To_Draw):
         self.active_vector.updatefromgrid(self.xls)
         self.find_minmax(True)
 
+    def Ontest_interior(self, event:wx.MouseEvent):
+        """ Test if the active vector has interior portions """
+        if self.verify_activevec():
+            return
+
+        self.active_vector.check_if_interior_exists()
+
+        self.active_vector._fillgrid_only_i(self.xls)
+
+        self.get_mapviewer().Paint()
+
+
     def Onplotmpl(self, event:wx.MouseEvent):
         """
         Plot active vector in matplotlib