wolfhece 2.2.34__py3-none-any.whl → 2.2.36__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,44 @@ class vector:
 
         return len(not_in_use) > 0
 
+    @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 +2325,21 @@ 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]
 
         else:
             if self.has_interior:
@@ -2488,19 +2601,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,6 +2638,258 @@ class vector:
 
             self.plot_legend_mpl(ax)
 
+        return fig, ax
+
+    def plot_matplotlib_sz(self, ax:plt.Axes | tuple[Figure, Axes] = None):
+        """
+        Plot Matplotlib - SZ coordinates ONLY.
+
+        S is the curvilinear abscissa, Z is the elevation.
+
+        :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:
+            s,z = self.sz_curvi
+
+            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)
+
+        return fig, ax
+
+    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
+
+        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 """
 
@@ -2789,7 +3167,7 @@ class vector:
 
         return pts
 
-    def split(self,ds, new=True):
+    def split(self, ds, new=True):
         """
         Création d'un nouveau vecteur sur base du découpage d'un autre et d'un pas spatial à respecter
         Le nouveau vecteur contient tous les points de l'ancien et des nouveaux sur base d'un découpage 3D
@@ -2854,370 +3232,159 @@ class vector:
                        self.myvertices[k1].z*pond1+self.myvertices[k1+1].z*(1.-pond1))
 
         v2= wolfvertex(self.myvertices[k2].x*pond2+self.myvertices[k2+1].x*(1.-pond2),
-                       self.myvertices[k2].y*pond2+self.myvertices[k2+1].y*(1.-pond2),
-                       self.myvertices[k2].z*pond2+self.myvertices[k2+1].z*(1.-pond2))
-
-        newvec = vector(name='substr')
-
-        newvec.add_vertex(v1)
-
-        if s1<=s2:
-            if is3D:
-                for k in range(k1+1,k2+1):
-                    if self.myvertices[k].dist3D(newvec.myvertices[-1])!=0.:
-                        newvec.add_vertex(self.myvertices[k])
-            else:
-                for k in range(k1+1,k2+1):
-                    if self.myvertices[k].dist2D(newvec.myvertices[-1])!=0.:
-                        newvec.add_vertex(self.myvertices[k])
-        else:
-            if is3D:
-                for k in range(k1+1,k2+1,-1):
-                    if self.myvertices[k].dist3D(newvec.myvertices[-1])!=0.:
-                        newvec.add_vertex(self.myvertices[k])
-            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
-
-        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.
+                       self.myvertices[k2].y*pond2+self.myvertices[k2+1].y*(1.-pond2),
+                       self.myvertices[k2].z*pond2+self.myvertices[k2+1].z*(1.-pond2))
 
-        Version pour wxPython
-        """
+        newvec = vector(name='substr')
 
-        colors=['red','blue','green']
+        newvec.add_vertex(v1)
 
-        exit=True
-        for curlabel, curarray in linked_arrays.items():
-            if curarray.plotted:
-                exit=False
+        if s1<=s2:
+            if is3D:
+                for k in range(k1+1,k2+1):
+                    if self.myvertices[k].dist3D(newvec.myvertices[-1])!=0.:
+                        newvec.add_vertex(self.myvertices[k])
+            else:
+                for k in range(k1+1,k2+1):
+                    if self.myvertices[k].dist2D(newvec.myvertices[-1])!=0.:
+                        newvec.add_vertex(self.myvertices[k])
+        else:
+            if is3D:
+                for k in range(k1+1,k2+1,-1):
+                    if self.myvertices[k].dist3D(newvec.myvertices[-1])!=0.:
+                        newvec.add_vertex(self.myvertices[k])
+            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 exit:
-            return
+        if [v2.x,v2.y,v2.z] != [newvec.myvertices[-1].x,newvec.myvertices[-1].y,newvec.myvertices[-1].z]:
+            newvec.add_vertex(v2)
 
-        k=0
+        # 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
 
-        myls = self.asshapely_ls()
-        length = myls.length
-        tol=length/10.
-        fig.cur_ax.set_xlim(0-tol,length+tol)
+    def get_values_linked_polygon(self, linked_arrays:list, getxy=False) -> dict:
+        """
+        Retourne les valeurs contenue dans le polygone
 
-        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_values_insidepoly(self, getxy=getxy)
+            else:
+                vals[curarray.idx] = None
 
-                ds = curarray.get_dxdy_min()
-
-                nb = int(np.ceil(length/ds*2))
+        return vals
 
-                alls = np.linspace(0,int(length),nb)
+    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
 
-                pts = [myls.interpolate(curs) for curs in alls]
+        linked_arrays : liste Python d'objet matriciels WolfArray (ou surcharge)
+        """
+        vals={}
 
-                allz = np.asarray([curarray.get_value(curpt.x,curpt.y, nullvalue= nullvalue) for curpt in pts])
+        for curarray in linked_arrays:
+            if curarray.plotted:
+                vals[curarray.idx] = curarray.get_all_values_insidepoly(self, getxy=getxy)
+            else:
+                vals[curarray.idx] = None
 
-                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 +3446,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 +3460,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 +3499,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 +3536,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 +3559,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 +3594,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 +3624,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 +3646,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 +3673,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 +3697,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 +3720,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 +3741,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 +3759,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
 
@@ -4251,7 +4492,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 +4500,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
@@ -6708,23 +6958,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 +7013,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 +7246,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