wolfhece 1.8.13__py3-none-any.whl → 2.0.0__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -18,12 +18,14 @@ from typing import Union, Literal
 import logging
 from tqdm import tqdm
 import geopandas as gpd
+import io
+from typing import Union, Literal
 
 from .textpillow import Font_Priority
 from .PyTranslate import _
 from .CpGrid import CpGrid
 from .PyVertex import wolfvertex,getIfromRGB,getRGBfromI
-from .PyParams import Wolf_Param
+from .PyParams import Wolf_Param, key_Param, Type_Param
 from .lazviewer.laz_viewer import myviewer
 from .wolf_texture import Text_Image_Texture,Text_Infos
 from .drawing_obj import Element_To_Draw
@@ -309,7 +311,7 @@ class Triangulation(Element_To_Draw):
 
         self.id_list = -99999
 
-    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
+    def plot(self):
 
         if self.id_list == -99999:
             self.id_list = glGenLists(1)
@@ -382,7 +384,7 @@ class Triangulation(Element_To_Draw):
         self.nb_tri = len(self.tri)
         self.valid_format()
 class vectorproperties:
-
+    """ Vector properties """
     used:bool
 
     color:int
@@ -411,7 +413,14 @@ class vectorproperties:
 
     myprops:Wolf_Param = None
 
-    def __init__(self,lines=[],parent=None) -> None:
+    def __init__(self, lines:list[str]=[], parent:"vector"=None) -> None:
+        """
+        Init the vector properties -- Compatibility with VB6, Fortran codes --> Modify with care
+
+        @param lines: list of lines from a file
+        @param parent: parent vector
+        """
+
         self.parent:vector
         self.parent=parent
 
@@ -442,6 +451,7 @@ class vectorproperties:
 
             self.used=lines[2]=='#TRUE#'
         else:
+            # default values in case of new vector
             self.color=0
             self.width=1
             self.style=1
@@ -468,31 +478,39 @@ class vectorproperties:
         self.init_extra()
 
     def init_extra(self):
+        """
+        Init extra properties --> not compatible with VB6, Fortran codes
 
-        self.legendlength = 100
-        self.legendheight = 100
+        Useful for Python UI, OpenGL legend, etc.
+        """
+        self.legendlength = 100.
+        self.legendheight = 100.
         self.legendpriority = 2
-        self.legendorientation = 0
+        self.legendorientation = 0.
 
-    def get_extra(self):
+    def get_extra(self) -> list[float,float,int,float]:
+        """ Return extra properties """
+        return [self.legendlength,
+                self.legendheight,
+                self.legendpriority,
+                self.legendorientation]
 
-        extras = [self.legendlength,
-                  self.legendheight,
-                  self.legendpriority,
-                  self.legendorientation]
+    def set_extra(self, linesextra:list[float,float,int,float] = None):
+        """ Set extra properties """
 
-        return extras
+        if linesextra is None:
+            return
 
-    def set_extra(self,linesextra:list):
+        assert len(linesextra)==4, 'Extra properties must be a list of [float, float, int, float]'
 
-        if len(linesextra)>0:
-            self.legendlength = float(linesextra[0])
-            self.legendheight = float(linesextra[1])
-            self.legendpriority = float(linesextra[2])
-            self.legendorientation = float(linesextra[3])
+        self.legendlength = float(linesextra[0])
+        self.legendheight = float(linesextra[1])
+        self.legendpriority = float(linesextra[2])
+        self.legendorientation = float(linesextra[3])
 
 
-    def saveextra(self,f):
+    def save_extra(self, f:io.TextIOWrapper):
+        """ Save extra properties to opened file """
 
         extras = self.get_extra()
 
@@ -501,7 +519,12 @@ class vectorproperties:
         for curextra in extras:
             f.write('{}'.format(curextra)+'\n')
 
-    def save(self,f):
+    def save(self, f:io.TextIOWrapper):
+        """
+        Save properties to opened file
+
+        Pay attention to the order of the lines and the format to be compatible with VB6, Fortran codes
+        """
         line1 = str(self.color) + ',' + str(self.width)+','+ str(self.style)
 
         added = ',#TRUE#' if self.closed else ',#FALSE#'
@@ -532,120 +555,39 @@ class vectorproperties:
         added = '#TRUE#' if self.used else '#FALSE#'
         f.write(added+'\n')
 
-    def fill_property_default(self):
-
-        curdict=self.myprops.myparams_default
-
-        if 'Draw' in curdict.keys():
-            keysactive = curdict['Draw'].keys()
-            if 'Color' in keysactive:
-                self.color = getIfromRGB(curdict['Draw']['Color']['value'])
-            if 'Width' in keysactive:
-                self.width = int(curdict['Draw']['Width']['value'])
-            if 'Style' in keysactive:
-                self.style = int(curdict['Draw']['Style']['value'])
-            if 'Closed' in keysactive:
-                self.closed = bool(curdict['Draw']['Closed']['value'])
-            if 'Filled' in keysactive:
-                self.filled = bool(curdict['Draw']['Filled']['value'])
-            if 'Transparent' in keysactive:
-                self.transparent = bool(curdict['Draw']['Transparent']['value'])
-            if 'Alpha' in keysactive:
-                self.alpha = int(curdict['Draw']['Alpha']['value'])
-            if 'Flash' in keysactive:
-                self.flash = bool(curdict['Draw']['Flash']['value'])
-
-        if 'Legend' in curdict.keys():
-            keysactive = curdict['Legend'].keys()
-            if 'Underlined' in keysactive:
-                self.legendunderlined = bool(curdict['Legend']['Underlined']['value'])
-            if 'Bold' in keysactive:
-                self.legendbold = bool(curdict['Legend']['Bold']['value'])
-            if 'Font name' in keysactive:
-                self.legendfontname = str(curdict['Legend']['Font name']['value'])
-            if 'Font size' in keysactive:
-                self.legendfontsize = int(curdict['Legend']['Font size']['value'])
-            if 'Color' in keysactive:
-                self.legendcolor = getIfromRGB(curdict['Legend']['Color']['value'])
-            if 'Italic' in keysactive:
-                self.legenditalic = bool(curdict['Legend']['Italic']['value'])
-            if 'relative Position' in keysactive:
-                self.legendrelpos = int(curdict['Legend']['relative Position']['value'])
-            if 'Text' in keysactive:
-                self.legendtext = str(curdict['Legend']['Text']['value'])
-            if 'Visible' in keysactive:
-                self.legendvisible = bool(curdict['Legend']['Visible']['value'])
-            if 'X' in keysactive:
-                self.legendx = float(curdict['Legend']['X']['value'])
-            if 'Y' in keysactive:
-                self.legendy = float(curdict['Legend']['Y']['value'])
-
-            if 'Length' in keysactive:
-                self.legendlength = float(curdict['Legend']['Length']['value'])
-            if 'Height' in keysactive:
-                self.legendheight = float(curdict['Legend']['Height']['value'])
-            if 'Priority' in keysactive:
-                self.legendpriority = int(curdict['Legend']['Priority']['value'])
-            if 'Orientation' in keysactive:
-                self.legendorientation = float(curdict['Legend']['Orientation']['value'])
-
     def fill_property(self):
-
-        curdict=self.myprops.myparams
-        self.fill_property_default()
-
-        if 'Draw' in curdict.keys():
-            keysactive = curdict['Draw'].keys()
-            if 'Color' in keysactive:
-                self.color = getIfromRGB(curdict['Draw']['Color']['value'].replace('(','').replace(')','').split(', '))
-            if 'Width' in keysactive:
-                self.width = int(curdict['Draw']['Width']['value'])
-            if 'Style' in keysactive:
-                self.style = int(curdict['Draw']['Style']['value'])
-            if 'Closed' in keysactive:
-                self.closed = bool(curdict['Draw']['Closed']['value'])
-            if 'Filled' in keysactive:
-                self.filled = bool(curdict['Draw']['Filled']['value'])
-            if 'Transparent' in keysactive:
-                self.transparent = bool(curdict['Draw']['Transparent']['value'])
-            if 'Alpha' in keysactive:
-                self.alpha = int(curdict['Draw']['Alpha']['value'])
-            if 'Flash' in keysactive:
-                self.flash = bool(curdict['Draw']['Flash']['value'])
-
-        if 'Legend' in curdict.keys():
-            keysactive = curdict['Legend'].keys()
-            if 'Underlined' in keysactive:
-                self.legendunderlined = bool(curdict['Legend']['Underlined']['value'])
-            if 'Bold' in keysactive:
-                self.legendbold = bool(curdict['Legend']['Bold']['value'])
-            if 'Font name' in keysactive:
-                self.legendfontname = str(curdict['Legend']['Font name']['value'])
-            if 'Font size' in keysactive:
-                self.legendfontsize = int(curdict['Legend']['Font size']['value'])
-            if 'Color' in keysactive:
-                self.legendcolor = getIfromRGB(curdict['Legend']['Color']['value'].replace('(','').replace(')','').split(', '))
-            if 'Italic' in keysactive:
-                self.legenditalic = bool(curdict['Legend']['Italic']['value'])
-            if 'relative Position' in keysactive:
-                self.legendrelpos = int(curdict['Legend']['relative Position']['value'])
-            if 'Text' in keysactive:
-                self.legendtext = str(curdict['Legend']['Text']['value'])
-            if 'Visible' in keysactive:
-                self.legendvisible = bool(curdict['Legend']['Visible']['value'])
-            if 'X' in keysactive:
-                self.legendx = float(curdict['Legend']['X']['value'])
-            if 'Y' in keysactive:
-                self.legendy = float(curdict['Legend']['Y']['value'])
-
-            if 'Length' in keysactive:
-                self.legendlength = float(curdict['Legend']['Length']['value'])
-            if 'Height' in keysactive:
-                self.legendheight = float(curdict['Legend']['Height']['value'])
-            if 'Priority' in keysactive:
-                self.legendpriority = int(curdict['Legend']['Priority']['value'])
-            if 'Orientation' in keysactive:
-                self.legendorientation = float(curdict['Legend']['Orientation']['value'])
+        """
+        Callback for the properties UI
+
+        When the 'Apply' button is pressed, this function is called
+        """
+        props = self.myprops
+
+        self.color = getIfromRGB(props[('Draw','Color')])
+        self.width = props[('Draw','Width')]
+        self.style = props[('Draw','Style')]
+        self.closed = props[('Draw','Closed')]
+        self.filled = props[('Draw','Filled')]
+        self.transparent = props[('Draw','Transparent')]
+        self.alpha = props[('Draw','Alpha')]
+        self.flash = props[('Draw','Flash')]
+
+        self.legendunderlined = props[('Legend','Underlined')]
+        self.legendbold = props[('Legend','Bold')]
+        self.legendfontname = props[('Legend','Font name')]
+        self.legendfontsize = props[('Legend','Font size')]
+        self.legendcolor = getIfromRGB(self.myprops[('Legend','Color')])
+        self.legenditalic = props[('Legend','Italic')]
+        self.legendrelpos = props[('Legend','relative Position')]
+        self.legendtext = props[('Legend','Text')]
+        self.legendvisible = props[('Legend','Visible')]
+        self.legendx = props[('Legend','X')]
+        self.legendy = props[('Legend','Y')]
+
+        self.legendlength = props[('Legend','Length')]
+        self.legendheight = props[('Legend','Height')]
+        self.legendpriority = props[('Legend','Priority')]
+        self.legendorientation = props[('Legend','Orientation')]
 
         if self.legendvisible:
             self.parent.textimage = Text_Image_Texture(self.legendtext,
@@ -657,24 +599,37 @@ class vectorproperties:
         else:
             self.parent.textimage=None
 
+        try:
+            self.parent.parentzone.parent.mapviewer.Refresh()
+        except:
+            pass
+
     def get_textfont(self):
+        """ Retunr a 'Text_Infos' instance for the legend """
 
         r,g,b = getRGBfromI(self.legendcolor)
         return Text_Infos(self.legendpriority,
                           (np.cos(self.legendorientation/180*np.pi),np.sin(self.legendorientation/180*np.pi)),
-                          self.legendfontname.lower()+'.ttf',
+                          self.legendfontname.lower().endswith('.ttf'),
                           self.legendfontsize,
                           colour=(r,g,b,255),
                           dimsreal=(self.legendlength,self.legendheight))
 
-    def defaultprop(self):
+    def _defaultprop(self):
+        """
+        Create the default properties for the vector and the associated UI
+        """
+
         if self.myprops is None:
-            self.myprops=Wolf_Param(title='Vector Properties',to_read=False)
+            self.myprops=Wolf_Param(title='Vector Properties', w=500, h=800, to_read=False)
+            self.myprops.show_in_active_if_default = True
             self.myprops._callbackdestroy = self.destroyprop
             self.myprops._callback=self.fill_property
-            self.myprops.saveme.Disable()
-            self.myprops.loadme.Disable()
-            self.myprops.reloadme.Disable()
+
+            self.myprops.hide_selected_buttons() # only 'Apply' button
+            # self.myprops.saveme.Disable()
+            # self.myprops.loadme.Disable()
+            # self.myprops.reloadme.Disable()
 
         self.myprops.addparam('Draw','Color',(0,0,0),'Color','Drawing color',whichdict='Default')
         self.myprops.addparam('Draw','Width',1,'Integer','Drawing width',whichdict='Default')
@@ -692,7 +647,7 @@ class vectorproperties:
         self.myprops.addparam('Legend','Y',0,'Float','',whichdict='Default')
         self.myprops.addparam('Legend','Bold',False,'Logical','',whichdict='Default')
         self.myprops.addparam('Legend','Italic',False,'Logical','',whichdict='Default')
-        self.myprops.addparam('Legend','Font name','Arial','String','',whichdict='Default')
+        self.myprops.addparam('Legend','Font name','Arial', 'String','',whichdict='Default')
         self.myprops.addparam('Legend','Font size',10,'Integer','',whichdict='Default')
         self.myprops.addparam('Legend','Color',(0,0,0),'Color','',whichdict='Default')
         self.myprops.addparam('Legend','Underlined',False,'Logical','',whichdict='Default')
@@ -702,10 +657,21 @@ class vectorproperties:
         self.myprops.addparam('Legend','Orientation',0,'Float','',whichdict='Default')
 
     def destroyprop(self):
+        """
+        Nullify the properties UI
+
+        Destroy has been called, so the UI is not visible anymore
+        """
         self.myprops=None
 
     def show(self):
-        self.defaultprop()
+        """
+        Show the properties
+
+        Firstly, set default values
+        Then, add the current properties to the UI
+        """
+        self._defaultprop()
 
         self.myprops.addparam('Draw','Color',getRGBfromI(self.color),'Color','Drawing color')
         self.myprops.addparam('Draw','Width',self.width,'Integer','Drawing width')
@@ -734,6 +700,8 @@ class vectorproperties:
         self.myprops.addparam('Legend','Orientation',self.legendorientation,'Float','')
 
         self.myprops.Populate()
+        self.myprops.Layout()
+        self.myprops.SetSizeHints(500,800)
         self.myprops.Show()
 
 class vector:
@@ -790,11 +758,11 @@ class vector:
         if type(lines)==list:
             if len(lines)>0:
                 self.myname=lines[0]
-                self.nbvertices=int(lines[1])
+                tmp_nbvertices=int(lines[1])
                 self.myvertices=[]
 
                 if is2D:
-                    for i in range(self.nbvertices):
+                    for i in range(tmp_nbvertices):
                         try:
                             curx,cury=lines[2+i].split()
                         except:
@@ -802,7 +770,7 @@ class vector:
                         curvert = wolfvertex(float(curx),float(cury))
                         self.myvertices.append(curvert)
                 else:
-                    for i in range(self.nbvertices):
+                    for i in range(tmp_nbvertices):
                         try:
                             curx,cury,curz=lines[2+i].split()
                         except:
@@ -810,11 +778,10 @@ class vector:
                         curvert = wolfvertex(float(curx),float(cury),float(curz))
                         self.myvertices.append(curvert)
 
-                self.myprop=vectorproperties(lines[self.nbvertices+2:],parent=self)
+                self.myprop=vectorproperties(lines[tmp_nbvertices+2:],parent=self)
 
         if name!='' and self.myname=='':
             self.myname=name
-            self.nbvertices=0
             self.myvertices=[]
             self.myprop=vectorproperties(parent=self)
 
@@ -829,6 +796,18 @@ class vector:
         if fromshapely is not None:
             self.import_shapelyobj(fromshapely)
 
+    @property
+    def nbvertices(self) -> int:
+        return len(self.myvertices)
+
+    @property
+    def used(self) -> bool:
+        return self.myprop.used
+
+    @used.setter
+    def used(self, value:bool):
+        self.myprop.used = value
+
     def import_shapelyobj(self, obj):
         """ Importation d'un objet shapely """
 
@@ -875,7 +854,10 @@ class vector:
             return ((xmin, xmax), (ymin, ymax))
 
     def get_mean_vertex(self, asshapelyPoint = False):
+        """ Return the mean vertex """
+
         if self.closed or (self.myvertices[0].x == self.myvertices[-1].x and self.myvertices[0].y == self.myvertices[-1].y):
+            # if closed, we don't take the last vertex otherwise we have a double vertex
             x_mean = np.mean([curvert.x for curvert in self.myvertices[:-1]])
             y_mean = np.mean([curvert.y for curvert in self.myvertices[:-1]])
             z_mean = np.mean([curvert.z for curvert in self.myvertices[:-1]])
@@ -1045,37 +1027,6 @@ class vector:
         else:
             return None
 
-    # def offset_curve(self, distance=5.):
-    #     """
-    #     The distance parameter must be a signed float value.
-    #     """
-
-    #     if self.nbvertices<2:
-    #         return None
-
-    #     myls = self.asshapely_ls()
-
-    #     mypar = myls.offset_curve(distance=abs(distance),join_style=JOIN_STYLE.round)
-
-    #     if mypar.geom_type=='MultiLineString':
-    #         return None
-
-    #     if len(mypar.coords) >0:
-
-    #         newvec = vector(name='par'+str(distance), parentzone=self.parentzone)
-
-    #         for x,y in mypar.coords:
-    #             xy = Point(x,y)
-    #             curs = mypar.project(xy,True)
-    #             curz = myls.interpolate(curs,True).z
-
-    #             newvert = wolfvertex(x,y,curz)
-    #             newvec.add_vertex(newvert)
-
-    #         return newvec
-    #     else:
-    #         return None
-
     def intersection(self, vec2 = None, eval_dist=False,norm=False, force_single=False):
         """
         Calcul de l'intersection avec un autre vecteur
@@ -1112,7 +1063,6 @@ class vector:
 
     def reset(self):
         """Remise à zéro"""
-        self.nbvertices=0
         self.myvertices=[]
         self.linestring=None
 
@@ -1128,7 +1078,6 @@ class vector:
             assert(addedvert is not None)
             assert isinstance(addedvert, wolfvertex)
             self.myvertices.append(addedvert)
-            self.nbvertices += 1
 
     def add_vertices_from_array(self, xyz:np.ndarray):
         """
@@ -1144,8 +1093,13 @@ class vector:
     def count(self):
         """
         Retroune le nombre de vertices
+
+        For compatibility with older version of the code --> use 'nbvertices' property instead
+        Must be removed in the future
         """
-        self.nbvertices=len(self.myvertices)
+        # Nothing to do because nbvertices is a property
+        # self.nbvertices=len(self.myvertices)
+        return
 
     def close_force(self):
         """
@@ -1263,7 +1217,6 @@ class vector:
 
         myvert=wolfvertex(x,y)
         self.myvertices.insert(indexmp,myvert)
-        self.nbvertices+=1
 
         return self.myvertices[indexmp]
 
@@ -1277,7 +1230,7 @@ class vector:
             self.xmax=max(vert.x for vert in self.myvertices)
             self.ymax=max(vert.y for vert in self.myvertices)
 
-    def plot(self):
+    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
         """
         Plot OpenGL
         """
@@ -1399,7 +1352,6 @@ class vector:
 
         while k<self.nbvertices:
             self.myvertices.pop(k)
-            self.nbvertices-=1
 
         if self.linestring is not None:
             self.prepare_shapely()
@@ -1582,7 +1534,6 @@ class vector:
                 except:
                     pass
         else:
-            self.nbvertices = newvec.nbvertices
             self.myvertices = newvec.myvertices
             self.update_lengths()
 
@@ -1905,40 +1856,48 @@ class zone:
     mytree:TreeListCtrl
     myitem:TreeItemId
 
-    def __getitem__(self, ndx) -> vector:
-        return self.myvectors[ndx]
+    def __init__(self,
+                 lines:list[str]=[],
+                 name:str='NoName',
+                 parent:"Zones"=None,
+                 is2D:bool=True,
+                 fromshapely:Union[LineString,Polygon,MultiLineString, MultiPolygon]=None) -> None:
 
-    def __init__(self, lines=[], name='NoName', parent=None, is2D=True, fromshapely=None) -> None:
-
-        self.myname = ''
-        self.idgllist = -99999
-        self.active_vector=None
-        self.parent=parent
+        self.myname = ''        # name of the zone
+        self.idgllist = -99999  # id of the zone in the gllist
+        self.active_vector=None # current active vector
+        self.parent=parent      # parent object - type(Zones)
 
         if len(lines)>0:
+            # Decoding from lines -- lines is a list of strings provided by the parent during reading
+            # The order of the lines is important to ensure compatibility with the WOLF2D format
             self.myname=lines[0]
-            self.nbvectors=int(lines[1])
+            tmp_nbvectors=int(lines[1])
             self.myvectors=[]
             curstart=2
-            for i in range(self.nbvectors):
+            for i in range(tmp_nbvectors):
                 curvec=vector(lines[curstart:],parentzone=self,is2D=is2D)
                 curstart+=curvec._nblines()
                 self.myvectors.append(curvec)
 
         if name!='' and self.myname=='':
             self.myname=name
-            self.nbvectors=0
             self.myvectors=[]
 
-        self.selected_vectors=[]
-        self.multils = None
-        self.used = True
+        self.selected_vectors=[]                # list of selected vectors
+        self.multils:MultiLineString = None     # MultiLineString shapely
+        self.used = True                        # indicate if the zone must used or not --> corresponding to checkbox in the tree
 
-        self.mytree=None
+        self.mytree=None                        # TreeListCtrl wx
 
         if fromshapely is not None:
+            # Object can be created from a shapely object
             self.import_shapelyobj(fromshapely)
 
+    @property
+    def nbvectors(self):
+        return len(self.myvectors)
+
     def import_shapelyobj(self, obj):
         """ Importation d'un objet shapely """
 
@@ -1965,7 +1924,7 @@ class zone:
         Si plusieurs vecteurs portent le même nom, seule le premier est retourné
         """
         if isinstance(keyvector,int):
-            if keyvector<self.nbvectors:
+            if keyvector < self.nbvectors:
                 return self.myvectors[keyvector]
             return None
         if isinstance(keyvector,str):
@@ -1974,7 +1933,12 @@ class zone:
                 return self.myvectors[zone_names.index(keyvector)]
             return None
 
+    def __getitem__(self, ndx:Union[int,str]) -> vector:
+        """ Permet de retrouver un vecteur sur base de son index """
+        return self.get_vector(ndx)
+
     def export_shape(self, fn:str = ''):
+        """ Export to shapefile using GDAL/OGR """
 
         from osgeo import gdal, osr, gdalconst,ogr
 
@@ -2023,7 +1987,7 @@ class zone:
         # Save and close DataSource
         ds = None
 
-    def save(self,f):
+    def save(self, f:io.TextIOWrapper):
         """
         Ecriture sur disque
         """
@@ -2032,14 +1996,14 @@ class zone:
         for curvect in self.myvectors:
             curvect.save(f)
 
-    def saveextra(self,f):
+    def save_extra(self, f:io.TextIOWrapper):
         """
         Ecriture des options EXTRA
         """
         f.write(self.myname+'\n')
         curvect:vector
         for curvect in self.myvectors:
-            curvect.myprop.saveextra(f)
+            curvect.myprop.save_extra(f)
 
     def add_vector(self, addedvect:vector, index=-99999, forceparent=False):
         """
@@ -2050,21 +2014,28 @@ class zone:
             self.myvectors.append(addedvect)
         else:
             self.myvectors.insert(index,addedvect)
-        self.nbvectors+=1
+
         # FIXME set vector's parent to self ?
+        # NOT necessary because, in some situation, we can add a vector
+        #  to a temporary zone without forcing its parent to be this zone
+        if forceparent:
+            addedvect.parentzone = self
 
         if self.nbvectors==1:
             self.active_vector = addedvect
             # FIXME else ?
-
-        if forceparent:
-            addedvect.parentzone = self
+            # NOTHING because the active vector is normally choosen by the UI or during special operations
+            # Here, we select the first added vector
 
     def count(self):
         """
-        Nombre de vecteurs
+        Compte le nombre de vecteurs
+
+        For compatibility with older versions --> Must be removed in future version
         """
-        self.nbvectors=len(self.myvectors)
+        # self.nbvectors=len(self.myvectors)
+        # Nothing to do because the number of vectors is a property
+        return
 
     def _nblines(self):
         """
@@ -2227,8 +2198,6 @@ class zone:
             mypl = self.active_vector.parallel_offset(distance,'right')
         elif distance<0.:
             mypl = self.active_vector.parallel_offset(distance,'left')
-        # if abs(distance)>0.:
-        #     mypl = self.active_vector.offset_curve(distance)
         else:
             mypl = vector(name=self.active_vector.myname+"_duplicate")
             mypl.myvertices = [wolfvertex(cur.x,cur.y,cur.z) for cur in self.active_vector.myvertices]
@@ -3188,15 +3157,12 @@ class Zones(wx.Frame, Element_To_Draw):
     tx:float
     ty:float
 
-    nbzones:int
+    # nbzones:int
 
     myzones:list[zone]
     treelist:TreeListCtrl
     xls:CpGrid
 
-    def __getitem__(self, ndx) -> zone:
-        return self.myzones[ndx]
-
     def __init__(self, filename='', ox:float=0., oy:float=0., tx:float=0., ty:float=0., parent=None, is2D=True, idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
         """
         parent : soit une instance 'WolfMapViewer', soit une instance 'Ops_Array'
@@ -3252,7 +3218,6 @@ class Zones(wx.Frame, Element_To_Draw):
         self.tx=tx
         self.ty=ty
         self.myzones=[]
-        self.nbzones=0
 
         if filename!='':
             # lecture du fichier
@@ -3278,17 +3243,22 @@ class Zones(wx.Frame, Element_To_Draw):
 
                 self.tx=float(tx)
                 self.ty=float(ty)
-                self.nbzones=int(lines[1])
+                tmp_nbzones=int(lines[1])
 
                 curstart=2
-                for i in range(self.nbzones):
+                for i in range(tmp_nbzones):
                     curzone=zone(lines[curstart:],parent=self,is2D=self.is2D)
                     self.myzones.append(curzone)
                     curstart+=curzone._nblines()
 
             self.find_minmax(True)
 
+    @property
+    def nbzones(self):
+        return len(self.myzones)
+
     def import_shapefile(self, fn:str, bbox:Polygon = None):
+        """ Import shapefile by using geopandas """
 
         content = gpd.read_file(fn, bbox=bbox)
 
@@ -3333,6 +3303,11 @@ class Zones(wx.Frame, Element_To_Draw):
                 return self.myzones[zone_names.index(keyzone)]
             return None
 
+    def __getitem__(self, ndx:Union[int,str]) -> zone:
+        """ Retourne la zone sur base de son nom ou de sa position """
+
+        return self.get_zone(ndx)
+
     def import_dxf(self, fn, imported_elts=['POLYLINE','LWPOLYLINE','LINE']):
         """
         Import d'un fichier DXF en tant qu'objets WOLF
@@ -3508,7 +3483,7 @@ class Zones(wx.Frame, Element_To_Draw):
 
         with open(self.filename + '.extra', 'w') as f:
             for curzone in self.myzones:
-                curzone.saveextra(f)
+                curzone.save_extra(f)
 
     def OnClose(self, e):
         """
@@ -3522,7 +3497,6 @@ class Zones(wx.Frame, Element_To_Draw):
         Ajout d'une zone à la liste
         """
         self.myzones.append(addedzone)
-        self.nbzones+=1
 
         if forceparent:
             addedzone.parent = self
@@ -3560,7 +3534,7 @@ class Zones(wx.Frame, Element_To_Draw):
             self.xmax=1.
             self.ymax=1.
 
-    def plot(self):
+    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
         """
         Dessine les zones
         """
@@ -4680,7 +4654,6 @@ class Zones(wx.Frame, Element_To_Draw):
 
             self.active_zone.reset_listogl()
             self.myzones.pop(int(self.myzones.index(self.active_zone)))
-            self.nbzones-=1
             self.fill_structure()
             self.find_minmax(True)
 
@@ -4781,7 +4754,6 @@ class Zones(wx.Frame, Element_To_Draw):
 
             actzone =self.active_zone
             actzone.myvectors.pop(int(actzone.myvectors.index(self.active_vector)))
-            actzone.nbvectors-=1
             self.fill_structure()
             self.find_minmax(True)
 
@@ -4974,56 +4946,49 @@ class Zones(wx.Frame, Element_To_Draw):
                             dlg.Destroy()
                             return
 
-    def add_interpolators(self, myinterpolators):
-        """
-        Ajout d'objets 'Interpolators' pour affichage/stockage
-        """
-        myinterpolators:Interpolators
-        curinterp:Interpolator
-
-        zonesinterp=Zones(parent=self.parent)
-
-        id=0
-        points=[]
-        triangles=[]
-        decal=0
-        for curinterp in myinterpolators.myinterp:
-            id+=1
-
-            myzone = zone(name='Interpolator'+str(id), parent=zonesinterp, is2D=False)
-            myzone.used=False
-            zonesinterp.add_zone(myzone)
-            curinterp.add_triangles_to_zone(myzone)
+class Grid(Zones):
+    """
+    Grid to draw on the mapviewer.
 
-            nbpts,pts,tr=curinterp.get_triangles()
+    Contains one zone and 3 vectors (gridx, gridy, contour).
 
-            points.append(pts)
-            triangles.append(tr+decal)
-            decal+=nbpts
+    Each gridx and gridy vector contains vertices forming a continuous line.
+    Contour vector contains 4 vertices forming a closed polyline.
 
-        curinterp.export_gltf(np.concatenate(points),np.concatenate(triangles))
+    Drawing all the elements on the mapviewer allows to draw a grid.
 
-        # if self.wx_exists:
-        #     self.fill_structure()
+    Based on spatial extent and resolution.
+    """
 
-        return zonesinterp
+    def __init__(self,
+                 size:float=1000.,
+                 ox:float=0.,
+                 oy:float=0.,
+                 ex:float=1000.,
+                 ey:float=1000.,
+                 parent=None):
 
-class Grid(Zones):
-
-    def __init__(self, size:float=1000.,ox:float=0.,oy:float=0.,ex:float=1000.,ey:float=1000., parent=None):
         super().__init__(ox=ox, oy=oy, parent=parent)
 
-        mygrid=zone(name='mygrid',parent=self)
+        mygrid=zone(name='grid',parent=self)
         self.add_zone(mygrid)
-        mygridx=vector(name='mygridx')
-        mygridy=vector(name='mygridy')
+
+        gridx=vector(name='gridx')
+        gridy=vector(name='gridy')
         contour=vector(name='contour')
-        mygrid.add_vector(mygridx)
-        mygrid.add_vector(mygridy)
+
+        mygrid.add_vector(gridx)
+        mygrid.add_vector(gridy)
         mygrid.add_vector(contour)
+
         self.creategrid(size,ox,oy,ex,ey)
 
-    def creategrid(self,size:float=100.,ox:float=0.,oy:float=0.,ex:float=1000.,ey:float=1000.):
+    def creategrid(self,
+                   size:float=100.,
+                   ox:float=0.,
+                   oy:float=0.,
+                   ex:float=1000.,
+                   ey:float=1000.):
 
         mygridx=self.myzones[0].myvectors[0]
         mygridy=self.myzones[0].myvectors[1]
@@ -5081,550 +5046,3 @@ class Grid(Zones):
         contour.add_vertex(newvert)
 
         self.find_minmax(True)
-
-class Interpolator():
-    """
-    Objet d'interpolation sur sections en travers
-
-        - self.interpolants est une liste de listes
-        - chaque élément de self.interpolants est également une liste de listes
-        - chaque liste de self.interpolants[k] contient les wolfvertex de la section discrétisée
-
-    """
-
-    def __init__(self,vec1:vector,vec2:vector,supports:list,ds=1.) -> None:
-
-        self.interpolants=[]
-
-        sect1={}
-        sect2={}
-
-        #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()
-
-        nb = 0
-        supls={}
-
-        eps=5.e-2
-
-        for curvec in supports:
-            #linestring du support courant
-            #distances des intersections des sections sur le support
-            myls:LineString
-            myls=curvec.asshapely_ls()
-
-            #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)
-            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()
-
-            if i1 and i2:
-                supls[nb]={}
-                supls[nb]['ls']=myls
-                supls[nb]['vec']=curvec
-                nb+=1
-
-        #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']
-
-            #intersections du vecteur support avec les sections
-
-            #section amont
-            i1=myls.intersection(s1)
-            if i1.geom_type=='MultiPoint':
-                i1=i1.geoms[0]
-
-            #section aval
-            i2=myls.intersection(s2)
-            if i2.geom_type=='MultiPoint':
-                i2=i2.geoms[0]
-
-            #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):
-            interpolant=[]
-            self.interpolants.append(interpolant)
-
-            cursupl:vector
-            cursupr:vector
-            curvec1:vector
-            curvec2:vector
-
-            #morceaux de sections entre intersections avec le support
-            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']
-
-            #MAJ des longueurs 2D et 3D
-            cursupl.update_lengths()
-            cursupr.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):
-                print(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
-                else:
-                    alpha1l = 0.
-                    alpha2l = 0.
-                if l2.z!=0.:
-                    if pt1r.z==0.:
-                        alpha1r = 0.
-                    else:
-                        alpha1r = l2.z/pt1r.z
-
-                    if pt2r.z==0.:
-                        alpha2r = 0.
-                    else:
-                        alpha2r = l2.z/pt2r.z
-                else:
-                    alpha1r=0.
-                    alpha2r=0.
-
-                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)
-                    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))
-
-                interpolant.append(val)
-
-                sloc+=locds
-                sloc=min(sloc,1.)
-
-    def get_xyz_for_viewer(self,nbsub=10):
-
-        pts=self.interpolants
-
-        nb=0
-        for curpt in pts:
-            for curl in curpt:
-                nb+=(len(curpt)-1)*(len(curl)-1)*3+(len(curl)-1)+(len(curpt))
-
-        pond=np.arange(0.,1.,1./float(nbsub))
-        xyz=np.ones([(nb-1)*nbsub,4],order='F')
-        start=0
-        for curpt in pts:
-            for k in range(len(curpt)-1):
-                curl=curpt[k]
-                nextl=curpt[k+1]
-                for i in range(len(curl)-1):
-                    v1=curl[i].getcoords()
-                    v2=curl[i+1].getcoords()
-                    v3=nextl[i].getcoords()
-
-                    xyz[start:start+nbsub,:3]=[v1+(v2-v1)*curpond for curpond in pond]
-                    start+=nbsub
-                    xyz[start:start+nbsub,:3]= [v2+(v3-v2)*curpond for curpond in pond]
-                    start+=nbsub
-                    xyz[start:start+nbsub,:3]= [v3+(v1-v3)*curpond for curpond in pond]
-                    start+=nbsub
-
-            curl=curpt[-1]
-            for i in range(len(curl)-1):
-                v1=curl[i].getcoords()
-                v2=curl[i+1].getcoords()
-                xyz[start:start+nbsub,:3]=[v1+(v2-v1)*curpond for curpond in pond]
-                start+=nbsub
-            for k in range(len(curpt)-1):
-                curl=curpt[k]
-                nextl=curpt[k+1]
-                v1=curl[-1].getcoords()
-                v3=nextl[-1].getcoords()
-                xyz[start:start+nbsub,:3]=[v1+(v3-v1)*curpond for curpond in pond]
-                start+=nbsub
-
-        return xyz
-
-    def add_triangles_to_zone(self,myzone:zone):
-
-        nb=0
-        npt=1
-        for curpt in self.interpolants:
-            for k in range(len(curpt)-1):
-                curl=curpt[k]
-                nextl=curpt[k+1]
-                for i in range(len(curl)-1):
-                    curvec = vector(name='tr'+'_'+str(npt)+'_'+str(k)+'_'+str(i),parentzone=myzone)
-                    curvec.add_vertex([curl[i],curl[i+1],nextl[i]])
-                    curvec.close_force()
-                    curvec.myprop.used=False
-                    myzone.add_vector(curvec)
-
-                    curvec = vector(name='tr'+'_'+str(npt)+'_'+str(k+1)+'_'+str(i),parentzone=myzone)
-                    curvec.add_vertex([nextl[i],curl[i+1],nextl[i+1]])
-                    curvec.close_force()
-                    curvec.myprop.used=False
-                    myzone.add_vector(curvec)
-
-            npt+=1
-            nb+=(len(curpt)-1)*(len(curl)-1)*3+(len(curl)-1)+(len(curpt))
-
-    def get_triangles(self,forgltf=True):
-
-        points=[]
-        triangles=[]
-        nbpts=0
-        nbtr=0
-        for curpt in self.interpolants:
-
-            nb_points_perline = len(curpt[0])
-            nbsect=len(curpt)
-            if forgltf:
-                pointsloc=[[pt.x,pt.z,-pt.y] for curl in curpt for pt in curl]
-            else:
-                pointsloc=[[pt.x,pt.y,pt.z] for curl in curpt for pt in curl]
-
-            trianglesloc=[[[k+decal*nb_points_perline+nbpts,
-                        k+1+decal*nb_points_perline+nbpts,
-                        nb_points_perline+k+decal*nb_points_perline+nbpts],
-
-                        [nb_points_perline+k+decal*nb_points_perline+nbpts,
-                        k+1+decal*nb_points_perline+nbpts,
-                        nb_points_perline+k+decal*nb_points_perline+1+nbpts]]
-                            for decal in range(len(curpt)-1) for k in range(nb_points_perline-1)]
-
-            nbpts+=nb_points_perline*nbsect
-            nbloc=(nb_points_perline-1)*(nbsect-1)*2
-            nbtr+=nbloc
-
-            points.append(pointsloc)
-            triangles.append(np.asarray(trianglesloc).reshape([nbloc,3]))
-
-
-        points=np.asarray(np.concatenate(points),dtype=np.float32)
-        triangles=np.asarray(np.concatenate(triangles),dtype=np.uint32)
-
-
-        if len(np.argwhere(np.isnan(points)==True))>0:
-            a=1
-
-        return nbpts,points,triangles
-
-    def get_points(self,forgltf=False):
-
-        points=[]
-        nbpts=0
-        for curpt in self.interpolants:
-
-            nb_points_perline = len(curpt[0])
-            nbsect=len(curpt)
-            if forgltf:
-                pointsloc=[[pt.x,pt.z,-pt.y] for curl in curpt for pt in curl]
-            else:
-                pointsloc=[[pt.x,pt.y,pt.z] for curl in curpt for pt in curl]
-
-            nbpts+=nb_points_perline*nbsect
-            points.append(pointsloc)
-
-        if forgltf:
-            points=np.asarray(np.concatenate(points),dtype=np.float32)
-        else:
-            points=np.asarray(np.concatenate(points))
-
-        return nbpts,points
-
-    def export_gltf(self,points=None,triangles=None):
-
-        if points is None and triangles is None:
-            points,triangles= self.get_triangles()
-
-        triangles_binary_blob = triangles.flatten().tobytes()
-        points_binary_blob = points.tobytes()
-
-        gltf = pygltflib.GLTF2(
-            scene=0,
-            scenes=[pygltflib.Scene(nodes=[0])],
-            nodes=[pygltflib.Node(mesh=0)],
-            meshes=[
-                pygltflib.Mesh(
-                    primitives=[
-                        pygltflib.Primitive(
-                            attributes=pygltflib.Attributes(POSITION=1), indices=0
-                        )
-                    ]
-                )
-            ],
-            accessors=[
-                pygltflib.Accessor(
-                    bufferView=0,
-                    componentType=pygltflib.UNSIGNED_INT,
-                    count=triangles.size,
-                    type=pygltflib.SCALAR,
-                    max=[int(triangles.max())],
-                    min=[int(triangles.min())],
-                ),
-                pygltflib.Accessor(
-                    bufferView=1,
-                    componentType=pygltflib.FLOAT,
-                    count=len(points),
-                    type=pygltflib.VEC3,
-                    max=points.max(axis=0).tolist(),
-                    min=points.min(axis=0).tolist(),
-                ),
-            ],
-            bufferViews=[
-                pygltflib.BufferView(
-                    buffer=0,
-                    byteLength=len(triangles_binary_blob),
-                    target=pygltflib.ELEMENT_ARRAY_BUFFER,
-                ),
-                pygltflib.BufferView(
-                    buffer=0,
-                    byteOffset=len(triangles_binary_blob),
-                    byteLength=len(points_binary_blob),
-                    target=pygltflib.ARRAY_BUFFER,
-                ),
-            ],
-            buffers=[
-                pygltflib.Buffer(
-                    byteLength=len(triangles_binary_blob) + len(points_binary_blob)
-                )
-            ],
-        )
-        gltf.set_binary_blob(triangles_binary_blob + points_binary_blob)
-
-        dlg=wx.FileDialog(None,_('Choose filename'),wildcard='binary gltf2 (*.glb)|*.glb|gltf2 (*.gltf)|*.gltf|All (*.*)|*.*',style=wx.FD_SAVE)
-        ret=dlg.ShowModal()
-        if ret==wx.ID_CANCEL:
-            dlg.Destroy()
-            return
-
-        fn=dlg.GetPath()
-        dlg.Destroy()
-
-        gltf.save(fn)
-
-    def get_xy_z_for_griddata(self):
-
-        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():
-
-    def __init__(self, banks:Zones, cs, ds=1.) -> None:
-
-        self.mybanks = [curv for curzone in banks.myzones for curv in curzone.myvectors]
-        cs.set_zones()
-        self.mycs = cs.myzones
-
-        self.myinterp=[]
-
-        zonecs:zone
-        zonecs = self.mycs.myzones[0]
-
-        if zonecs.myvectors[0].up is not None:
-
-            cs1=cs.get_upstream()['cs']
-
-            while cs1.down is not cs1:
-                cs2=cs1.down
-
-                print('{} - {}'.format(cs1.myname,cs2.myname))
-
-                myinterp=Interpolator(cs1,cs2,self.mybanks,ds)
-                self.myinterp.append(myinterp)
-                cs1=cs2
-        else:
-            for i in range(zonecs.nbvectors-1):
-                cs1=zonecs.myvectors[i]
-                cs2=zonecs.myvectors[i+1]
-
-                print('{} - {}'.format(cs1.myname,cs2.myname))
-                myinterp=Interpolator(cs1,cs2,self.mybanks,ds)
-                self.myinterp.append(myinterp)
-
-        self.myzones= self.mycs.add_interpolators(self)
-
-    def viewer_interpolator(self):
-
-        xyz=[]
-        for curinterp in self.myinterp:
-            xyz.append(curinterp.get_xyz_for_viewer())
-
-        xyz=np.concatenate(xyz)
-
-        myviewer(xyz,0)
-
-    def interp_on_array(self,myarray,method):
-
-        xy=[]
-        z=[]
-        for curint in self.myinterp:
-            tmpxy,tmpz = curint.get_xy_z_for_griddata()
-            xy.append(tmpxy)
-            z.append(tmpz)
-
-        xy = np.concatenate(xy)
-        z = np.concatenate(z)
-
-        myarray.interpolate_on_cloud(xy,z,method)