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

wolfhece/PyCrosssections.py

@@ -12,7 +12,7 @@ from numpy import asarray,ndarray,arange,zeros,linspace,concatenate,unique,amin,
 import math
 import matplotlib.pyplot as plt
 from shapely.geometry import LineString,MultiLineString,Point,Polygon,CAP_STYLE,Point
-from shapely.prepared import prep
+from shapely import prepare, is_prepared, destroy_prepared
 from shapely.ops import nearest_points,substring
 from OpenGL.GL  import *
 import numpy as np
@@ -28,7 +28,7 @@ import wx
 from typing import Union, Literal
 from pathlib import Path
 import pandas as pd
-
+from numba import njit
 
 from .PyTranslate import _
 from .drawing_obj import Element_To_Draw
@@ -72,7 +72,8 @@ example_diffsect1="""0 10
 42 7
 50 10"""
 
-def INTERSEC(x1,y1,x2,y2,el):
+@njit
+def INTERSEC(x1:float, y1:float, x2:float, y2:float, el:float):
     """Procédure de calcul de l'abscisse d'intersection d'une altitude donnée el
     dans un segment défini par ses coordonnées (x1,y1) et (x2,y2)"""
     xx=1.0e10
@@ -90,14 +91,19 @@ def INTERSEC(x1,y1,x2,y2,el):
         xx=(el-b)/a
     return xx
 
-def partranslation(base, x, y ):
+def _shift_np(base:np.ndarray, x:float, y:float):
+    """ Copy a Numpy array and translate it by (x,y) in the XY plane """
 
     copie = base.copy()
     copie[:,0] += x
     copie[:,1] += y
-    return(copie)
+    return copie
+
+@njit
+def _find_shift_at_xy(section:np.ndarray, x3:float, y3:float):
+    """ Find the Delta X and Delta Y to shift a section
+    to be parallel to itself at point (x3,y3) """
 
-def  find_xy(section,x3,y3):
     x1 = section[0,0]
     y1 = section[0,1]
     x2 = section[-1,0]
@@ -110,9 +116,9 @@ def  find_xy(section,x3,y3):
         a = (y2-y1)/(x2-x1)
         b = y1-(a*x1)
 
-        vecteur = ([1,a])
-        normale = ([-a,1])
-        normale_opposée = ([a,-1])
+        # vecteur = ([1,a])
+        # normale = ([-a,1])
+        # normale_opposée = ([a,-1])
 
         c = -1/a
         d = y3-(c*x3)
@@ -135,19 +141,40 @@ class postype(Enum):
 
 class profile(vector):
     """
-    Surcharge d'un vecteur en vue de définir un profil de rivière
+    Subclass of a vector to define a river profile/cross-section.
+
+    Some attributes are added to manage specific points of the profile (banks, bed).
+    The bankleft, bankright, bed, bankleft_down, bankright_down attributes can be wolfvertex,
+    index of vertex or s3D position depending on banksbed_postype.
+
+    If a profile is part of a croossection object, the parent attribute points to it.
+    If the profiles are ordered along a river, the up and down attributes point to the upstream and downstream profiles.
 
-    Les coordonnées attendues sont en 3D (x,y,z)
+    sdatum and zdatum are offsets to be added to the curvilinear abscissa and altitudes of the profile.
+
+    The stored coordinates are in 3D (x, y, z). If data_sect is provided at initialization, we expect (X, Z) data.
+    The x coordinate is the curvilinear abscissa along the section and z is the altitude (y is set to 0).
+
+    ATTENTION:
+        Normally, a profile is a succession of points in a vertical plane, aligned along a trace.
+        In this implementation, the points can be in 3D space, not necessarily aligned.
+        Some routines have a 'cumul' parameter to compute the curvilinear abscissa along the section.
+        If 'cumul' is True, the real curvilinear abscissa is computed.
+        If 'cumul' is False, the distance **between each point and the first point** is computed.
     """
 
-    def __init__(self, name, data_sect='',parent=None) -> None:
+    def __init__(self, name:str, data_sect:str | np.ndarray | list | vector = '', parent = None) -> None:
+        """ Initialization of a profile
+
+        :param name: name of the profile
+        :param data_sect: section data as a string (x z) separated by spaces and line breaks
+        :param parent: parent object (crosssections)
+        """
+
         super().__init__(name=name)
 
-        if data_sect!='':
-            for curline in data_sect.splitlines():
-                values=curline.split(' ')
-                curvert=wolfvertex(float(values[0]),0.,float(values[1]))
-                self.add_vertex(curvert)
+        if not isinstance(data_sect, (str, np.ndarray, list, vector)):
+            raise TypeError(_('data_sect must be a string, numpy array or list'))
 
         # Les positions de référence sont intanciées à None
         # Elles sont accessibles comme "property" de l'objet --> valeur "brute"
@@ -156,9 +183,6 @@ class profile(vector):
         #  - bankleft_s3D, bankright_s3D, bed_s3D qui retournent la position curvi 3D quel que soit le format de stockage
         #  - bankleft_sz, bankright_sz, bed_sz qui retournent un couple (s,z) quel que soit le format de stockage
 
-
-
-
         self._bankleft=None
         self._bankright=None
         self._bed=None
@@ -174,27 +198,85 @@ class profile(vector):
         self.up:profile = None
         self.down:profile = None
 
-        self.laz=False
+        self.laz = False # if True, points from LAZ file are loaded around the section
 
         if parent is not None:
             assert isinstance(parent,crosssections), _('Bad type of parent object')
+
         self.parent=parent
 
-        self.zdatum = 0.
-        self.add_zdatum=False
+        # self.zdatum = 0.
+        # self.add_zdatum = False
 
-        self.sdatum = 0.
-        self.add_sdatum=False
+        # self.sdatum = 0.
+        # self.add_sdatum = False
 
         self.orient = None
 
         self.sz = None
         self.sz_bankbed = None
         self.s3d_bankbed = None
-        self.prepared=False # if True, one can call self.sz instead of self.get_sz
+        self.prepared = False # if True, one can call self.sz instead of self.get_sz
+
+        self.smin = -99999
+        self.smax = -99999
+        self.zmin = -99999
+        self.zmax = -99999
+
+        # Uniform discharge
+        self.q_slope = None # Based on imposed slope and roughness
+        self.q_down = 0.  # Based on downstream slope (if oriented sections exist) and roughness
+        self.q_up = 0.  # Based on upstream slope (if oriented sections exist) and roughness
+        self.q_centered = 0. # Based on centered slope (if oriented sections exist) and roughness
+
+        self.wetarea = None
+        self.wetperimeter = None
+        self.hydraulicradius = None
+        self.waterdepth = None
+        self.localwidth = None
+        self.criticaldischarge = None
+
+        self._linestring_sz = None
+        self._linestring_s3dz = None
+
+        if isinstance(data_sect, str):
+            if data_sect != '':
+                for curline in data_sect.splitlines():
+                    values=curline.split(' ')
+                    curvert=wolfvertex(float(values[0]), 0., float(values[1]))
+                    self.add_vertex(curvert)
+                self.prepare()
+            else:
+                logging.debug(_('Empty data_sect string -- no vertex added'))
+        elif isinstance(data_sect, np.ndarray):
+            if data_sect.shape[1]==2:
+                for cur in data_sect:
+                    curvert=wolfvertex(float(cur[0]), 0., float(cur[1]))
+                    self.add_vertex(curvert)
+                self.prepare()
+            else:
+                logging.error(_('Bad shape of input array in data_sect -- no vertex added'))
+        elif isinstance(data_sect, list):
+            if all(isinstance(item, (list, tuple, np.ndarray)) and len(item)==2 for item in data_sect):
+                for cur in data_sect:
+                    curvert=wolfvertex(float(cur[0]), 0., float(cur[1]))
+                    self.add_vertex(curvert)
+                self.prepare()
+            elif all(isinstance(item, wolfvertex) for item in data_sect):
+                self.add_vertex(data_sect)
+                self.prepare()
+            else:
+                logging.error(_('Bad shape of input list in data_sect -- no vertex added'))
+        elif isinstance(data_sect, vector):
+            self.add_vertex(data_sect.myvertices.copy())
+            self.prepare()
 
     @property
     def linked_arrays(self):
+        """ Return the linked arrays from parent crosssection if any.
+        Useful to plot associated data along the section.
+        """
+
         if self.parent is not None:
             return self.parent.get_linked_arrays()
         else:
@@ -202,46 +284,60 @@ class profile(vector):
 
     @property
     def bankleft(self):
+        """ Return the bankleft reference point in its raw format (wolfvertex, index or s3D) """
         return self._bankleft
 
     @bankleft.setter
     def bankleft(self,value):
-        self._bankleft=value
+        """ Set the bankleft reference point in its raw format (wolfvertex, index or s3D) """
+        self._bankleft = value
 
     @property
     def bankright(self):
+        """ Return the bankright reference point in its raw format (wolfvertex, index or s3D) """
         return self._bankright
 
     @bankright.setter
     def bankright(self,value):
-        self._bankright=value
+        """ Set the bankright reference point in its raw format (wolfvertex, index or s3D) """
+        self._bankright = value
 
-    @ property
+    @property
     def bankleft_down(self):
+        """ Return the bankleft_down reference point in its raw format (wolfvertex, index or s3D) """
         return self._bankleft_down
 
     @bankleft_down.setter
     def bankleft_down(self,value):
-        self._bankleft_down=value
+        """ Set the bankleft_down reference point in its raw format (wolfvertex, index or s3D) """
+        self._bankleft_down = value
 
     @property
     def bankright_down(self):
+        """ Return the bankright_down reference point in its raw format (wolfvertex, index or s3D) """
         return self._bankright_down
 
     @bankright_down.setter
     def bankright_down(self,value):
-        self._bankright_down=value
+        """ Set the bankright_down reference point in its raw format (wolfvertex, index or s3D) """
+        self._bankright_down = value
 
     @property
     def bed(self):
+        """ Return the bed reference point in its raw format (wolfvertex, index or s3D) """
         return self._bed
 
     @bed.setter
     def bed(self,value):
-        self._bed=value
+        """ Set the bed reference point in its raw format (wolfvertex, index or s3D) """
+        self._bed = value
 
     @property
     def bankleft_vertex(self):
+        """ Return the bankleft reference point as a wolfvertex whatever the storage format """
+        if self._bankleft is None:
+            return None
+
         if self.banksbed_postype == postype.BY_VERTEX:
             return self._bankleft
         elif self.banksbed_postype == postype.BY_INDEX:
@@ -251,6 +347,10 @@ class profile(vector):
 
     @property
     def bankright_vertex(self):
+        """ Return the bankright reference point as a wolfvertex whatever the storage format """
+        if self._bankright is None:
+            return None
+
         if self.banksbed_postype == postype.BY_VERTEX:
             return self._bankright
         elif self.banksbed_postype == postype.BY_INDEX:
@@ -260,6 +360,10 @@ class profile(vector):
 
     @property
     def bankleft_down_vertex(self):
+        """ Return the bankleft_down reference point as a wolfvertex whatever the storage format """
+        if self._bankleft_down is None:
+            return None
+
         if self.banksbed_postype == postype.BY_VERTEX:
             return self._bankleft_down
         elif self.banksbed_postype == postype.BY_INDEX:
@@ -269,6 +373,10 @@ class profile(vector):
 
     @property
     def bankright_down_vertex(self):
+        """ Return the bankright_down reference point as a wolfvertex whatever the storage format """
+        if self._bankright_down is None:
+            return None
+
         if self.banksbed_postype == postype.BY_VERTEX:
             return self._bankright_down
         elif self.banksbed_postype == postype.BY_INDEX:
@@ -278,6 +386,10 @@ class profile(vector):
 
     @property
     def bed_vertex(self):
+        """ Return the bed reference point as a wolfvertex whatever the storage format """
+        if self._bed is None:
+            return None
+
         if self.banksbed_postype == postype.BY_VERTEX:
             return self._bed
         elif self.banksbed_postype == postype.BY_INDEX:
@@ -287,6 +399,7 @@ class profile(vector):
 
     @property
     def bankleft_s3D(self):
+        """ Return the bankleft reference point as a s3D position whatever the storage format """
         if self.banksbed_postype == postype.BY_S3D:
             return self._bankleft
         else:
@@ -294,8 +407,8 @@ class profile(vector):
             # --> projection x,y sur la trace --> récupération de 's'
             # --> calcul de la distance s3D via shapely LineString sz en projetant '(s,z)'
             if self.bankleft_vertex is not None:
-                ls2d = self.asshapely_ls()
-                lssz = self.asshapely_sz()
+                ls2d = self.linestring
+                lssz = self.linestring_sz
                 curvert = self.bankleft_vertex
                 s = ls2d.project(Point(curvert.x, curvert.y))
                 s3d = lssz.project(Point(s,curvert.z))
@@ -305,6 +418,7 @@ class profile(vector):
 
     @property
     def bankright_s3D(self):
+        """ Return the bankright reference point as a s3D position whatever the storage format """
         if self.banksbed_postype == postype.BY_S3D:
             return self._bankright
         else:
@@ -312,8 +426,8 @@ class profile(vector):
             # --> projection x,y sur la trace --> récupération de 's'
             # --> calcul de la distance s3D via shapely LineString sz en projetant '(s,z)'
             if self.bankright_vertex is not None:
-                ls2d = self.asshapely_ls()
-                lssz = self.asshapely_sz()
+                ls2d = self.linestring
+                lssz = self.linestring_sz
                 curvert = self.bankright_vertex
                 s = ls2d.project(Point(curvert.x, curvert.y))
                 s3d = lssz.project(Point(s,curvert.z))
@@ -323,6 +437,7 @@ class profile(vector):
 
     @property
     def bankleft_down_s3D(self):
+        """ Return the bankleft_down reference point as a s3D position whatever the storage format """
         if self.banksbed_postype == postype.BY_S3D:
             return self._bankleft_down
         else:
@@ -330,8 +445,8 @@ class profile(vector):
             # --> projection x,y sur la trace --> récupération de 's'
             # --> calcul de la distance s3D via shapely LineString sz en projetant '(s,z)'
             if self.bankleft_down_vertex is not None:
-                ls2d = self.asshapely_ls()
-                lssz = self.asshapely_sz()
+                ls2d = self.linestring
+                lssz = self.linestring_sz
                 curvert = self.bankleft_down_vertex
                 s = ls2d.project(Point(curvert.x, curvert.y))
                 s3d = lssz.project(Point(s,curvert.z))
@@ -341,6 +456,7 @@ class profile(vector):
 
     @property
     def bankright_down_s3D(self):
+        """ Return the bankright_down reference point as a s3D position whatever the storage format """
         if self.banksbed_postype == postype.BY_S3D:
             return self._bankright_down
         else:
@@ -348,8 +464,8 @@ class profile(vector):
             # --> projection x,y sur la trace --> récupération de 's'
             # --> calcul de la distance s3D via shapely LineString sz en projetant '(s,z)'
             if self.bankright_down_vertex is not None:
-                ls2d = self.asshapely_ls()
-                lssz = self.asshapely_sz()
+                ls2d = self.linestring
+                lssz = self.linestring_sz
                 curvert = self.bankright_down_vertex
                 s = ls2d.project(Point(curvert.x, curvert.y))
                 s3d = lssz.project(Point(s,curvert.z))
@@ -359,6 +475,7 @@ class profile(vector):
 
     @property
     def bed_s3D(self):
+        """ Return the bed reference point as a s3D position whatever the storage format """
         if self.banksbed_postype == postype.BY_S3D:
             return self._bed
         else:
@@ -366,8 +483,8 @@ class profile(vector):
             # --> projection x,y sur la trace --> récupération de 's'
             # --> calcul de la distance s3D via shapely LineString sz en projetant '(s,z)'
             if self.bed_vertex is not None:
-                ls2d = self.asshapely_ls()
-                lssz = self.asshapely_sz()
+                ls2d = self.linestring
+                lssz = self.linestring_sz
                 curvert = self.bed_vertex
                 s = ls2d.project(Point(curvert.x, curvert.y))
                 s3d = lssz.project(Point(s,curvert.z))
@@ -377,35 +494,40 @@ class profile(vector):
 
     @property
     def bankleft_sz(self):
-        ls2d = self.asshapely_ls()
+        """ Return the bankleft reference point as a (s,z) tuple whatever the storage format """
+        ls2d = self.linestring
         curvert = self.bankleft_vertex
         s = ls2d.project(Point(curvert.x, curvert.y))
         return s, curvert.z
 
     @property
     def bankright_sz(self):
-        ls2d = self.asshapely_ls()
+        """ Return the bankright reference point as a (s,z) tuple whatever the storage format """
+        ls2d = self.linestring
         curvert = self.bankright_vertex
         s = ls2d.project(Point(curvert.x, curvert.y))
         return s, curvert.z
 
     @property
     def bed_sz(self):
-        ls2d = self.asshapely_ls()
+        """ Return the bed reference point as a (s,z) tuple whatever the storage format """
+        ls2d = self.linestring
         curvert = self.bed_vertex
         s = ls2d.project(Point(curvert.x, curvert.y))
         return s, curvert.z
 
     @property
     def bankleft_down_sz(self):
-        ls2d = self.asshapely_ls()
+        """ Return the bankleft_down reference point as a (s,z) tuple whatever the storage format """
+        ls2d = self.linestring
         curvert = self.bankleft_down_vertex
         s = ls2d.project(Point(curvert.x, curvert.y))
         return s, curvert.z
 
     @property
     def bankright_down_sz(self):
-        ls2d = self.asshapely_ls()
+        """ Return the bankright_down reference point as a (s,z) tuple whatever the storage format """
+        ls2d = self.linestring
         curvert = self.bankright_down_vertex
         s = ls2d.project(Point(curvert.x, curvert.y))
         return s, curvert.z
@@ -414,17 +536,21 @@ class profile(vector):
 
         self.update_lengths()
 
-        # for curl in self._lengthparts3D
 
-    def triangulation_gltf(self, zmin):
+    def triangulation_gltf(self, zmin:float):
         """
         Génération d'un info de triangulation pour sortie au format GLTF --> Blender
-        :zmin : position d'altitude minimale de la triangulation
+
+        La triangulation est constituée de la section et d'une base plane à l'altitude zmin, a priori sous le lit de la rivière.
+
+        :param zmin: position d'altitude minimale de la triangulation
         """
+
         section = self.asnparray3d()
         base = section.copy()
         base[:,2] = zmin
-        points = np.concatenate((section,base),axis=0)
+
+        points = np.concatenate((section,base), axis=0)
         triangles=[]
         nb=self.nbvertices
         for j in range (nb-1):
@@ -436,15 +562,20 @@ class profile(vector):
                 c = b
                 b = a+1
 
-        return points,triangles
+        return points, triangles
 
-    def triangulation_ponts(self,x,y, zmax):
+    def triangulation_ponts(self, x:float ,y:float, zmax:float):
         """
         Triangulation d'une section de pont
+
+        :param x: coordonnée X du point de référence du pont
+        :param y: coordonnée Y du point de référence du pont
+        :param zmax: altitude du tablier du pont
         """
+
         section = self.asnparray3d()
-        x1,y1=find_xy(section,x,y)
-        parallele = partranslation(section,x1,y1)
+        x1,y1=_find_shift_at_xy(section,x,y)
+        parallele = _shift_np(section,x1,y1)
 
         base1 = section.copy()
         base1[:,2]= zmax
@@ -490,29 +621,60 @@ class profile(vector):
         triangles.append([len(section)-1,len(section)*2-1,len(section)*4-1])
         return(np.asarray([[curpt[0],curpt[2],-curpt[1]] for curpt in points],dtype=np.float32),np.asarray(triangles,dtype=np.uint32))
 
-    def set_orient(self):
+    def _set_orient(self):
         """
         Calcul du vecteur directeur de la section sur base des points extrêmes
         """
+
+        if self.nbvertices<2:
+            logging.error(_('Not enough vertices to define an orientation'))
+            self.orient = np.zeros(2)
+            return
+
         self.orient = asarray([self.myvertices[-1].x-self.myvertices[0].x,
                               self.myvertices[-1].y-self.myvertices[0].y])
-        self.orient = self.orient /np.linalg.norm(self.orient)
 
-    def get_xy_from_s(self,s) -> tuple[float, float]:
+        dist = np.linalg.norm(self.orient)
+        if dist==0.:
+            logging.error(_('Bad vertices to define an orientation -- identical points'))
+            self.orient = np.zeros(2)
+            return
+
+        self.orient = self.orient / np.linalg.norm(self.orient)
+
+    @property
+    def trace_increments(self):
+        """ Return the orientation vector of the section (unit vector in the XY plane)
+        """
+        if self.orient is None:
+            self._set_orient()
+        return self.orient
+
+    def get_xy_from_s(self, s:float) -> tuple[float, float]:
         """
         Récupération d'un tuple (x,y) sur base d'une distance 2D 's' orientée dans l'axe de la section
+
+        :param s: distance curviligne 2D le long de la section supposée plane étant donné l'utilisation de l'orientation
         """
+
         if self.orient is None:
-            self.set_orient()
+            self._set_orient()
 
         return self.myvertices[0].x+self.orient[0]*s,self.myvertices[0].y+self.orient[1]*s
 
-    def set_vertices_sz_orient(self, sz:np.ndarray, xy1:np.ndarray, xy2:np.ndarray):
+    def set_vertices_sz_orient(self, sz:np.ndarray | tuple | list, xy1:np.ndarray | list | tuple, xy2:np.ndarray | list | tuple):
         """
         Ajout de vertices depuis :
-          - une matrice numpy (s,z) -- shape = (nb_vert,2)
-          - d'un point source [x,y]_1
-          - d'un point visé [x,y]_2
+          - une matrice numpy (s,z) -- shape = (nb_vert,2) ou une liste ou un tuple convertibles en numpy array
+          - un point source [x,y]
+          - un point visé [x,y]
+
+        Le point source correspond au vertex de s=0.
+        Le point visé sert uniquement à définir l'orientation de la section.
+
+        :param sz: matrice numpy (s,z) -- shape = (nb_vert,2)
+        :param xy1: point source [x,y]
+        :param xy2: point visé [x,y]
         """
 
         if isinstance(sz,list):
@@ -539,19 +701,36 @@ class profile(vector):
                 for cur in sz:
                     x, y = xy1[0] + dx*cur[0], xy1[1] + dy*cur[0]
                     self.add_vertex(wolfvertex(x, y, float(cur[1])))
+            else:
+                logging.error(_('Bad input points in set_vertices_sz_orient -- identical points'))
+        else:
+            logging.error(_('Bad shape of input arrays in set_vertices_sz_orient'))
 
-    def get_laz_around(self,length_buffer=10.):
+    def get_laz_around(self, length_buffer:float = 10.):
         """
         Récupération de points LAZ autour de la section
+
+        :param length_buffer: distance latérale [m] autour de la section pour la récupération des points LAZ
         """
-        myls = self.asshapely_ls()
-        mypoly = myls.buffer(length_buffer,cap_style=CAP_STYLE.square)
-        mybounds = ((mypoly.bounds[0],mypoly.bounds[2]),(mypoly.bounds[1],mypoly.bounds[3]))
+
+        self.laz = False
+
+        if self.parent is None:
+            logging.error(_('No parent crosssection object -- cannot get LAZ points'))
+            return
+
+        if self.parent.gridlaz is None:
+            logging.error(_('No LAZ grid in parent crosssection object -- cannot get LAZ points'))
+            return
+
+        mypoly = self.linestring.buffer(length_buffer, cap_style=CAP_STYLE.square)
+        mybounds = ((mypoly.bounds[0], mypoly.bounds[2]), (mypoly.bounds[1], mypoly.bounds[3]))
 
         myxyz = self.parent.gridlaz.scan(mybounds)
 
-        prep_poly = prep(mypoly)
+        prep_poly = prepare(mypoly)
         mytests = [prep_poly.contains(Point(cur[:3])) for cur in myxyz]
+        destroy_prepared(prep_poly)
 
         self.usedlaz = np.asarray(myxyz[mytests])
 
@@ -586,13 +765,23 @@ class profile(vector):
 
         self.laz=True
 
-    def plot_laz(self,length_buffer=5.,fig:Figure=None,ax:Axes=None,show=False):
+    def plot_laz(self, length_buffer:float = 5., fig:Figure=None, ax:Axes=None, show=False):
         """
         Dessin des points LAZ sur le graphique Matplotlib
+
+        :param length_buffer: distance latérale [m] autour de la section pour la récupération des points LAZ
+        :param fig: figure Matplotlib
+        :param ax: axes Matplotlib
+        :param show: if True, show the figure
         """
+
         if not self.laz:
             self.get_laz_around(length_buffer)
 
+        if not self.laz:
+            logging.error(_('No LAZ points to plot'))
+            return None
+
         if ax is None:
             fig = plt.figure()
             ax=fig.add_subplot(111)
@@ -606,14 +795,17 @@ class profile(vector):
 
         return np.min(self.usedlaz[:,2]),np.max(self.usedlaz[:,2])
 
-    def slide_vertex(self,s):
+    def slide_vertex(self, s:float):
         """
         Glissement des vertices d'une constante 's'
+
+        :param s: distance de glissement dans l'axe de la section
         """
 
         if self.orient is None:
-            self.set_orient()
+            self._set_orient()
 
+        # increments de position
         dx = self.orient[0] *s
         dy = self.orient[1] *s
 
@@ -621,11 +813,15 @@ class profile(vector):
             curv.x +=dx
             curv.y +=dy
 
-    def movebankbed_index(self, which:Literal['left', 'right', 'bed', 'left_down', 'right_down'],
+    def movebankbed_index(self,
+                          which:Literal['left', 'right', 'bed', 'left_down', 'right_down'],
                           orientation:Literal['left', 'right']) -> None:
         """
-        Déplacement des points de référence sur base d'un index
-        Le cas échéant, adaptation du mode de stockage
+        Déplacement des points de référence sur base d'un index.
+        Le cas échéant, adaptation du mode de stockage.
+
+        :param which: point à déplacer ('left', 'right', 'bed', 'left_down', 'right_down')
+        :param orientation: direction du déplacement ('left' ou 'right')
         """
         if self.banksbed_postype == postype.BY_VERTEX:
             if which=='left':
@@ -707,9 +903,11 @@ class profile(vector):
             self.sz_bankbed = self.get_sz_banksbed(force=True)
             self.s3d_bankbed = self.get_s3d_banksbed(force=True)
 
-    def update_sdatum(self, new_sdatum):
+    def update_sdatum(self, new_sdatum:float):
         """
-        MAJ de la position de la section selon sa trace
+        Mise à jour de la position de la section selon sa trace
+
+        :param new_sdatum: nouvelle valeur de sdatum
         """
 
         sdatum_prev = self.sdatum
@@ -718,14 +916,16 @@ class profile(vector):
         self.add_sdatum = True
 
         if self.prepared:
-            delta = new_sdatum-sdatum_prev
+            delta = new_sdatum - sdatum_prev
             self.sz[:,0] += delta
             self.smin += delta
             self.smax += delta
 
-    def update_zdatum(self, new_zdatum):
+    def update_zdatum(self, new_zdatum:float):
         """
-        MAJ de l'altitude de référence de la section
+        Mise à jour de l'altitude de référence de la section
+
+        :param new_zdatum: nouvelle valeur de zdatum
         """
 
         zdatum_prev = self.zdatum
@@ -734,21 +934,28 @@ class profile(vector):
         self.add_zdatum = True
 
         if self.prepared:
-            delta = new_zdatum-zdatum_prev
-            self.sz[:,1] +=new_zdatum-zdatum_prev
+            delta = new_zdatum - zdatum_prev
+            self.sz[:,1] += delta
             self.zmin += delta
             self.zmax += delta
 
-    def update_banksbed_from_s3d(self, which, s:float):
+    def update_banksbed_from_s3d(self,
+                                 which:Literal['left', 'right', 'bed', 'left_down', 'right_down'],
+                                 s:float):
         """
-        MAJ des points de référence depuis une coordonnée curvi 3D
+        Mise à jour des points de référence depuis une coordonnée curvi 3D
+
+        :param which: point à modifier ('left', 'right', 'bed', 'left_down', 'right_down')
+        :param s: nouvelle position curvi 3D du point
         """
 
         if self.banksbed_postype != postype.BY_S3D:
-            s1, s2, s3 = self.get_s3d_banksbed()
+            s1, s2, s3, s4, s5 = self.get_s3d_banksbed()
             self.bankleft = s1
-            self.bed = s2
-            self.bankright = s3
+            self.bankleft_down = s2
+            self.bed = s3
+            self.bankright_down = s4
+            self.bankright = s5
 
         self.banksbed_postype = postype.BY_S3D
 
@@ -762,20 +969,34 @@ class profile(vector):
             self.bankright = s
 
             if self.prepared:
-                self.s3d_bankbed[2]=s
+                self.s3d_bankbed[4]=s
 
         elif which=='bed':
             self.bed = s
 
+            if self.prepared:
+                self.s3d_bankbed[2]=s
+
+        elif which=='left_down':
+            self.bankleft_down = s
+
             if self.prepared:
                 self.s3d_bankbed[1]=s
 
+        elif which=='right_down':
+            self.bankright_down = s
+
+            if self.prepared:
+                self.s3d_bankbed[3]=s
+
         if self.prepared:
             self.sz_bankbed = self.get_sz_banksbed(force=True)
 
-    def save(self,f):
+    def save(self, f):
         """
         Surcharge de l'opération d'écriture
+
+        :param f: fichier ouvert en écriture
         """
 
         if self.parent.forcesuper:
@@ -789,68 +1010,76 @@ class profile(vector):
                     which = "LEFT"
                 elif curvert is self.bankright:
                     which = "RIGHT"
+                elif curvert is self.bankleft_down:
+                    which = "LEFT_DOWN"
+                elif curvert is self.bankright_down:
+                    which = "RIGHT_DOWN"
 
-                f.write("{0}\t{1}\t{2}\t{3}\t{4}\n".format(self.myname,curvert.x,curvert.y,which,curvert.z))
+                f.write("{0}\t{1}\t{2}\t{3}\t{4}\n".format(self.myname, curvert.x, curvert.y, which, curvert.z))
 
-    def get_s_from_xy(self, xy:wolfvertex) -> float:
+    def get_s_from_xy(self, xy:wolfvertex, cumul:bool = False) -> float:
         """
-        Retourne la coordonnér curvi sur base d'un vertex
+        Retourne la coordonnée curviligne (ou distance euclidienne selon l'orientation de la section)
+        du point xy donné en tant qu'objet wolfvertex.
+
+        Dans cette routine, 'cumul' est à False par défaut pour être rétro-compatible avec les versions précédentes.
+        ATTENTION: Cette valeur par défaut n'est pas identique à celle utilisée dans 'get_sz'.
+
+        :param xy: vertex dont on veut la coordonnée curvi 2D
+        :param cumul: si True, la coordonnée curvi 2D est cumulée (distance le long de la section)
+                       si False, la coordonnée curvi 2D est la distance euclidienne au point de départ
         """
 
+        if cumul:
+            s = self.linestring.project(Point(xy.x, xy.y))
+            return s
+
         x1 = self.myvertices[0].x
         y1 = self.myvertices[0].y
         length = math.sqrt((xy.x-x1)**2.+(xy.y-y1)**2.)
 
         return length
 
-    def get_sz(self, cumul=True) -> tuple[np.ndarray, np.ndarray]:
-        """
-        Retourne 2 vecteurs avec la position curvi 2D et l'altitude des points
-        """
+    # def get_sz(self, cumul=True) -> tuple[np.ndarray, np.ndarray]:
+    #     """
+    #     Surcharge de la méthode get_sz de la classe mère wolfsection pour ajouter les datums s et z.
 
-        if self.prepared:
-            return self.sz[:,0], self.sz[:,1]
+    #     :param cumul: si True, la coordonnée curvi 2D est cumulée (distance le long de la section)
+    #                    si False, la coordonnée curvi 2D est la distance euclidienne au point de départ
+    #     :return: tuple (s,z) avec s la coordonnée curvi 2D
+    #     """
 
-        z = asarray([self.myvertices[i].z for i in range(self.nbvertices)])
+    #     if self.prepared:
+    #         return self.sz[:,0], self.sz[:,1]
 
-        if self.add_zdatum:
-            z+=self.zdatum
-
-        nb = len(z)
-        s = zeros(nb)
+    #     s, z = super().get_sz(cumul=cumul)
 
-        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
+    #     if self.add_zdatum:
+    #         z += self.zdatum
 
-                length = np.sqrt((x2-x1)**2.+(y2-y1)**2.)
-                s[i+1] = s[i]+length
+    #     if self.add_sdatum:
+    #         s += self.sdatum
 
-                x1=x2
-                y1=y2
-        else:
-            for i in range(nb):
-                s[i] = self.myvertices[0].dist2D(self.myvertices[i])
+    #     return s,z
 
-        if self.add_sdatum:
-            s+=self.sdatum
+    def set_sz(self, sz:np.ndarray, trace:list[tuple[float, float]]):
+        """
+        Calcule les positions des vertices sur base d'une matrice sz et d'une trace.
 
-        return s,z
+        :param s: colonne 0
+        :param z: colonne 1
+        :param trace: liste de 2 couples xy -> [[x1,y1], [x2,y2]]
 
-    def set_sz(self, sz, trace):
-        """
-        Calcule les positions des vertices sur base d'une matrice sz et d'une trace
-            s : colonne 0
-            z : colonne 1
-            trace : liste de 2 couples xy -> [[x1,y1], [x2,y2]]
+        FIXME: Vérifier la possibilité de fusionner avec set_vertices_sz_orient
         """
 
         orig = trace[0]
         end = trace[1]
 
+        if np.all(np.asarray(orig)==np.asarray(end)):
+            logging.error(_('Bad input points in set_sz -- identical points'))
+            return
+
         vec = np.asarray(end)-np.asarray(orig)
         vec = vec/np.linalg.norm(vec)
 
@@ -863,7 +1092,11 @@ class profile(vector):
     def get_sz_banksbed(self, cumul=True, force:bool=False) -> tuple[float, float, float, float, float, float, float, float, float, float]:
         """
         Retourne les positions des points de référence  mais avec la coordonnée curvi 2D
-         - (sleft, sbed, sright, zleft, zbed, zright)
+         - (sleft, sbed, sright, zleft, zbed, zright, sbankleft_down, sbankright_down, zbankleft_down, zbankright_down)
+
+        :param cumul: si True, la coordonnée curvi 2D est cumulée (distance le long de la section)
+                       si False, la coordonnée curvi 2D est la distance euclidienne au point de départ
+        :param force: si True, force le recalcul même si la section est déjà préparée
         """
 
         if self.prepared and not force:
@@ -952,16 +1185,16 @@ class profile(vector):
 
         return sleft,sbed,sright,zleft,zbed,zright, sbankleft_down, sbankright_down, zbankleft_down, zbankright_down
 
-    def get_s3d_banksbed(self, force:bool=False)-> tuple[float, float, float]:
+    def get_s3d_banksbed(self, force:bool=False)-> tuple[float, float, float, float, float]:
         """
         Retourne les coordonnée curvi 3D des points de référence
-         - (sleft, sbed, sright)
+         - (sleft, sleft_down, sbed, sright_down, sright)
         """
 
         if self.prepared and not force:
             return self.s3d_bankbed
 
-        return self.bankleft_s3D, self.bed_s3D, self.bankright_s3D
+        return self.bankleft_s3D, self.bankleft_down_s3D, self.bed_s3D, self.bankright_down_s3D, self.bankright_s3D
 
     def asshapely_sz(self) -> LineString:
         """
@@ -971,6 +1204,19 @@ class profile(vector):
         s,z = self.get_sz()
         return LineString(np.asarray([[curs, curz] for curs, curz in zip(s,z)]))
 
+    @property
+    def linestring_sz(self) -> LineString:
+        """
+        Retroune la section comme objet shapely - polyligne selon la trace avec altitudes
+        """
+
+        if self._linestring_sz is not None:
+            return self._linestring_sz
+
+        self._linestring_sz = self.asshapely_sz()
+        prepare(self._linestring_sz)
+        return self._linestring_sz
+
     def asshapely_s3dz(self) -> LineString:
         """
         Retroune la section comme objet shapely - polyligne selon la trace 3D avec altitudes
@@ -980,9 +1226,32 @@ class profile(vector):
         z = [cur.z for cur in self.myvertices]
         return LineString(np.asarray([[curs, curz] for curs, curz in zip(s,z)]))
 
+    @property
+    def s3dz(self) -> np.ndarray:
+        """
+        Retroune la section comme matrice numpy (s3d,z)
+        """
+
+        s = self.get_s3d()
+        z = [cur.z for cur in self.myvertices]
+        return np.column_stack([s,z])
+
+    @property
+    def linestring_s3dz(self) -> LineString:
+        """
+        Retroune la section comme objet shapely - polyligne selon la trace 3D avec altitudes
+        """
+
+        if self._linestring_s3dz is not None:
+            return self._linestring_s3dz
+
+        self._linestring_s3dz = self.asshapely_s3dz()
+        prepare(self._linestring_s3dz)
+        return self._linestring_s3dz
+
     def prepare(self,cumul=True):
         """
-        Pre-Compute sz and sz_banked to avoid multiple computation
+        Pre-Compute sz, sz_banked and shapely objects to avoid multiple computation
         """
 
         self.reset_prepare()
@@ -994,12 +1263,30 @@ class profile(vector):
         self.zmin = min(y)
         self.zmax = max(y)
 
-        self.prepare_shapely()
+        self.prepare_shapely(linestring=True, polygon=False)
         self.sz_bankbed = list(self.get_sz_banksbed(cumul))
         self.s3d_bankbed = list(self.get_s3d_banksbed())
 
         self.prepared=True
 
+    def __del__(self):
+
+        self.reset_prepare()
+        super().__del__()
+
+    def _reset_linestring_sz_s3dz(self):
+
+        if self._linestring_sz is not None:
+            if is_prepared(self._linestring_sz):
+                destroy_prepared(self._linestring_sz)
+            self._linestring_sz=None
+
+        if self._linestring_s3dz is not None:
+            if is_prepared(self._linestring_s3dz):
+                destroy_prepared(self._linestring_s3dz)
+            self._linestring_s3dz=None
+
+
     def reset_prepare(self):
         """
         Réinitialisation de la préparation de la section
@@ -1013,173 +1300,35 @@ class profile(vector):
         self.sz_bankbed = None
         self.s3d_bankbed = None
         self.reset_linestring()
+        self._reset_linestring_sz_s3dz()
 
         self.prepared=False
 
-    def get_min(self):
+    def get_min(self) -> wolfvertex:
+        """ Return the vertex with minimum elevation """
         return sorted(self.myvertices,key=lambda x:x.z)[0]
 
-    def get_max(self):
+    def get_max(self) -> wolfvertex:
+        """ Return the vertex with maximum elevation """
         return sorted(self.myvertices,key=lambda x:x.z)[-1]
 
-    def get_minz(self):
+    def get_minz(self) -> float:
+        """ Return the minimum elevation """
         return amin(list(x.z for x in self.myvertices))
 
-    def get_maxz(self):
+    def get_maxz(self) -> float:
+        """ Return the maximum elevation """
         return amax(list(x.z for x in self.myvertices))
 
-    def plot_linked(self, fig, ax, linked_arrays:dict):
-
-        colors=['red','blue','green']
-
-        k=0
-        for curlabel, curarray in linked_arrays.items():
-            if curarray.plotted:
-                myls = self.asshapely_ls()
-
-                length = myls.length
-                ds = min(curarray.dx,curarray.dy)
-                nb = int(np.ceil(length/ds*2))
-
-                alls = np.linspace(0,int(length),nb)
-
-                pts = [myls.interpolate(curs) for curs in alls]
-
-                allz = [curarray.get_value(curpt.x,curpt.y) for curpt in pts]
-
-                if np.max(allz)>-99999:
-                    ax.plot(alls,allz,
-                            color=colors[np.mod(k,3)],
-                            lw=2.0,
-                            label=curlabel)
-                k+=1
-
-    def _plot_only_cs(self,fig:Figure=None,ax:Axes=None,label='',alpha=0.8,lw=1.,style: str ='dashed',centerx=0.,centery=0.,grid=True, col_ax: str = 'black'):
-        # plot
-        x,y=self.get_sz()
-
-        sl,sb,sr,yl,yb,yr, sld, srd, yld, yrd = self.get_sz_banksbed()
-
-        if centerx >0. and sb!=-99999.:
-            decal = centerx-sb
-            x+=decal
-            sl+=decal
-            sb+=decal
-            sr+=decal
-
-        if centery >0. and yb!=-99999.:
-            decal = centery-yb
-            y+=decal
-            yl+=decal
-            yb+=decal
-            yr+=decal
-
-        ax.plot(x,y,color=col_ax,
-                lw=lw,
-                linestyle=style,
-                alpha=alpha,
-                label=label)
-
-        curtick=ax.get_xticks()
-        ax.set_xticks(np.arange(min(curtick[0],(x[0]//2)*2),max(curtick[-1],(x[-1]//2)*2),2))
-
-        if sl != -99999.:
-            ax.plot(sl,yl,'or',alpha=alpha)
-        if sb != -99999.:
-            ax.plot(sb,yb,'ob',alpha=alpha)
-        if sr != -99999.:
-            ax.plot(sr,yr,'og',alpha=alpha)
-        if sld != -99999.:
-            ax.plot(sld,yld,'*r',alpha=alpha)
-        if srd != -99999.:
-            ax.plot(srd,yrd,'*g',alpha=alpha)
-
-    def plot_cs(self, fwl=None, show=False, forceaspect=True, fig:Figure=None, ax:Axes=None, plotlaz=True, clear=True, linked_arrays:dict={}):
-        # plot
-        x,y=self.get_sz()
-
-        sl,sb,sr,yl,yb,yr, sld, srd, yld, yrd = self.get_sz_banksbed()
-
-        xmin=x[0]
-        xmax=x[-1]
-        ymin=self.get_minz()
-        ymax=self.get_maxz()
+    def relation_oneh(self, cury:float, x:float = None, y:float = None):
+        """ Compute the hydraulic characteristics for a given water elevation 'cury'
 
-        dy=ymax-ymin
-        ymin-=dy/4.
-        ymax+=dy/4.
-
-        if ax is None:
-            redraw=False
-            fig = plt.figure()
-            ax=fig.add_subplot(111)
-        else:
-            redraw=True
-            if clear:
-                ax.cla()
-
-        if np.min(y) != -99999. and np.max(y) != -99999.:
-            ax.plot(x,y,color='black',
-                    lw=2.0,
-                    label='Profil')
-
-        if self.parent is not None:
-            if plotlaz and self.parent.gridlaz is not None:
-                minlaz=ymin
-                maxlaz=ymax
-                minlaz,maxlaz=self.plot_laz(fig=fig,ax=ax)
-                if np.min(y) != -99999. and np.max(y) != -99999.:
-                    ymin = min(ymin,minlaz)
-                    ymax = max(ymax,maxlaz)
-                else:
-                    ymin = minlaz
-                    ymax = maxlaz
-
-        self.plot_linked(fig,ax,linked_arrays)
-
-        if fwl is not None:
-            ax.fill_between(x,y,fwl,where=y<=fwl,facecolor='cyan',alpha=0.3,interpolate=True)
-
-        if sl != -99999.:
-            ax.plot(sl,yl,'or')
-        if sb != -99999.:
-            ax.plot(sb,yb,'ob')
-        if sr != -99999.:
-            ax.plot(sr,yr,'og')
-        if sld != -99999.:
-            ax.plot(sld,yld,'*r')
-        if srd != -99999.:
-            ax.plot(srd,yrd,'*g')
-
-        ax.set_title(self.myname)
-        ax.set_xlabel(_('Distance [m]'))
-        ax.set_ylabel('Elevation [EL.m]')
-        ax.legend()
-
-        tol=(xmax-xmin)/10.
-        ax.set_xlim(xmin-tol,xmax+tol)
-        ax.set_ylim(ymin,ymax)
-
-        nbticks = 20
-        dzticks = max((((ymax-ymin)/nbticks) // .25) *.25,.25)
-
-        ax.set_yticks(np.arange((ymin//.25)*.25,(ymax//.25)*.25,dzticks))
-        ax.grid()
-
-        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 sl,sb,sr,yl,yb,yr
-
-    def relation_oneh(self,cury,x=None,y=None):
+        :param cury: water elevation
+        :param x: optional x coordinates of the section (if None, use the section's coordinates)
+        :param y: optional y coordinates of the section (if None, use the section's coordinates)
+        :return: a,s,w,r  (wetted area, wetted perimeter, top width, hydraulic radius)
 
+        """
         if x is None and y is None:
             x,y=self.get_sz()
 
@@ -1224,7 +1373,7 @@ class profile(vector):
         else:
             r=0.
 
-        return a,s,w,r
+        return float(a), float(s), float(w), float(r)
 
     def relations(self, discretize: int = 100, plot = True):
         """
@@ -1232,6 +1381,7 @@ class profile(vector):
         of a specific hydraulic characteristic with respect to the water depth in the profile
         (wetted area, wetted perimeter, top width, water detph, hydraulic radius, critical discharge).
         """
+
         x,y=self.get_sz()
 
         ymin=min(y)
@@ -1263,7 +1413,7 @@ class profile(vector):
         if plot:                                        # In order to allow other usages apart from Graphprofile.
             self.wetarea = a
             self.wetperimeter = s
-            self.hyrdaulicradius = r
+            self.hydraulicradius = r
             self.waterdepth=h
             self.localwidth=w
             self.criticaldischarge = qcr
@@ -1271,6 +1421,11 @@ class profile(vector):
         return a,s,r,h,w,qcr
 
     def slopes(self):
+        """ Compute the slopes of the section with respect to the upstream and downstream sections """
+
+        if self.up is None or self.down is None:
+            logging.error(_('No upstream or downstream section defined for section {}').format(self.myname))
+            return 0.,0.,0.
 
         slopedown = (self.get_minz() - self.down.get_minz()) / abs(self.down.s - self.s+1.e-10)
         slopeup   = (self.up.get_minz() - self.get_minz()) / abs(self.s - self.up.s+1.e-10)
@@ -1278,30 +1433,52 @@ class profile(vector):
 
         return slopeup,slopecentered,slopedown
 
-    def ManningStrickler_Q(self,slope=1.e-3,nManning=0.,KStrickler=0.):
-        """Procédure générique pour obtenir une relation uniforme Q-H sur base
-            - nManning : un coefficient de frottement
-            - slope : une pente
+    def ManningStrickler_Q(self, slope:float = 1.e-3, nManning:float = 0., KStrickler:float = 0.):
+        """Procédure générique pour obtenir une relation uniforme Q-H sur base d'une pente et d'un coefficient de frottement.
+
+        :param slope: une pente
+        :param nManning: un coefficient de frottement
+        :param KStrickler: un coefficient de frottement (if nManning > 0.0, KStrickler is ignored)
         """
 
+        if slope <= 0.:
+            logging.error(_('No positive slope provided for section {}').format(self.myname))
+            return
+
+         # Calcul des caractéristiques hydrauliques si pas encore faites
+
+        if self.waterdepth is None:
+            self.relations(plot = True)
+
         if nManning==0. and KStrickler==0.:
+            logging.error(_('No friction coefficient provided for section {}').format(self.myname))
             return
-        elif nManning>0.:
-            coeff=1./nManning
+        elif nManning > 0.:
+            coeff = 1. / nManning
         elif KStrickler>0.:
             coeff = KStrickler
 
-        nn=len(self.waterdepth)
-        sqrtslope=math.sqrt(slope)
+        nn = len(self.waterdepth)
+        sqrtslope = math.sqrt(slope)
+
+        self.q_slope = asarray([coeff * self.hydraulicradius[k]**(2./3.)* sqrtslope * self.wetarea[k] for k in range(nn)])
 
-        self.q=asarray([coeff * self.hyrdaulicradius[k]**(2./3.)*sqrtslope * self.wetarea[k] for k in range(nn)])
+        return self.q_slope
 
-    def ManningStrickler_oneQ(self,slope=1.e-3,nManning=0.,KStrickler=0.,cury=0.):
+    def ManningStrickler_oneQ(self, slope:float = 1.e-3, nManning:float = 0., KStrickler:float = 0., cury:float = 0.):
         """Procédure générique pour obtenir une relation uniforme Q-H sur base
-            - nManning : un coefficient de frottement
-            - slope : une pente
+
+        :param slope: une pente
+        :param nManning: un coefficient de frottement
+        :param KStrickler: un coefficient de frottement (if nManning > 0.0, KStrickler is ignored)
+        :param cury: une hauteur d'eau
+        :return: le débit Q
         """
 
+        if slope <= 0.:
+            logging.error(_('No positive slope provided for section {}').format(self.myname))
+            return
+
         if nManning==0. and KStrickler==0.:
             return
         elif nManning>0.:
@@ -1317,16 +1494,19 @@ class profile(vector):
 
         return q
 
-    # Methods added
-    def deepcopy_profile(self, name: str = None):
+    def deepcopy_profile(self, name: str = None, appendstr: str = '_copy'):
         """
         This method returns a deepcopy of the active profile.
         The profile features are individually transferred, therefore,
         only the necessary features are copied.
+
+        :param name: name of the copied profile (if None, the current profile's name + appendstr is used)
+        :param appendstr: string to append to the current profile's name if no new name is given (default: '_copy')
+        :return: the copied profile
         """
         # if a new name is not given, we add _copy to the current profile's name.
         if name is None:
-            name = self.myname + "_copy"
+            name = self.myname + appendstr
 
         # We create the new  profile (copy).
         copied_profile = profile(name)
@@ -1339,21 +1519,31 @@ class profile(vector):
         copied_profile.bankright = copy.deepcopy(self.bankright)
         copied_profile.bed = copy.deepcopy(self.bed)
         copied_profile.banksbed_postype = copy.deepcopy(self.banksbed_postype)
+        copied_profile.bankleft_down = copy.deepcopy(self.bankleft_down)
+        copied_profile.bankright_down = copy.deepcopy(self.bankright_down)
 
         return copied_profile
 
-    def color_active_profile(self, width: float = 3., color: list = [255, 0, 0], plot_opengl = True):
+    def color_active_profile(self, width: float = 3., color: list = [255, 0, 0], plot_opengl:bool = True):
         """
         This method colors and thickens the active profile
         (default width : 3, default color: red).
+
+        :param width: width of the profile
+        :param color: color of the profile as a list of RGB values (0-255)
+        :param plot_opengl: if True, update the OpenGL plot of the parent zone
         """
+
         self.myprop.width = width
         self.myprop.color = getIfromRGB(color)
+
         if plot_opengl:
-            self.parentzone.plot(True) # FIXME (Parent zone)
+            if self.parentzone is not None:
+                self.parentzone.plot(True) # FIXME (Parent zone)
+
+    def highlighting(self, width: float = 3., color: list = [255, 0, 0] , plot_opengl:bool = True):
+        """ Alias for color_active_profile """
 
-    def highlightning(self, width: float = 3., color: list = [255, 0, 0] , plot_opengl = True):
-        """Alias for color_active_profile"""
         self.color_active_profile(width, color)
 
     def uncolor_active_profile(self, plot_opengl = True):
@@ -1364,28 +1554,40 @@ class profile(vector):
         self.myprop.color = getIfromRGB([0, 0, 0])
 
         if plot_opengl:
-            self.parentzone.plot(True)
+            if self.parentzone is not None:
+                self.parentzone.plot(True)
 
-    def withdrawing(self , plot_opengl = True):
+    def withdrawing(self, plot_opengl:bool = True):
         """Alias for uncolor_active_profile"""
+
         self.uncolor_active_profile(plot_opengl)
 
     def ManningStrickler_profile(self, slope: float =1.e-3, nManning: float =0., KStrickler: float=0.):
         """
-        Procédure générique pour obtenir une relation uniforme Q-H d'un profile sur base:
-            - nManning ou KStrickler: un coefficient de frottement,
-            - slope : une pente fournie (default: 0.001),
+        Procédure générique pour obtenir une relation uniforme Q-H d'un profile
+
+        :param slope: une pente
+        :param nManning: un coefficient de frottement
+        :param KStrickler: un coefficient de frottement (if nManning > 0.0, KStrickler is ignored)
 
         ainsi que les relations correspondant aux pentes aval(slope down), amont(slopeup), et amont-aval (centered).
+
+        :return: le débit Q maximum parmi les 4 relations
         """
         if self.down is not None and self.up is not None:
             slopeup,slopecentered,slopedown = self.slopes()
+            # slopes are not necessarily positive --> subsequent tests
+
+            slopeup = max(slopeup, 0.)
+            slopecentered = max(slopecentered, 0.)
+            slopedown = max(slopedown, 0.)
         else:
-            slopecentered = 0
-            slopedown = 0
-            slopeup = 0
+            slopecentered = 0.
+            slopedown = 0.
+            slopeup = 0.
 
         if nManning==0. and KStrickler==0.:
+            logging.error(_('No friction coefficient provided for section {}').format(self.myname))
             return
         elif nManning>0.:
             coeff=1./nManning
@@ -1396,40 +1598,31 @@ class profile(vector):
 
 
         sqrtslope = math.sqrt(slope)
-        if slopedown > 0:
-            sqrtslopedown= math.sqrt(slopedown)
-        else:
-            sqrtslopedown = 0.
+        sqrtslopedown= math.sqrt(slopedown)
+        sqrtslopecentered= math.sqrt(slopecentered)
+        sqrtslopeup= math.sqrt(slopeup)
 
-        if slopecentered > 0:
-            sqrtslopecentered= math.sqrt(slopecentered)
-        else:
-            sqrtslopecentered = 0.
-        if slopeup > 0:
-            sqrtslopeup= math.sqrt(slopeup)
-        else:
-            sqrtslopeup = 0.
+        self.q_slope = asarray([coeff*(self.hydraulicradius[k]**(2/3))*sqrtslope*self.wetarea[k] for k in range (nn)])
+        self.q_down=asarray([coeff * self.hydraulicradius[k]**(2./3.)*sqrtslopedown * self.wetarea[k] for k in range(nn)])
+        self.q_up=asarray([coeff * self.hydraulicradius[k]**(2./3.)*sqrtslopeup * self.wetarea[k] for k in range(nn)])
+        self.q_centered=asarray([coeff * self.hydraulicradius[k]**(2./3.)*sqrtslopecentered * self.wetarea[k] for k in range(nn)])
 
-        self.q_slope = asarray([coeff*(self.hyrdaulicradius[k]**(2/3))*sqrtslope*self.wetarea[k] for k in range (nn)])
-        self.q_down=asarray([coeff * self.hyrdaulicradius[k]**(2./3.)*sqrtslopedown * self.wetarea[k] for k in range(nn)])
-        self.q_up=asarray([coeff * self.hyrdaulicradius[k]**(2./3.)*sqrtslopeup * self.wetarea[k] for k in range(nn)])
-        self.q_centered=asarray([coeff * self.hyrdaulicradius[k]**(2./3.)*sqrtslopecentered * self.wetarea[k] for k in range(nn)])
         return max(max(self.q_slope), max(self.q_down), max(self.q_up), max(self.q_centered), max(self.criticaldischarge))
 
     def plotcs_profile(self,
                        fig: Figure = None,
                        ax: Axes = None,
-                       compare = None,
+                       compare:"profile" = None,
                        vecs : list = [],
                        col_structure: str ='none',
                        fwl: float = None,
                        fwd: float = None,
                        simuls:list=None,
-                       show = False,
-                       forceaspect= True,
-                       plotlaz= True,
-                       clear = True,
-                       redraw=True ):
+                       show:bool = False,
+                       forceaspect:bool = True,
+                       plotlaz:bool = True,
+                       clear:bool = True,
+                       redraw:bool = True ):
         """
         This method plots the physical geometry of the current cross section (profile).
 
@@ -1439,6 +1632,21 @@ class profile(vector):
            - idsimul: list of available numerical simulations containing this profile,
            - zsimul: list of water level in the simulations.
            - col_structure colors the structure displayed.
+
+        :param fig: Matplotlib figure
+        :param ax: Matplotlib axes
+        :param compare: reference profile to compare with
+        :param vecs: list of vector objects to plot on the section (e.g. levees, dikes, ...)
+        :param col_structure: color of the structures (default: 'none')
+        :param fwl: water level to plot (if None, no water level is plotted)
+        :param fwd: water depth to plot (if None, no water level is plotted)
+        :param simuls: list of simulations containing the profile (id, name, date, time, water level)
+        :param show: if True, show the figure
+        :param forceaspect: if True, force aspect ratio
+        :param plotlaz: if True, plot LAZ points if available
+        :param clear: if True, clear the axis before plotting
+        :param redraw: if True, redraw the figure after plotting
+
         """
 
         idsimul=None
@@ -1648,10 +1856,11 @@ class profile(vector):
                           fwd: float = None,
                           fwq: float = None,
                           simuls:list=None,
-                          show = False,
-                          clear = True,
-                          labels = True,
-                          redraw =True):
+                          show:bool = False,
+                          clear:bool = True,
+                          labels:bool = True,
+                          redraw:bool =True,
+                          force_label_to_right:bool = True):
         """
         This method plots the discharges relationship computed
         with the methods: relations and ManningStrcikler_profile.
@@ -1662,8 +1871,22 @@ class profile(vector):
         - idsimul: list of available numerical models.
         - qsimul: list of discharges in the available numerical models,
         - hsimul: list of water depth in the available numerical models.
+
+        :param fig: Matplotlib figure
+        :param ax: Matplotlib axes
+        :param fwl: water level to plot (if None, no water level is plotted)
+        :param fwd: water depth to plot (if None, no water level is plotted)
+        :param fwq: discharge to plot (if None, no discharge is plotted)
+        :param simuls: list of simulations containing the profile (id, name, date, time, discharge, water level)
+        :param show: if True, show the figure
+        :param clear: if True, clear the axis before plotting
+        :param labels: if True, show the legend
+        :param redraw: if True, redraw the figure after plotting
         """
 
+        if self.q_slope is None:
+            raise Exception(_('Please compute the discharge relationship first using the method "ManningStrickler_profile"'))
+
         hsimul  = None
         qsimul  = None
         idsimul = None
@@ -1681,12 +1904,18 @@ class profile(vector):
             if fwd is None or fwd <= 0:
                 fwd =0
                 fwl= self.zmin+ fwd
+                plot_wl = False
             elif fwd > 0 :
                 fwl = self.zmin + fwd
+                plot_wl = True
 
         elif fwl is not None:
             fwl = fwl
             fwd = fwl-self.zmin
+            plot_wl = True
+
+        if fig is None:
+            fig, ax = plt.subplots()
 
         # Creation of a new ax for cleaning purposes in the wolfhece.Graphprofile.
         myax2 = ax
@@ -1721,7 +1950,8 @@ class profile(vector):
             myax2.axhline(y=zb, color=_('blue'), alpha=1, lw=1, label =_('Bed'), ls =_('dotted'))
 
         # Desired water depth
-        myax2.axhspan(ymin= self.zmin, ymax =fwl,color=_('cyan'), alpha=0.2, lw=2, label =_('Desired water depth'))
+        if plot_wl:
+            myax2.axhspan(ymin= self.zmin, ymax =fwl,color=_('cyan'), alpha=0.2, lw=2, label =_('Desired water depth'))
 
         myax2.set_xlabel(_('Discharge - Q ($m^3/s$)'), size=12)
         myax2.set_ylim(self.zmin, self.zmax+1)
@@ -1729,7 +1959,10 @@ class profile(vector):
         if qsimul is not None:
             myax2.set_xlim(0., max(max(self.q_down),max(self.q_up),max(self.q_centered),max(self.q_slope), max(self.criticaldischarge),max(qsimul)))
         else:
-            myax2.set_xlim(0., max(max(self.q_down),max(self.q_up),max(self.q_centered),max(self.q_slope), max(self.criticaldischarge)))
+            if self and self.down and self.up:
+                myax2.set_xlim(0., max(max(self.q_down),max(self.q_up),max(self.q_centered),max(self.q_slope), max(self.criticaldischarge)))
+            else:
+                myax2.set_xlim(0., max(max(self.q_slope), max(self.criticaldischarge)))
 
         # Conversion methods for the second matplotlib ax
         def alt_to_depth(y):
@@ -1737,7 +1970,7 @@ class profile(vector):
         def depth_to_alt(y):
             return y+self.zmin
 
-        secax = myax2.secondary_yaxis(_('right'), functions=(alt_to_depth,depth_to_alt))
+        secax = myax2.secondary_yaxis('right', functions=(alt_to_depth,depth_to_alt))
         #secax.set_yticks(y)
         myax2.yaxis.tick_left()
         #myax2.set_yticks(alt_to_depth(self.waterdepth))
@@ -1750,106 +1983,351 @@ class profile(vector):
 
 
         if labels:
-            myax2.set_ylabel(_('Water depth - h\n($m$)'), size=12, rotation=270,labelpad=35)
-            myax2.yaxis.set_label_position(_('right'))
-            secax.set_ylabel(_('Altitude - Z\n($m$)'), size=12, labelpad=10)
+            myax2.set_ylabel(_('Altitude - Z ($m$)'), size=12, rotation=270,labelpad=35)
+            if force_label_to_right:
+                myax2.yaxis.set_label_position('right')
+            secax.set_ylabel(_('Water depth - h ($m$)'), size=12, labelpad=10)
             fig.suptitle('Discharges C.S. - %s'%(self.myname), size=15)
 
 
-        if show:
-            fig.show()
+        if show:
+            fig.show()
+
+    def plot_discharges_UnCr(self,
+                          fig: Figure = None,
+                          ax: Axes = None,
+                          fwl: float = None,
+                          fwd: float = None,
+                          fwq: float = None,
+                          simuls:list=None,
+                          show:bool = False,
+                          clear:bool = True,
+                          labels:bool = True,
+                          redraw:bool =True,
+                          force_label_to_right:bool = False):
+
+        self.plotcs_discharges(fig, ax, fwl, fwd, fwq, simuls, show, clear, labels, redraw, force_label_to_right)
+
+    def plotcs_hspw(self,
+                    fig:Figure = None, ax:Axes = None,
+                    fwl:float = None, fwd:float = None,
+                    fwq:float = None,
+                    show:bool = False, clear:bool = True,
+                    labels:bool = True, redraw:bool =True,
+                    force_label_to_right:bool = True):
+
+        """
+        This method plots the hydraulic geometries computed by the relations method
+        (Hydraulic radius, wetted area, wetted perimeter, Top width).
+
+        - fwl: for water level,
+        - fwd: for water depth,
+        - fwq: for water discharge.
+
+        :param fig: Matplotlib figure
+        :param ax: Matplotlib axes
+        :param fwl: water level to plot (if None, no water level is plotted)
+        :param fwd: water depth to plot (if None, no water level is plotted)
+        :param fwq: discharge to plot (if None, no discharge is plotted)
+        :param show: if True, show the figure
+        :param clear: if True, clear the axis before plotting
+        :param labels: if True, show the legend
+        :param redraw: if True, redraw the figure after plotting
+
+        """
+        if self.waterdepth is None:
+            self.relations()
+
+        if fig is None and ax is None:
+            fig, ax = plt.subplots()
+
+        sl,sb,sr,zl,zb,zr, sld, srd, zld, zrd = self.get_sz_banksbed()
+        x,y = self.get_sz()
+
+        if fwl is None:
+            if fwd is None or fwd <= 0:
+                fwd =0
+                fwl= self.zmin+ fwd
+                plot_wl = False
+            elif fwd > 0 :
+                fwl = self.zmin + fwd
+                plot_wl = True
+
+        elif fwl is not None:
+            fwl = fwl
+            fwd = fwl-self.zmin
+            plot_wl = True
+
+        # Creation of a new ax for cleaning purposes in the wolfhece.Graphprofile.
+        myax3 = ax
+        axt3 = ax
+        if redraw:
+            if clear:
+                axt3.clear()
+                # myax3.clear()
+
+        # Plots
+        # FIXME (Clearing issues) a second x axis for the Hydraulic radius to provide more clarity.
+        axt3.plot(self.hydraulicradius,self.waterdepth + self.zmin,color=_('green'),lw=2,label=_('H - Hydraulic radius($m$)'), ls= _('--')) #Plot the evaluation of the hydraulic radius as function of water depth
+        axt3.set_xlim(0, max(self.hydraulicradius))
+
+        myax3.plot(self.wetarea,self.waterdepth + self.zmin,color=_('black'),lw=2.0,label=_('S - Wet area ($m^2$)'))          #Plot the wetted area as function of water depth
+        myax3.plot(self.wetperimeter,self.waterdepth + self.zmin,color=_('magenta'),lw=1,label=_('P -  Wet perimeter($m$)'))  #Plot the wetted perimeter as function of water depth
+        myax3.plot(self.localwidth,self.waterdepth + self.zmin,color=_('red'),lw=1,label=_('W - Top Width ($m$)'))      #Plot the evalution of the water table as function of water depth
+
+        # Selection of hydraulic geometries based on their index
+        if fwq is not None and fwq > 0.:
+            # First, We select the closest critical discharge to the user's input.
+            mask = np.absolute(self.criticaldischarge - fwq)
+            index  = np.argmin(mask)
+            # Second, since the matrices have the same shapes and their elements are sorted likewise,
+            # we use the index of the selected critical discharge to find the corresponding hydraulic geometries.
+            cr_wetarea = self.wetarea[index]
+            cr_wetperimeter = self.wetperimeter[index]
+            cr_width = self.localwidth[index]
+            cr_radius = self.hydraulicradius[index]
+            cr_h = self.waterdepth[index]
+            myax3.plot(cr_wetarea,cr_h + self.zmin,'ok' )
+            myax3.annotate(_('$Critical$ $characteristics$ \nH: %s $m$ \nS: %s $m^2$ \nP: %s $m$ \nW: %s $m$  \n \n')% (round(cr_radius,2),round(cr_wetarea,2),round(cr_wetperimeter,2),round(cr_width,2)),\
+                 (cr_wetarea, cr_h + self.zmin),  alpha= 1, fontsize = _('x-small'),color =_('black'))
+
+            #Finally, we plot the critical hydraulic geometries as dots.
+            myax3.plot(cr_wetperimeter,cr_h + self.zmin,_('om') )
+            myax3.plot(cr_width,cr_h + self.zmin,_('or') )
+            myax3.plot(cr_radius,cr_h + self.zmin,_('og') )
+
+        #Displayed water depths and banks
+        if plot_wl:
+            myax3.axhspan(ymin= self.zmin, ymax =fwd + self.zmin,color=_('cyan'), alpha=0.2, lw=2, label =_('Desired water depth'))
+
+        if zl != -99999.:
+            myax3.axhline(y=zl, color=_('magenta'), alpha=1, lw=1, label =_('Left bank'), ls =_('dotted') )
+        if zr != -99999.:
+            myax3.axhline(y=zr, color=_('green'), alpha=1, lw=1, label =_('right bank'), ls =_('dotted') )
+        if zb != -99999.:
+            myax3.axhline(y=zb, color=_('blue'), alpha=1, lw=1, label =_(' bed '), ls =_('dotted'))
+
+        #Limits and labels
+        myax3.set_ylim(self.zmin,self.zmax+1)
+        myax3.set_xlim(0., max(max(self.wetarea), max(self.wetperimeter), max(self.localwidth)))
+        myax3.set_xlabel(_('S - P - W'), size=12)
+        myax3.set_ylabel(_('Altitude - Z ($m$)'), size=12,rotation=270, labelpad=50)
+
+        #Conversion methods for the second y axis
+        def alt_to_depth(y):
+            return y-self.zmin
+        def depth_to_alt(y):
+            return y+self.zmin
+        secax = myax3.secondary_yaxis('right', functions=(alt_to_depth,depth_to_alt))
+
+        myax3.yaxis.tick_left()
+        if force_label_to_right:
+            myax3.yaxis.set_label_position('right')
+        if labels:
+            secax.set_ylabel(_('Water depth - h ($m$)'), size=12, rotation=270, labelpad=20)
+        myax3.grid()
+
+        if show:
+            fig.show()
+
+    def plotcs_relations(self,
+                    fig:Figure = None, ax:Axes = None,
+                    fwl:float = None, fwd:float = None,
+                    fwq:float = None,
+                    show:bool = False, clear:bool = True,
+                    labels:bool = True, redraw:bool =True,
+                    force_label_to_right:bool = False
+                    ):
+        """
+        This method plots the cross section relations (geometry, hydraulic geometries)
+
+        It is the same than 'plotcs_hspw' but with (force_label_to_right = False) by default
+        """
+
+        self.plotcs_hspw(fig=fig, ax=ax,
+                         fwl=fwl, fwd=fwd,
+                         fwq=fwq,
+                         show=show, clear=clear,
+                         labels=labels, redraw=redraw,
+                         force_label_to_right=force_label_to_right)
+
+
+    def plot_linked(self, fig:Figure, ax:Axes, linked_arrays:dict, colors:list=['red','blue','green']):
+        """ Plot linked arrays on the section plot """
+
+        from .wolf_array import WolfArray
+
+        # colors=['red','blue','green']
+        nb_colors = len(colors)
+
+        k=0
+        for curlabel, curarray in linked_arrays.items():
+
+            curarray:WolfArray
+            if curarray.plotted:
+
+                length = self.linestring.length
+                ds = min(curarray.dx,curarray.dy)
+                nb = int(np.ceil(length/ds*2))
+
+                alls = np.linspace(0,int(length),nb)
+
+                pts = [self.linestring.interpolate(curs) for curs in alls]
+
+                allz = [curarray.get_value(curpt.x,curpt.y) for curpt in pts]
+
+                if np.max(allz)>-99999:
+                    ax.plot(alls,allz,
+                            color=colors[np.mod(k,nb_colors)],
+                            lw=2.0,
+                            label=curlabel)
+                k+=1
+
+    def _plot_only_cs(self,
+                      fig:Figure=None, ax:Axes=None,
+                      label='', alpha=0.8, lw=1., style: str ='dashed',
+                      centerx=0., centery=0., grid=True, col_ax: str = 'black'):
+        """ Plot only the cross section line on an existing axis """
+
+        x,y=self.get_sz()
+
+        sl,sb,sr,yl,yb,yr, sld, srd, yld, yrd = self.get_sz_banksbed()
+
+        if centerx >0. and sb!=-99999.:
+            decal = centerx-sb
+            x+=decal
+            sl+=decal
+            sb+=decal
+            sr+=decal
+
+        if centery >0. and yb!=-99999.:
+            decal = centery-yb
+            y+=decal
+            yl+=decal
+            yb+=decal
+            yr+=decal
+
+        ax.plot(x,y,color=col_ax,
+                lw=lw,
+                linestyle=style,
+                alpha=alpha,
+                label=label)
+
+        curtick=ax.get_xticks()
+        ax.set_xticks(np.arange(min(curtick[0],(x[0]//2)*2),max(curtick[-1],(x[-1]//2)*2),2))
 
-    def plotcs_hspw(self, fig: Figure = None, ax: Axes = None, fwl: float = None, fwd: float = None, fwq: float = None, show = False, clear = True, labels = True,redraw =True):
+        if sl != -99999.:
+            ax.plot(sl,yl,'or',alpha=alpha)
+        if sb != -99999.:
+            ax.plot(sb,yb,'ob',alpha=alpha)
+        if sr != -99999.:
+            ax.plot(sr,yr,'og',alpha=alpha)
+        if sld != -99999.:
+            ax.plot(sld,yld,'*r',alpha=alpha)
+        if srd != -99999.:
+            ax.plot(srd,yrd,'*g',alpha=alpha)
 
+    def plot_cs(self,
+                fwl:float = None, show:bool = False, forceaspect:bool = True,
+                fig:Figure = None, ax:Axes = None,
+                plotlaz:bool = True, clear:bool = True,
+                linked_arrays:dict = {}):
+        """ Plot the cross section with matplotlib - with options
+
+        :param fwl: fill water level - if None, no filling
+        :param show: if True, show the figure
+        :param forceaspect: if True, force aspect ratio
+        :param fig: figure Matplotlib
+        :param ax: axes Matplotlib
+        :param plotlaz: if True, plot LAZ points if available
+        :param clear: if True, clear the axis before plotting
+        :param linked_arrays: dictionary of linked arrays to plot on the section
         """
-        This method plots the hydraulic geometries computed by the relations method
-        (Hydraulic radius, wetted area, wetted perimeter, Top width).
 
-        - fwl: for water level,
-        - fwd: for water depth,
-        - fwq: for water discharge.
+        if linked_arrays is None:
+            linked_arrays = {}
 
-        """
-        sl,sb,sr,zl,zb,zr, sld, srd, zld, zrd = self.get_sz_banksbed()
-        x,y = self.get_sz()
+        x,y=self.get_sz()
 
-        if fwl is None:
-            if fwd is None or fwd <= 0:
-                fwd =0
-                fwl= self.zmin+ fwd
-            elif fwd > 0 :
-                fwl = self.zmin + fwd
+        sl,sb,sr,yl,yb,yr, sld, srd, yld, yrd = self.get_sz_banksbed()
 
-        elif fwl is not None:
-            fwl = fwl
-            fwd = fwl-self.zmin
+        xmin=x[0]
+        xmax=x[-1]
+        ymin=self.get_minz()
+        ymax=self.get_maxz()
 
-        # Creation of a new ax for cleaning purposes in the wolfhece.Graphprofile.
-        myax3 = ax
-        axt3 = ax
-        if redraw:
+        dy=ymax-ymin
+        ymin-=dy/4.
+        ymax+=dy/4.
+
+        if ax is None:
+            redraw=False
+            fig = plt.figure()
+            ax=fig.add_subplot(111)
+        else:
+            redraw=True
             if clear:
-                axt3.clear()
-                # myax3.clear()
+                ax.cla()
 
-        # Plots
-        # FIXME (Clearing issues) a second x axis for the Hydraulic radius to provide more clarity.
-        axt3.plot(self.hyrdaulicradius,self.waterdepth + self.zmin,color=_('green'),lw=2,label=_('H - Hydraulic radius($m$)'), ls= _('--')) #Plot the evaluation of the hydraulic radius as function of water depth
-        axt3.set_xlim(0, max(self.hyrdaulicradius))
+        if np.min(y) != -99999. and np.max(y) != -99999.:
+            ax.plot(x,y,color='black',
+                    lw=2.0,
+                    label='Profil')
 
-        myax3.plot(self.wetarea,self.waterdepth + self.zmin,color=_('black'),lw=2.0,label=_('S - Wet area ($m^2$)'))          #Plot the wetted area as function of water depth
-        myax3.plot(self.wetperimeter,self.waterdepth + self.zmin,color=_('magenta'),lw=1,label=_('P -  Wet perimeter($m$)'))  #Plot the wetted perimeter as function of water depth
-        myax3.plot(self.localwidth,self.waterdepth + self.zmin,color=_('red'),lw=1,label=_('W - Top Width ($m$)'))      #Plot the evalution of the water table as function of water depth
+        if self.parent is not None:
+            if plotlaz and self.parent.gridlaz is not None:
+                minlaz=ymin
+                maxlaz=ymax
+                minlaz,maxlaz=self.plot_laz(fig=fig,ax=ax)
+                if np.min(y) != -99999. and np.max(y) != -99999.:
+                    ymin = min(ymin,minlaz)
+                    ymax = max(ymax,maxlaz)
+                else:
+                    ymin = minlaz
+                    ymax = maxlaz
 
-        # Selection of hydraulic geometries based on their index
-        if fwq is not None and fwq > 0.:
-            # First, We select the closest critical discharge to the user's input.
-            mask = np.absolute(self.criticaldischarge - fwq)
-            index  = np.argmin(mask)
-            # Second, since the matrices have the same shapes and their elements are sorted likewise,
-            # we use the index of the selected critical discharge to find the corresponding hydraulic geometries.
-            cr_wetarea = self.wetarea[index]
-            cr_wetperimeter = self.wetperimeter[index]
-            cr_width = self.localwidth[index]
-            cr_radius = self.hyrdaulicradius[index]
-            cr_h = self.waterdepth[index]
-            myax3.plot(cr_wetarea,cr_h + self.zmin,'ok' )
-            myax3.annotate(_('$Critical$ $characteristics$ \nH: %s $m$ \nS: %s $m^2$ \nP: %s $m$ \nW: %s $m$  \n \n')% (round(cr_radius,2),round(cr_wetarea,2),round(cr_wetperimeter,2),round(cr_width,2)),\
-                 (cr_wetarea, cr_h + self.zmin),  alpha= 1, fontsize = _('x-small'),color =_('black'))
+        self.plot_linked(fig,ax,linked_arrays)
 
-            #Finally, we plot the critical hydraulic geometries as dots.
-            myax3.plot(cr_wetperimeter,cr_h + self.zmin,_('om') )
-            myax3.plot(cr_width,cr_h + self.zmin,_('or') )
-            myax3.plot(cr_radius,cr_h + self.zmin,_('og') )
+        if fwl is not None:
+            ax.fill_between(x,y,fwl,where=y<=fwl,facecolor='cyan',alpha=0.3,interpolate=True)
 
-        #Displayed water depths and banks
-        myax3.axhspan(ymin= self.zmin, ymax =fwd + self.zmin,color=_('cyan'), alpha=0.2, lw=2, label =_('Desired water depth'))
-        myax3.axhline(y=zl, color=_('magenta'), alpha=1, lw=1, label =_('Left bank'), ls =_('dotted') )
-        myax3.axhline(y=zr, color=_('green'), alpha=1, lw=1, label =_('right bank'), ls =_('dotted') )
-        myax3.axhline(y=zb, color=_('blue'), alpha=1, lw=1, label =_(' bed '), ls =_('dotted'))
+        if sl != -99999.:
+            ax.plot(sl,yl,'or')
+        if sb != -99999.:
+            ax.plot(sb,yb,'ob')
+        if sr != -99999.:
+            ax.plot(sr,yr,'og')
+        if sld != -99999.:
+            ax.plot(sld,yld,'*r')
+        if srd != -99999.:
+            ax.plot(srd,yrd,'*g')
 
-        #Limits and labels
-        myax3.set_ylim(self.zmin,self.zmax+1)
-        myax3.set_xlim(0., max(max(self.wetarea), max(self.wetperimeter), max(self.localwidth)))
-        myax3.set_xlabel(_('S - P - W'), size=12)
-        myax3.set_ylabel(_('Water depth - h\n($m$)'), size=12,rotation=270, labelpad=50)
+        ax.set_title(self.myname)
+        ax.set_xlabel(_('Distance [m]'))
+        ax.set_ylabel('Elevation [EL.m]')
+        ax.legend()
 
-        #Conversion methods for the second y axis
-        def alt_to_depth(y):
-            return y-self.zmin
-        def depth_to_alt(y):
-            return y+self.zmin
-        secax = myax3.secondary_yaxis(_('right'), functions=(alt_to_depth,depth_to_alt))
+        tol=(xmax-xmin)/10.
+        ax.set_xlim(xmin-tol,xmax+tol)
+        ax.set_ylim(ymin,ymax)
 
-        myax3.yaxis.tick_left()
-        myax3.yaxis.set_label_position(_('right'))
-        if labels:
-            secax.set_ylabel(_('Altitude - Z ($m$)'), size=12, rotation=270, labelpad=20)
-        myax3.grid()
+        nbticks = 20
+        dzticks = max((((ymax-ymin)/nbticks) // .25) *.25,.25)
+
+        ax.set_yticks(np.arange((ymin//.25)*.25,(ymax//.25)*.25,dzticks))
+        ax.grid()
+
+        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 sl,sb,sr,yl,yb,yr
 
 
 class crosssections(Element_To_Draw):
@@ -1860,6 +2338,7 @@ class crosssections(Element_To_Draw):
         - SPW_2025 --> format ='2025_xlsx'
         - WOLF vecz --> format ='vecz'
         - WOLF sxy --> format ='sxy'
+        - WOLF zones --> format ='zones'
 
     L'objet stocke ses informations dans un dictionnaire : self.myprofiles
     Les clés de chaque entrée sont:
@@ -1884,22 +2363,54 @@ class crosssections(Element_To_Draw):
 
     """
 
-    myprofiles:dict
+    myprofiles:dict['cs':profile, 'index':int, 'left':wolfvertex, 'bed':wolfvertex, 'right':wolfvertex, 'left_down':wolfvertex, 'right_down':wolfvertex]
     mygenprofiles:dict
 
     def __init__(self,
-                 myfile:str = '',
-                 format:typing.Literal['2000','2022', '2025_xlsx','vecz','sxy']='2022',
+                 fn_or_Zones:str | Path | Zones = '',
+                 format:typing.Literal['2000','2022', '2025_xlsx','vecz','sxy', 'zones']='2022',
                  dirlaz:typing.Union[str, xyz_laz_grids] =r'D:\OneDrive\OneDrive - Universite de Liege\Crues\2021-07 Vesdre\CSC - Convention - ARNE\Data\LAZ_Vesdre\2023',
                  mapviewer = None,
                  idx='',
-                 plotted=True) -> None:
+                 plotted=True,
+                 from_zones:Zones = None,
+                 force_unique_name:bool = False) -> None:
+        """
+        Constructor of the crosssections class
+
+        ATTENTION:
+        - If you use "from_zones", the cross-sections will be read from the provided Zones instance, overriding fn_or_Zones and format.
+        - If you use "from_zones", the cross-sections will be added only if "used" in the Zones instance.
+        - If you use "fn_or_Zones" as an instance of Zones, the format must be "zones". In this case, only the first zone will be used and cross-sections will be added even if not "used".
+
+        :param fn_or_Zones: filename (str or Path) or instance of Zones containing the sections
+        :param format: format of the sections file - '2000','2022','2025_xlsx','vecz','sxy', 'zones'
+        :param dirlaz: directory containing LAZ files or instance of xyz_laz_grids
+        :param mapviewer: instance of MapViewer (if None, no mapviewer is used)
+        :param idx: index of the crosssections instance
+        :param plotted: if True, the crosssections will be plotted in the mapviewer (if provided)
+        :param from_zones: if not None, the sections will be read from the provided Zones instance (overrides fn_or_Zones and format)
+        :param force_unique_name: if True, force unique names for each section (useful when reading from Zones)
+        :return: None
 
-        assert format in ['2000','2022','2025_xlsx','vecz','sxy'], _('Format %s not supported!')%format
+        """
+
+        assert format in ['2000','2022','2025_xlsx','vecz','sxy', 'zones'], _('Format %s not supported!')%format
 
         super().__init__(idx=idx, plotted= plotted, mapviewer=mapviewer, need_for_wx=False)
 
-        self.filename=myfile
+        if from_zones is not None:
+            assert isinstance(from_zones, Zones), _('from_zones must be an instance of Zones!')
+            self.filename = ''
+            format=''
+        elif isinstance(fn_or_Zones, Zones):
+            assert format=='zones', _('If fn_or_Zones is an instance of Zones, format must be "zones"!')
+            self.filename = fn_or_Zones.filename
+        elif isinstance(fn_or_Zones, (str, Path)):
+            self.filename = fn_or_Zones
+        else:
+            raise Exception(_('fn_or_Zones must be a string, Path or an instance of Zones!'))
+
         self.myzones=None
         self.myzone=None
 
@@ -1920,25 +2431,25 @@ class crosssections(Element_To_Draw):
         self.linked_zones=None
 
         if format in ['2000','2022','sxy']:
-            self.filename=myfile
-            if Path(myfile).exists() and myfile!='':
-                f=open(myfile,'r')
+            self.filename=fn_or_Zones
+            if Path(fn_or_Zones).exists() and fn_or_Zones!='':
+                f=open(fn_or_Zones,'r')
                 lines=f.read().splitlines()
                 f.close()
         elif format=='2025_xlsx':
             # For the 2025_xlsx format, we need to read the file using pandas
-            if Path(myfile).exists() and myfile!='':
+            if Path(fn_or_Zones).exists() and fn_or_Zones!='':
                 # read the first sheet of the excel file
                 # Note: header=1 means that the first row is not the header, but the second row is.
-                logging.info(_('Reading cross section data from %s')%myfile)
+                logging.info(_('Reading cross section data from %s')%fn_or_Zones)
                 try:
-                    lines = pd.read_excel(myfile, sheet_name=0, header=1)
-                    logging.info(_('Cross section data read successfully from %s')%myfile)
+                    lines = pd.read_excel(fn_or_Zones, sheet_name=0, header=1)
+                    logging.info(_('Cross section data read successfully from %s')%fn_or_Zones)
                 except Exception as e:
-                    logging.error(_('Error reading the file %s: %s')%(myfile, str(e)))
+                    logging.error(_('Error reading the file %s: %s')%(fn_or_Zones, str(e)))
                     lines = pd.DataFrame()
             else:
-                logging.error(_('File %s does not exist!')%myfile)
+                logging.error(_('File %s does not exist!')%fn_or_Zones)
                 lines = []
         # For other formats (e.g.  vecz)
         else:
@@ -2232,23 +2743,60 @@ class crosssections(Element_To_Draw):
                         curdict['right']=cursect.bankright
 
 
-        # To make a distinction between cases for vecz
+        elif from_zones is not None:
+
+            for curzone in from_zones.myzones:
+                for curvec in curzone.myvectors:
+                    if curvec.used:
+
+                        if curvec.myname in self.myprofiles.keys():
+                            if force_unique_name:
+                                logging.info(_('Profile %s already exists in cross-sections. We change its name to %s.')%(curvec.myname, f"{curvec.myname}_{len(self.myprofiles)}"))
+                                curvec.myname = f"{curvec.myname}_{len(self.myprofiles)}"
+                            else:
+                                logging.warning(_('Profile %s already exists in cross-sections. Previous will be overwritten.')%curvec.myname)
+
+                        self.myprofiles[curvec.myname]={}
+                        curdict=self.myprofiles[curvec.myname]
+
+                        curdict['index']=len(self.myprofiles)
+                        curdict['left']=None
+                        curdict['bed']=None
+                        curdict['right']=None
+                        curdict['left_down'] = None
+                        curdict['right_down'] = None
+
+                        curdict['cs'] = profile(name=curvec.myname, parent=self)
+                        cursect:profile
+                        cursect=curdict['cs']
+
+                        cursect.myvertices = curvec.myvertices.copy()
+
         elif len(lines)==0:
+
             if format=='vecz' or format=='zones':
 
-                if isinstance(myfile, Zones):
-                    self.filename=myfile.filename
-                    tmpzones=myfile
-                elif isinstance(myfile, str):
-                    self.filename=myfile
-                    tmpzones=Zones(myfile, find_minmax=False)
+                if isinstance(fn_or_Zones, Zones):
+                    self.filename=fn_or_Zones.filename
+                    tmpzones = fn_or_Zones
+
+                elif isinstance(fn_or_Zones, (str, Path)):
+                    self.filename=fn_or_Zones
+                    tmpzones = Zones(fn_or_Zones, find_minmax=False)
 
                 curzone:zone
                 curvec:vector
-                curzone=tmpzones.myzones[0]
+                curzone = tmpzones.myzones[0]
                 index=0
                 for curvec in curzone.myvectors:
 
+                    if curvec.myname in self.myprofiles.keys():
+                        if force_unique_name:
+                            logging.info(_('Profile %s already exists in cross-sections. We change its name to %s.')%(curvec.myname, f"{curvec.myname}_{index}"))
+                            curvec.myname = f"{curvec.myname}_{index}"
+                        else:
+                            logging.warning(_('Profile %s already exists in cross-sections. Previous will be overwritten.')%curvec.myname)
+
                     self.myprofiles[curvec.myname]={}
                     curdict=self.myprofiles[curvec.myname]
 
@@ -2256,18 +2804,47 @@ class crosssections(Element_To_Draw):
                     curdict['left']=None
                     curdict['bed']=None
                     curdict['right']=None
+                    curdict['left_down'] = None
+                    curdict['right_down'] = None
 
                     index+=1
-                    curdict['cs']=profile(name=curvec.myname,parent=self)
+                    curdict['cs']=profile(name=curvec.myname, parent=self)
                     cursect:profile
                     cursect=curdict['cs']
 
-                    cursect.myvertices = curvec.myvertices
+                    cursect.myvertices = curvec.myvertices.copy()
 
         self.verif_bed()
         self.find_minmax(True)
         self.init_cloud()
 
+
+    @property
+    def nb_profiles(self):
+        """ Return the number of profiles in the cross-sections. """
+        return len(self.myprofiles)
+
+    def __getitem__(self, key):
+        """ Get a profile by its name, index or (x, y) coordinates.
+
+        :param key: The name or index  of the profile or coordinates where the search is performed.
+        :type key: str | int | tuple | list
+        :return: The profile corresponding to the key.
+        :rtype: profile
+        """
+
+        if isinstance(key, str):
+            return self.myprofiles[key]['cs']
+        elif isinstance(key, int):
+            return self.myprofiles[list(self.myprofiles.keys())[key]]['cs']
+        elif isinstance(key, tuple | list):
+            if len(key) == 2:
+                x, y = key
+                assert isinstance(x, float) and isinstance(y, float), _('Coordinates must be floats.')
+                return self.select_profile(x, y)
+        else:
+            raise KeyError(_('Key must be a string or an integer or a tuple/list of (float, float).'))
+
     def init_cloud(self):
         """ Initialiaze cloud points for cross-sections. """
 
@@ -2435,7 +3012,7 @@ class crosssections(Element_To_Draw):
                     curlinkprop = myvec.myname
 
                 myvecls = myvec.asshapely_ls()
-                prepls=prep(myvecls)
+                prepls=prepare(myvecls)
 
                 for cursname in self.myprofiles.values():
                     curs:profile
@@ -2464,6 +3041,7 @@ class crosssections(Element_To_Draw):
                             curs.refpoints[curlinkprop]=myvert
 
                         cursname[curlinkprop]=myvert
+                destroy_prepared(prepls)
 
         self.update_cloud()
 
@@ -2628,12 +3206,12 @@ class crosssections(Element_To_Draw):
             for curprof in self.myprofiles.keys():
                 curdict=self.myprofiles[curprof]
                 curvec=curdict['cs']
-                curvec:vector
+                curvec:profile
                 if curvec.used:
                     self.myzone.add_vector(curvec, forceparent=True)
 
             if self.plotted:
-                self._prep_listogl()  #FIXME : Does not work in the context of a 1D model
+                self._prep_listogl()
 
     def showstructure(self, parent=None, forceupdate=False):
         """ Show the structure of the cross-sections in the zones. """
@@ -2641,7 +3219,7 @@ class crosssections(Element_To_Draw):
         self.set_zones()
         self.myzones.showstructure(parent, forceupdate)
 
-    def get_upstream(self) -> dict:
+    def get_upstream(self) -> dict['cs':profile, 'index':int, 'left':wolfvertex | None, 'bed':wolfvertex | None, 'right':wolfvertex | None, 'left_down':wolfvertex | None, 'right_down':wolfvertex | None]:
         """ Get the upstream profile of the cross-sections."""
         curprof:profile
         curprof=self.myprofiles[list(self.myprofiles.keys())[0]]['cs']
@@ -2651,7 +3229,7 @@ class crosssections(Element_To_Draw):
 
         return self.myprofiles[curprof.myname]
 
-    def get_downstream(self) -> dict:
+    def get_downstream(self) -> dict['cs':profile, 'index':int, 'left':wolfvertex | None, 'bed':wolfvertex | None, 'right':wolfvertex | None, 'left_down':wolfvertex | None, 'right_down':wolfvertex | None]:
         """ Get the downstream profile of the cross-sections. """
         curprof:profile
         curprof=self.myprofiles[list(self.myprofiles.keys())[0]]['cs']
@@ -2860,7 +3438,7 @@ class crosssections(Element_To_Draw):
         mysorted = curdict['sorted']  = []
         length = vecsupport.length
 
-        prepsup=prep(vecsupport) #Prepare le vecteur support aux opérations récurrentes
+        prepsup=prepare(vecsupport) #Prepare le vecteur support aux opérations récurrentes
         curvect:profile
         for idx,curv in self.myprofiles.items():
             #bouclage sur les sections
@@ -2878,6 +3456,7 @@ class crosssections(Element_To_Draw):
                     curvect.s = length - mydist
                 else:
                     curvect.s = mydist
+        destroy_prepared(prepsup)
 
         #on trie le résultat en place
         mysorted.sort(key=lambda x:x.s)
@@ -2929,7 +3508,7 @@ class crosssections(Element_To_Draw):
         self.set_zones()
         self.myzones.saveas(filename=filename)
 
-    def select_profile(self, x:float, y:float):
+    def select_profile(self, x:float, y:float) -> profile:
         """ Select the profile closest to the given coordinates (x, y).
 
         :param x: X coordinate of the point.
@@ -2965,271 +3544,426 @@ class Interpolator():
 
     """
 
-    def __init__(self, vec1:vector, vec2:vector,
-                 supports:list[vector], ds=1.) -> None:
+    def __init__(self, vec1:vector,
+                 vec2:vector,
+                 supports:list[vector],
+                 ds:float = 1.,
+                 epsilon:float = 5e-2) -> None:
+        """
+        Initialize the Interpolator with two vectors and a list of support vectors.
+
+        Not all supports need to intersect both sections.
+        First, we check if each support intersects the sections.
+        If a support does not intersect both sections, it will be ignored.
+
+        Support vectors must have Z coordinates.
+
+        If the Z-coordinates at the intersection points between the supports and the sections are not identical,
+        "alpha" values are computed for interpolation:
+
+            alpha = Z_support / Z_section
+
+        The Z-coordinate of each interpolated point is then:
+
+            Z_interp = Z_section * alpha
+
+        Alpha is linearly interpolated between the two sections according to
+        the curvilinear abscissa. The same applies to the Z-coordinates of the supports and the sections.
+
+        If the sections are not straight lines, a "trace" is defined by the intersection points
+        between the supports and the sections. This trace is used to pre-compute the interpolation points.
+        Then, deltas (in X and Y) are added to "deform" the local sections.
+        These deltas are linearly interpolated between the two sections.
+
+        :param vec1: The first vector representing the first section.
+        :type vec1: vector | profile
+        :param vec2: The second vector representing the second section.
+        :type vec2: vector | profile
+        :param supports: A list of support vectors used for interpolation. This should be a list of vectors, not a zone.
+        :type supports: list[vector]
+        :param ds: The step size for interpolation, default is 1.0 [m].
+        :type ds: float
+        :param epsilon: The tolerance for intersection checks, default is 5e-2 [m] (5 cm).
+        :type epsilon: float
+        """
 
         self.interpolants=[]
 
-        sect1={}
-        sect2={}
+        sect1 = {} # local dict to store section 1 data
+        sect2 = {} # local dict to store section 2 data
+
+        used_supports:dict[int: dict['vec':vector, int:float]] = {}
 
         #Linestrings shapely des sections 1 et 2
         #ATTENTION, SHAPELY est une librairie géométrique 2D --> des outils spécifiques ont été programmés pour faire l'interpolation 3D
-        s1=sect1['ls']=vec1.asshapely_ls()
-        s2=sect2['ls']=vec2.asshapely_ls()
+        s1 = sect1['ls'] = vec1.linestring
+        s2 = sect2['ls'] = vec2.linestring
+
+        eps = epsilon  # Tolérance pour vérifier l'intersection
+
+        # Check if sections intersect the supports at their endpoints, considering a small epsilon (eps) for precision issues
+        def check_intersection(section_ls:LineString, vec:profile, myls:LineString, eps:float):
+            loc = None
+            # Try intersection at start
+            pt = Point(section_ls.xy[0][0], section_ls.xy[1][0])
+            pt_proj = myls.interpolate(myls.project(pt))
+            length = pt_proj.distance(pt)
+            intersected = length < eps
+            if intersected:
+                vec.myvertices[0].x = pt_proj.xy[0][0]
+                vec.myvertices[0].y = pt_proj.xy[1][0]
+                section_ls = vec.linestring
+                loc = 'first'
+
+            # Try intersection at end if not found at start
+            if not intersected:
+                pt = Point(section_ls.xy[0][-1], section_ls.xy[1][-1])
+                pt_proj = myls.interpolate(myls.project(pt))
+                length = pt_proj.distance(pt)
+                intersected = length < eps
+                if intersected:
+                    vec.myvertices[-1].x = pt_proj.xy[0][-1]
+                    vec.myvertices[-1].y = pt_proj.xy[1][-1]
+                    section_ls = vec.linestring
+                    loc = 'last'
+            return intersected, section_ls, loc
+
+        for cur_trace  in supports:
+            # RRecherche des distances des intersections des sections sur le support
+
+            # linestring du support courant
+            cur_support_ls = cur_trace.linestring
 
-        nb = 0
-        supls={}
-
-        eps=5.e-2
+            #intersections du vecteur support avec les sections
+            i1 = cur_support_ls.intersects(s1) # check is intersects section 1 --> return True or False -- see https://shapely.readthedocs.io/en/2.1.1/reference/shapely.intersects.html
 
-        for curvec in supports:
-            #linestring du support courant
-            #distances des intersections des sections sur le support
-            myls:LineString
-            myls=curvec.asshapely_ls()
+            # If the section does not intersect the support, two possibilities:
+            # 1. The first vertex of the section is on/near the support line
+            # 2. The last vertex of the section is on/near the support line
+            # If neither is the case, we ignore this support.
 
-            #intersections du vecteur support avec les sections
-            i1=myls.intersects(s1)
             if not i1:
-                pt=Point(s1.xy[0][0],s1.xy[1][0])
-                pt1=myls.interpolate(myls.project(pt))
-                length = pt1.distance(pt)
-                i1 = length<eps
-
-                if i1:
-                    vec1.myvertices[0].x=pt1.xy[0][0]
-                    vec1.myvertices[0].y=pt1.xy[1][0]
-                    s1=vec1.asshapely_ls()
-
-                if not i1:
-                    pt=Point(s1.xy[0][-1],s1.xy[1][-1])
-                    pt1=myls.interpolate(myls.project(pt))
-                    length = pt1.distance(pt)
-                    i1 = length<eps
-                    if i1:
-                        vec1.myvertices[-1].x=pt1.xy[0][-1]
-                        vec1.myvertices[-1].y=pt1.xy[1][-1]
-                        s1=vec1.asshapely_ls()
-
-            i2=myls.intersects(s2)
+                i1, s1, _loc = check_intersection(s1, vec1, cur_support_ls, eps)
+
+            i2 = cur_support_ls.intersects(s2)
             if not i2:
-                pt=Point(s2.xy[0][0],s2.xy[1][0])
-                pt2=myls.interpolate(myls.project(pt))
-                length = pt2.distance(Point(s2.xy[0][0],s2.xy[1][0]))
-                i2 = length<eps
-
-                if i2:
-                    vec2.myvertices[0].x=pt2.xy[0][0]
-                    vec2.myvertices[0].y=pt2.xy[1][0]
-                    s2=vec2.asshapely_ls()
-
-                if not i2:
-                    pt=Point(s2.xy[0][-1],s2.xy[1][-1])
-                    pt2=myls.interpolate(myls.project(pt))
-                    length = pt2.distance(pt)
-                    i2 = length<eps
-                    if i2:
-                        vec2.myvertices[-1].x=pt2.xy[0][-1]
-                        vec2.myvertices[-1].y=pt2.xy[1][-1]
-                        s2=vec2.asshapely_ls()
+                i2, s2, _loc = check_intersection(s2, vec2, cur_support_ls, eps)
 
+            # Si le support intersecte les sections, on le conserve
+            # et on le stocke dans le dictionnaire used_supports
             if i1 and i2:
-                supls[nb]={}
-                supls[nb]['ls']=myls
-                supls[nb]['vec']=curvec
-                nb+=1
+                loc_sup = used_supports[len(used_supports)] = {}
+                loc_sup['vec'] = cur_trace
+
+
+        # Need to reset the PREPARED linestrings
+        # to ensure they are recalculated with the new coordinates
+        # of the sections after the intersection checks.
+        # This is necessary because the coordinates may have been adjusted
+        # to ensure they are close to the support lines.
+        # Otherwise, the linestrings may not reflect the actual geometry.
+        vec1.reset_linestring()
+        vec2.reset_linestring()
+
+        s1 = vec1.linestring
+        s2 = vec2.linestring
 
         #bouclage sur les vecteurs supports pour trouver les intersections avec les sections
         #  - trouver la portion utile entre intersections des supports
         #  - trouver les distances sur les sections de ces intersections
-        for k in range(nb):
-            #linestring du support courant
-            #distances des intersections des sections sur le support
-            myls:LineString
-            myls=supls[k]['ls']
+        for k in range(len(used_supports)):
 
-            #intersections du vecteur support avec les sections
+            # distances des intersections des sections sur le support
+            cur_trace:vector
+            cur_trace = used_supports[k]['vec']
+
+            cur_support_ls:LineString
+            cur_support_ls = cur_trace.linestring
+
+            # Coordonnées d'intersection du vecteur support avec les sections
+            # On est certain que cela s'intersecte puisque l'on a vérifié juste avant
+
+            # Section "amont"
+            i1 = cur_support_ls.intersection(s1) # --> return a Point or MultiPoint -- see https://shapely.readthedocs.io/en/stable/reference/shapely.intersection.html
+            if not i1:
+                i1, s1, loc1 = check_intersection(s1, vec1, cur_support_ls, eps)
+                if loc1=='first':
+                    i1 = Point(s1.xy[0][0], s1.xy[1][0])
+                elif loc1=='last':
+                    i1 = Point(s1.xy[0][-1], s1.xy[1][-1])
 
-            #section amont
-            i1=myls.intersection(s1)
-            if i1.geom_type=='MultiPoint':
+            elif i1.geom_type=='MultiPoint':
                 i1=i1.geoms[0]
                 logging.debug('MultiPoint -- use first point or debug')
 
-            #section aval
-            i2=myls.intersection(s2)
-            if i2.geom_type=='MultiPoint':
+
+            # Section "aval"
+            i2 = cur_support_ls.intersection(s2)
+            if not i2:
+                i2, s2, loc2 = check_intersection(s2, vec2, cur_support_ls, eps)
+                if loc2=='first':
+                    i2 = Point(s2.xy[0][0], s2.xy[1][0])
+                elif loc2=='last':
+                    i2 = Point(s2.xy[0][-1], s2.xy[1][-1])
+
+            elif i2.geom_type=='MultiPoint':
                 i2=i2.geoms[0]
                 logging.debug('MultiPoint -- use first point or debug')
 
-            #Les distances, sur les sections, sont calculées en projetant l'intersection du vecteur support et des sections
-            sect1[k]=s1.project(i1)
-            sect2[k]=s2.project(i2)
-
-            #Les distances, sur le support, sont calculées en projetant l'intersection du vecteur support et des sections
-            supls[k][1]=myls.project(i1)
-            if supls[k][1]==-1.:
-                #problème de précision de calcul
-                if myls.distance(Point(s1.xy[0][0],s1.xy[1][0]))<eps:
-                    supls[k][1]=myls.project(Point(s1.xy[0][0],s1.xy[1][0]))
-                    sect1[k]=s1.project(Point(s1.xy[0][0],s1.xy[1][0]))
-                elif myls.distance(Point(s1.xy[0][-1],s1.xy[1][-1]))<eps:
-                    supls[k][1]=myls.project(Point(s1.xy[0][-1],s1.xy[1][-1]))
-                    sect1[k]=s1.project(Point(s1.xy[0][-1],s1.xy[1][-1]))
-
-            supls[k][2]=myls.project(i2)
-            if supls[k][2]==-1.:
-                #problème de précision de calcul
-                if myls.distance(Point(s2.xy[0][0],s2.xy[1][0]))<eps:
-                    supls[k][2]=myls.project(Point(s2.xy[0][0],s2.xy[1][0]))
-                    sect2[k]=s2.project(Point(s2.xy[0][0],s2.xy[1][0]))
-                elif myls.distance(Point(s2.xy[0][-1],s2.xy[1][-1]))<eps:
-                    supls[k][2]=myls.project(Point(s2.xy[0][-1],s2.xy[1][-1]))
-                    sect2[k]=s2.project(Point(s2.xy[0][-1],s2.xy[1][-1]))
-
-            #on ne conserve que la fraction utile entre intersections
-            supls[k]['vec']=supls[k]['vec'].substring(supls[k][1],supls[k][2],False,False)
-
-        #bouclage sur les intervalles --> nb_supports-1
-        for k in range(nb-1):
+            # Les distances curvilignes, sur les sections, sont calculées
+            # en projetant l'intersection du vecteur support et des sections
+            sect1[k] = s1.project(i1)
+            sect2[k] = s2.project(i2)
+
+            # Les distances, sur le support, sont calculées en projetant
+            # l'intersection du vecteur support et des sections
+            used_supports[k][1] = cur_support_ls.project(i1)
+            if used_supports[k][1] == -1.:
+                # Problème de précision de calcul à gérer
+                # Même type de problème que lors de la vérification de l'intersection
+
+                # We test the distance to the first and last points of the section
+                # to ensure we have a valid projection.
+                # We project on the support AND the section and store the result
+                # in the used_supports and sect1/sect2 dictionaries.
+
+                pt_first = Point(vec1[0].x, vec1[0].y)
+                pt_last  = Point(vec1[-1].x, vec1[-1].y)
+
+                if cur_support_ls.distance(pt_first) < eps:
+                    used_supports[k][1] = cur_support_ls.project(pt_first)
+                    sect1[k] = s1.project(pt_first)
+
+                elif cur_support_ls.distance(pt_last) < eps:
+                    used_supports[k][1] = cur_support_ls.project(pt_last)
+                    sect1[k] = s1.project(pt_last)
+
+            used_supports[k][2] = cur_support_ls.project(i2)
+            if used_supports[k][2] == -1.:
+                # Problème de précision de calcul -- see previous comment
+                pt_first = Point(vec2[0].x, vec2[0].y)
+                pt_last  = Point(vec2[-1].x, vec2[-1].y)
+
+                if cur_support_ls.distance(pt_first) < eps:
+                    used_supports[k][2] = cur_support_ls.project(pt_first)
+                    sect2[k] = s2.project(pt_first)
+
+                elif cur_support_ls.distance(pt_last) < eps:
+                    used_supports[k][2] = cur_support_ls.project(pt_last)
+                    sect2[k] = s2.project(pt_last)
+
+            # Replace the vector by the portion of the support vector between the two intersections
+            used_supports[k]['vec'] = cur_trace.substring(used_supports[k][1], # curvilinear position of the intersection with section 1
+                                                          used_supports[k][2], # curvilinear position of the intersection with section 2
+                                                          is3D = False, # Compute in 2D, not 3D
+                                                          adim = False  # In real coordinates, not adimensional
+                                                          )
+
+
+        # Bouclage sur les intervalles --> nb_supports-1
+        for k in range(len(used_supports)-1):
+
             interpolant=[]
             self.interpolants.append(interpolant)
 
-            cursupl:vector
-            cursupr:vector
+            cur_support_left:vector
+            cur_support_right:vector
             curvec1:vector
             curvec2:vector
 
-            #morceaux de sections entre intersections avec le support
+            # Morceaux de sections entre intersections avec le support.
+            # Comme les distances ont été calculées avec Shapely,
+            # on doit trouver les morceaux en 2D et non 3D.
             curvec1=sect1['sub'+str(k)]=vec1.substring(sect1[k],sect1[k+1],is3D=False,adim=False)
             curvec2=sect2['sub'+str(k)]=vec2.substring(sect2[k],sect2[k+1],is3D=False,adim=False)
 
-            #pointeurrs vers les morceaux des supports
-            cursupl = supls[k]['vec']
-            cursupr = supls[k+1]['vec']
+            # Pointeurs vers les morceaux des supports
+            cur_support_left = used_supports[k]['vec']
+            cur_support_right = used_supports[k+1]['vec']
 
-            #MAJ des longueurs 2D et 3D
-            cursupl.update_lengths()
-            cursupr.update_lengths()
+            # MAJ des longueurs 2D ET 3D
+            cur_support_left.update_lengths()
+            cur_support_right.update_lengths()
             curvec1.update_lengths()
             curvec2.update_lengths()
 
-            #Trouve la liste des distances à traiter pour le maillage
-            nbi = np.ceil(max(curvec1.length3D,curvec2.length3D)/ds)
-            locds = 1./float(nbi)
-            dist3d = np.concatenate([np.arange(0.,1.,locds),np.cumsum(curvec1._lengthparts3D)/curvec1.length3D,np.cumsum(curvec2._lengthparts3D)/curvec2.length3D])
-            dist3d = np.unique(dist3d)
-
-            #nombre de points à traiter sur les supports
-            # on divise la longueur 3D des supports par la taille souhaitée et on arrondi à l'entier supérieur
-            nbi = int(np.ceil(max(cursupl.length3D,cursupr.length3D)/ds))
-            # nouvelle distance de calcul
-            locds = 1./float(nbi)
-
-            sloc=0.
-            pt1l = curvec1.interpolate(0.,True,True)
-            pt2l = curvec2.interpolate(0.,True,True)
-            pt1r = curvec1.interpolate(1.,True,True)
-            pt2r = curvec2.interpolate(1.,True,True)
-
-            s1dr = vector(name='sectiondroite1')
-            s2dr = vector(name='sectiondroite2')
-            s1dr.add_vertex([pt1l,pt1r])
-            s2dr.add_vertex([pt2l,pt2r])
-
-            s1dr = s1dr.asshapely_ls()
-            s2dr = s2dr.asshapely_ls()
-
-            # if np.isnan(pt1l.x):
-            #     a=1
-            # if np.isnan(pt2l.x):
-            #     a=1
-            # if np.isnan(pt1r.x):
-            #     a=1
-            # if np.isnan(pt2r.x):
-            #     a=1
-
-            for curalong in range(nbi+1):
-                logging.debug(str(curalong))
-
-                #interpolation 3D sur les 2 supports
-                l1 = cursupl.interpolate(sloc,True,True)
-                l2 = cursupr.interpolate(sloc,True,True)
-
-                curvec=vector(name='loc')
-                curvec.add_vertex([l1,l2])
-                val = []
-
-                if l1.z!=0.:
-                    if pt1l.z==0.:
-                        alpha1l=0.
-                    else:
-                        alpha1l = l1.z/pt1l.z
-                    if pt2l.z==0.:
-                        alpha2l=0.
-                    else:
-                        alpha2l = l1.z/pt2l.z
+            # Trouve la liste des distances à traiter pour le maillage
+
+            # Nombre de points (entier) à évaluer pour s'approcher de la distance ds souhaitée
+            # On divise la longueur 3D maximales des sections par la taille souhaitée
+            # et on arrondit à l'entier supérieur
+            nbi_sect = np.ceil(max(curvec1.length3D, curvec2.length3D) / ds)
+            if nbi_sect == 0:
+                logging.warning(_('No points to interpolate between sections {s1} and {s2} with distance {d} m.').format(s1=curvec1.myname, s2=curvec2.myname, d=ds))
+            else:
+                locds  = 1./float(nbi_sect) # nouvelle distance de calcul
+
+                # Create a list of adimensional distances where to interpolate
+                # We use :
+                # - the cumulative length of the sections to create a list of distances
+                # - a range from 0 to 1 with the step size locds
+                dist3d = np.concatenate([np.arange(0.,1.,locds),
+                                         np.cumsum(curvec1._lengthparts3D) / curvec1.length3D,
+                                         np.cumsum(curvec2._lengthparts3D) / curvec2.length3D])
+
+                # Remove duplicates AND sort the distances
+                dist3d = np.unique(dist3d)
+
+            # Nombre de points à traiter sur les supports.
+            # On divise la longueur 3D maximale des supports par la taille souhaitée
+            # et on arrondi à l'entier supérieur
+            nbi_support = int(np.ceil(max(cur_support_left.length3D, cur_support_right.length3D) / ds))
+
+            # Nouvelle distance de calcul
+            locds = 1./float(nbi_support)
+
+            # Wolfvertex des points d'intersection des sections avec les supports
+
+            # section amont/support gauche
+            pt1_left  = curvec1.interpolate(s= 0., is3D = True, adim = True)
+            # section amont/support droit
+            pt1_right = curvec1.interpolate(s= 1., is3D = True, adim = True)
+
+            # section aval/support gauche
+            pt2_left  = curvec2.interpolate(s= 0., is3D = True, adim = True)
+            # section aval/support droit
+            pt2_right = curvec2.interpolate(s= 1., is3D = True, adim = True)
+
+            # Vecteurs temporaires pour les sections.
+            # Ces nouveaux vecteurs sont des segments de droite entre les intersections
+            # des sections avec les supports.
+            # Cela définit ainsi la trace des sections, même si en réalité tous leurs
+            # points ne sont pas alignés.
+
+            # Rappel : Cette procédure a au départ été écrite pour de vraies sections en travers.
+            #          Elle a été adaptée pour fonctionner avec des sections 3D de forme quelconque.
+
+            # Passage via vector pour conversion vers LineString
+            # NDLR : on aurait sans doute pu faire plus simple ;-)
+            s1_trace = vector(name= 'temp1')
+            s2_trace = vector(name= 'temp2')
+
+            s1_trace.add_vertex([pt1_left, pt1_right])
+            s2_trace.add_vertex([pt2_left, pt2_right])
+
+            # Convert to LineString for Shapely operations
+            s1_trace = s1_trace.linestring
+            s2_trace = s2_trace.linestring
+
+            sloc = 0. # position adimensionnelle le long du support
+            # On a calculé la distance utile de discrétisation "locds".
+            # On va donc évoluer le long des supports en incrémentant "sloc" progressivement.
+
+            # Compute alpha coefficients for left and right endpoints of the support vectors
+            def safe_div(a, b):
+                return a / b if b != 0. else 0.
+
+            for s_along_sup in range(nbi_support + 1):
+
+                logging.debug(str(s_along_sup))
+
+                # Interpolation 3D sur les 2 supports
+                #
+                # Si le vecteur support est 3D, on souhaite utiliser les positions
+                # relatives des points des sections par rapport aux points du support
+                # pour calculer les positions des points interpolés.
+
+                l1 = cur_support_left.interpolate(s= sloc, is3D= True, adim= True)
+                l2 = cur_support_right.interpolate(s= sloc, is3D= True, adim= True)
+
+                # Trace de la future section interpolée.
+                # Tout comme "s1_trace" et "s2_trace"", c'est un segment de droite
+                # qui servira de position de départ à laquelle des incréments seront ajoutés.
+                # Cela définira les points de la section interpolée.
+                #
+                # On garde ici l'objet de type "vector"
+                cur_trace=vector(name='loc')
+                cur_trace.add_vertex([l1, l2])
+                all_points_interp = []
+
+                if l1.z != 0. and l1.z != -99999.:
+                    # Le support est 3D
+                    alpha1_left = safe_div(l1.z, pt1_left.z)
+                    alpha2_left = safe_div(l1.z, pt2_left.z)
                 else:
-                    alpha1l = 0.
-                    alpha2l = 0.
-                if l2.z!=0.:
-                    if pt1r.z==0.:
-                        alpha1r = 0.
-                    else:
-                        alpha1r = l2.z/pt1r.z
+                    alpha1_left = 0.
+                    alpha2_left = 0.
 
-                    if pt2r.z==0.:
-                        alpha2r = 0.
-                    else:
-                        alpha2r = l2.z/pt2r.z
+                if l2.z != 0. and l2.z != -99999.:
+                    # Le support est 3D
+                    alpha1_right = safe_div(l2.z, pt1_right.z)
+                    alpha2_right = safe_div(l2.z, pt2_right.z)
                 else:
-                    alpha1r=0.
-                    alpha2r=0.
+                    alpha1_right = 0.
+                    alpha2_right = 0.
 
+                # Bouclage sur tous les points d'interpolation
+                # sur les sections
                 for curdist in dist3d:
 
-                    #interpolation 3D dans les 2 sections
-                    cur1 = curvec1.interpolate(curdist,True,True)
-                    cur2 = curvec2.interpolate(curdist,True,True)
-
-                    alpha1 = alpha1l*(1.-curdist)+alpha1r*curdist
-                    alpha2 = alpha2l*(1.-curdist)+alpha2r*curdist
-
-                    sr1 = s1dr.project(Point(cur1.x,cur1.y))
-                    sr2 = s2dr.project(Point(cur2.x,cur2.y))
-                    pr1 = s1dr.interpolate(sr1)
-                    pr2 = s2dr.interpolate(sr2)
-                    sr1/=s1dr.length
-                    sr2/=s2dr.length
-
-                    dx1 = cur1.x-pr1.x
-                    dy1 = cur1.y-pr1.y
-                    dx2 = cur2.x-pr2.x
-                    dy2 = cur2.y-pr2.y
-                    dx = dx1*(1.-sloc)+dx2*sloc
-                    dy = dy1*(1.-sloc)+dy2*sloc
-                    s = sr1*(1.-sloc)+sr2*sloc
-
-                    # dist2d1 = cur1.dist2D(curvec1.myvertices[0])/curvec1.myvertices[0].dist2D(curvec1.myvertices[-1]) #curvec1.length2D
-                    # dist2d2 = cur2.dist2D(curvec2.myvertices[0])/curvec2.myvertices[0].dist2D(curvec2.myvertices[-1]) #curvec2.length2D
-                    # dist2d  = dist2d1*(1.-sloc) + dist2d2*sloc
-                    # pt = curvec.interpolate(dist2d,False,True)
-                    pt = curvec.interpolate(s,False,True)
-
-                    # xloc = cur1.x + sloc * (cur2.x-cur1.x)
-                    # yloc = cur1.y + sloc * (cur2.y-cur1.y)
+                    # Interpolation 3D dans les 2 sections
+                    cur1 = curvec1.interpolate(s= curdist, is3D = True, adim = True)
+                    cur2 = curvec2.interpolate(s= curdist, is3D = True, adim = True)
+
+                    # Pondération linéaire des alphas
+                    alpha1 = alpha1_left * (1.-curdist) + alpha1_right*curdist
+                    alpha2 = alpha2_left * (1.-curdist) + alpha2_right*curdist
+
+                    # Projection 2D des points sur les traces des sections
+                    # En fonction de la forme réelle de la section, ces projections
+                    # pourraient ne pas être situées selon une abscisse curviligne
+                    # strictement croissante le long de la section.
+                    s_proj1 = s1_trace.project(Point(cur1.x, cur1.y))
+                    s_proj2 = s2_trace.project(Point(cur2.x, cur2.y))
+
+                    # Interpolation des points sur les traces des sections
+                    proj_1 = s1_trace.interpolate(s_proj1)
+                    proj_2 = s2_trace.interpolate(s_proj2)
+
+                    s_proj1 /= s1_trace.length # adimensional position along the section 1
+                    s_proj2 /= s2_trace.length # adimensional position along the section 2
+
+                    # Relative position of the points on the support.
+                    # We calculate the difference between the projected points and the original points.
+                    dx1 = cur1.x - proj_1.x
+                    dy1 = cur1.y - proj_1.y
+                    dx2 = cur2.x - proj_2.x
+                    dy2 = cur2.y - proj_2.y
+
+                    # Linear ponderation of the differences
+                    dx = dx1*(1.-sloc) + dx2*sloc
+                    dy = dy1*(1.-sloc) + dy2*sloc
+                    s  = s_proj1*(1.-sloc) + s_proj2*sloc
+
+                    # !! Interpolation en 2D !! pour être cohérent avec le "s" des traces.
+                    pt = cur_trace.interpolate(s, is3D = False, adim = True)
+
+                    # Pondération des altitudes
                     zloc = cur1.z*alpha1 + sloc * (cur2.z*alpha2-cur1.z*alpha1)
 
-                    val.append(wolfvertex(pt.x+dx,pt.y+dy,zloc))
-                    # val.append(wolfvertex(xloc,yloc,zloc))
+                    # Ajout du point
+                    all_points_interp.append(wolfvertex(pt.x+dx, pt.y+dy, zloc))
+
+                # ajout de la liste des points interpolés dans la section
+                interpolant.append(all_points_interp)
+
+                # mise à jour de la position le long de la section
+                sloc += locds
 
-                interpolant.append(val)
+                # Limite la position à 1.0 pour éviter les débordements.
+                # La sommation des distances ne garantit pas que la position
+                # le long de la section soit strictement inférieure à 1.0.
+                sloc = min(sloc,1.)
 
-                sloc+=locds
-                sloc=min(sloc,1.)
 
-    def get_xyz_for_viewer(self,nbsub=10):
+    def get_xyz_for_viewer(self, nbsub=10):
+        """ Get the XYZ coordinates for the viewer.
+
+        :param nbsub: Number of subdivisions for each segment, default is 10.
+        :type nbsub: int
+        :return: A numpy array of shape [(nb-1)*nbsub, 4] containing the XYZ coordinates.
+        :rtype: np.ndarray
+        """
 
         pts=self.interpolants
 
@@ -3273,7 +4007,12 @@ class Interpolator():
 
         return xyz
 
-    def add_triangles_to_zone(self,myzone:zone):
+    def add_triangles_to_zone(self, myzone:zone):
+        """ Add triangles to the specified zone based on the interpolants.
+
+        :param myzone: The zone to which the triangles will be added.
+        :type myzone: zone
+        """
 
         nb=0
         npt=1
@@ -3297,8 +4036,17 @@ class Interpolator():
             npt+=1
             nb+=(len(curpt)-1)*(len(curl)-1)*3+(len(curl)-1)+(len(curpt))
 
-    def get_triangles(self,forgltf=True):
+    def get_triangles(self, forgltf=True):
+        """ Get the triangles and points for the interpolants.
 
+        ATTENTION : gltf format coordinates as [x, z, -y] and "forgltf" is True by default.
+        It is not the case in "get_points" where forgltf is False by default.
+
+        :param forgltf: If True, formats the points for glTF export, default is True.
+        :type forgltf: bool
+        :return: A tuple containing the number of points, points array, and triangles array.
+        :rtype: tuple[int, np.ndarray, np.ndarray]
+        """
         points=[]
         triangles=[]
         nbpts=0
@@ -3334,11 +4082,22 @@ class Interpolator():
 
 
         if len(np.argwhere(np.isnan(points)==True))>0:
-            a=1
+            logging.error(_('NaN values found in points array.'))
+            raise ValueError(_('NaN values found in points array.'))
 
         return nbpts,points,triangles
 
-    def get_points(self,forgltf=False):
+    def get_points(self, forgltf=False):
+        """ Get the points for the interpolants.
+
+        ATTENTION : gltf format coordinates as [x, z, -y] and "forgltf" is False by default.
+        It is not the case in "get_triangles" where forgltf is True by default.
+
+        :param forgltf: If True, formats the points for glTF export, default is False.
+        :type forgltf: bool
+        :return: A tuple containing the number of points and the points array.
+        :rtype: tuple[int, np.ndarray]
+        """
 
         points=[]
         nbpts=0
@@ -3362,7 +4121,19 @@ class Interpolator():
         return nbpts,points
 
     def export_gltf(self, points=None, triangles=None, fn:str | Path = None):
-
+        """ Export the interpolated sections as a glTF file.
+
+        GLTF can be opened in many 3D viewers, including Blender, Cesium, and others.
+
+        :param points: Optional points array, if None, it will be generated from the interpolants.
+        :type points: np.ndarray | None
+        :param triangles: Optional triangles array, if None, it will be generated from the interpolants.
+        :type triangles: np.ndarray | None
+        :param fn: The filename to save the glTF file, if None, a file dialog will be shown.
+        :type fn: str | Path | None
+        :return: None
+        :rtype: None
+        """
         if points is None and triangles is None:
             points,triangles= self.get_triangles()
 
@@ -3441,56 +4212,58 @@ class Interpolator():
         gltf.save(fn)
 
     def get_xy_z_for_griddata(self):
-
+        """
+        Get the XY and Z coordinates for griddata interpolation (Scipy).
+        """
         xy = np.asarray([[curvertex.x,curvertex.y] for curpt in self.interpolants for curl in curpt for curvertex in curl])
         z = np.asarray([curvertex.z for curpt in self.interpolants for curl in curpt for curvertex in curl])
 
-        # if len(np.argwhere(np.isnan(z)))>0:
-        #     test=1
-        # if len(np.argwhere(np.isneginf(z)))>0:
-        #     test=1
-        # if len(np.argwhere(np.isposinf(z)))>0:
-        #     test=1
         return xy,z
 
 class Interpolators():
     """
-    Classe de gestion des interpolations sur sections en travers
+    Classe de gestion des interpolations sur sections en travers.
+
+    La préparation de la triangulation est faite sur base de vecteurs supports (instance de type "Zones")
+    et de sections en travers stockées dans une instance de type "crosssections".
     """
 
-    def __init__(self, banks:Zones, cs:crosssections, ds=1.) -> None:
+    def __init__(self, banks:Zones, cs:crosssections, ds:float = 1.) -> None:
         """
-        Constructeur de la classe Interpolators
+        Constructeur de la classe Interpolators.
 
-        :param banks: Zones contenant les vecteurs supports
+        :param banks: Zones contenant les vecteurs supports (pay attention to the used property for zone and vectors)
         :param cs: objet 'crosssections' contenant les sections en travers --> voir PyCrosssections
+        :param ds: distance souhaitée de discrétisation [m]
         """
 
-        self.points = None
-        self.triangles = None
+        self.points    = None # Points for triangulation
+        self.triangles = None # Triangles for triangulation
 
-        self.mybanks = [curv for curzone in banks.myzones for curv in curzone.myvectors]
+        # Convert the supports/banks to a list of vectors
+        # All vectors in the zones will be used (independent of the zone name)
+        # If a zone/vector is not used, it will not be included in the list
+        self.mybanks = [curv for curzone in banks.myzones if curzone.used for curv in curzone.myvectors if curv.used]
 
-        cs.set_zones()
-        self.mycs = cs.myzones
+        cs.set_zones() # Force the cross-sections to be set up as a Zones object
 
-        self.myinterp:list[Interpolator]=[]
+        self.myinterp:list[Interpolator]=[] # List of Interpolator objects
 
-        zonecs:zone
-        zonecs = self.mycs.myzones[0]
+        # self.mycs = cs.myzones # pointer to the zones of the cross-sections
+        zonecs = cs.myzones.myzones[0]
 
         if zonecs.myvectors[0].up is not None:
             # Les sections ont été triées sur base d'un vecteur support
             # On les traite dans l'ordre du tri
             cs1:profile
-            cs1=cs.get_upstream()['cs']
+            cs1 = cs.get_upstream()['cs']
 
             while cs1.down is not cs1:
                 cs2=cs1.down
 
                 logging.info('{} - {}'.format(cs1.myname,cs2.myname))
 
-                myinterp=Interpolator(cs1,cs2,self.mybanks,ds)
+                myinterp = Interpolator(cs1, cs2, self.mybanks, ds)
 
                 if len(myinterp.interpolants)>0:
                     self.myinterp.append(myinterp)
@@ -3499,13 +4272,18 @@ class Interpolators():
 
                 cs1=cs2
         else:
-            # Les sections n'ont pas été triées --> on les traite dans l'ordre d'énumération
+            # Les sections n'ont pas été triées
+            # --> on les traite dans l'ordre d'énumération
             for i in range(zonecs.nbvectors-1):
-                cs1=zonecs.myvectors[i]
-                cs2=zonecs.myvectors[i+1]
+                cs1:vector
+                cs2:vector
+                cs1 = zonecs.myvectors[i]   # Cross-section 1
+                cs2 = zonecs.myvectors[i+1] # Cross-section 2
 
                 logging.info('{} - {}'.format(cs1.myname,cs2.myname))
-                myinterp=Interpolator(cs1,cs2,self.mybanks,ds)
+
+                myinterp = Interpolator(cs1, cs2, self.mybanks, ds)
+
                 if len(myinterp.interpolants)>0:
                     self.myinterp.append(myinterp)
                 else:
@@ -3552,6 +4330,7 @@ class Interpolators():
 
 
     def viewer_interpolator(self):
+        """ Display the interpolated sections in a viewer. """
 
         xyz=[]
         for curinterp in self.myinterp:
@@ -3561,9 +4340,34 @@ class Interpolators():
 
         myviewer(xyz,0)
 
+    @property
+    def points_xyz(self):
+        """ Get the XYZ coordinates of the interpolated points.
+
+        Points are stored as [x,z,-y] for glTF compatibility.
+        Convert them to [x,y,z] for other uses.
+        """
+        pts = self.points.reshape([-1,3])[:,[0,2,1]].copy()  # Convert from [x,z,-y] to [x,y,z]
+        pts[:,1] = -pts[:,1]  # Convert from -y to y
+        return pts
+
     def interp_on_array(self, myarray,
                         method:Literal["nearest", "linear", "cubic"],
-                        use_cloud:bool = True):
+                        use_cloud:bool=True,
+                        mask_outside_polygons:bool=False):
+        """ Interpolate the sections on a WolfArray.
+
+        :param myarray: The WolfArray to interpolate on.
+        :type myarray: WolfArray
+        :param method: The interpolation method to use, default is "linear".
+        :type method: str
+        :param use_cloud: If True, uses cloud interpolation, otherwise triangulation, default is True.
+        :type use_cloud: bool
+        """
+        from .wolf_array import WolfArray
+        from .PyVertexvectors import Triangulation
+
+        myarray:WolfArray
 
         if use_cloud:
             xy=[]
@@ -3576,7 +4380,40 @@ class Interpolators():
             xy = np.concatenate(xy)
             z = np.concatenate(z)
             myarray.interpolate_on_cloud(xy,z,method)
+
+            if mask_outside_polygons:
+
+                # Mask points outside the polygons defined by the triangulation
+                # Do not solve the problem of points alongside the polygons or on the vertices
+                # observed in some cases if we use triangulation.
+                #
+                # Should be improved by searching the contour of the polygons
+                # like the concatenation of external supports (left + last_section + right_inverted + first_section_inverted)
+
+                tmp_tri = Triangulation(pts = self.points_xyz, tri=self.triangles)
+                ij = myarray.get_ij_inside_listofpolygons(tmp_tri._get_polygons())
+                myarray.array.mask[:,:] = True  # Mask all points
+                myarray.array.mask[ij[:,0], ij[:,1]] = False  # Unmask
+                myarray.set_nullvalue_in_mask()
         else:
             for interp in self.myinterp:
                 n, pts, tri = interp.get_triangles(forgltf=False)
-                myarray.interpolate_on_triangulation(pts, tri, interp_method= 'scipy')
+                myarray.interpolate_on_triangulation(pts, tri, interp_method= 'scipy')
+
+    def saveas(self, fn: str | Path):
+        """ Save the interpolators to files.
+
+        Each interpolator will be saved as a separate file with a .tri extension.
+
+        :param fn: The filename to save the interpolators.
+        :type fn: str | Path
+        """
+        from .PyVertexvectors import Triangulation
+
+        if isinstance(fn, str):
+            fn = Path(fn)
+
+        for i, interp in enumerate(self.myinterp):
+            n, pts, tri = interp.get_triangles(forgltf=False)
+            tmp_tri = Triangulation(pts = pts, tri = tri)
+            tmp_tri.saveas(fn.parent / (fn.stem + f'_interp{i+1}.tri'))