wolfhece 2.1.127__py3-none-any.whl → 2.1.128__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -25,6 +25,9 @@ from scipy.interpolate import interp1d
 import matplotlib.pyplot as plt
 from matplotlib.axes import Axes
 from matplotlib.figure import Figure
+from matplotlib import cm
+from matplotlib.colors import Colormap
+
 import struct
 import pyvista as pv
 from typing import Union, Literal
@@ -36,7 +39,7 @@ import io
 from typing import Union, Literal
 from pathlib import Path
 import triangle
-
+from concurrent.futures import ThreadPoolExecutor, wait
 
 
 from .wolf_texture import genericImagetexture
@@ -47,6 +50,7 @@ from .PyParams import Wolf_Param, Type_Param, new_json
 from .wolf_texture import Text_Image_Texture,Text_Infos
 from .drawing_obj import Element_To_Draw
 from .matplotlib_fig import Matplotlib_Figure as MplFig
+from .PyPalette import wolfpalette
 
 class Triangulation(Element_To_Draw):
     def __init__(self, fn='', pts=[], tri=[], idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
@@ -581,12 +585,53 @@ class vectorproperties:
 
             self.used=True
 
+        self._values = {}
+
         # FIXME : to be changed
         # if self.parent is not None:
         #     self.closed = self.parent.closed
 
         self.init_extra()
 
+    def __getitem__(self, key:str) -> Union[int,float,bool,str]:
+        """ Get a value """
+        if key in self._values:
+            return self._values[key]
+        else:
+            return None
+
+    def __setitem__(self, key:str, value:Union[int,float,bool,str]):
+        """ Set a value """
+        self._values[key] = value
+
+    def set_color_from_value(self, key:str, cmap:wolfpalette | str | Colormap | cm.ScalarMappable, vmin:float= 0., vmax:float= 1.):
+        """ Set the color from a value """
+
+        if key in self._values:
+            val = self._values[key]
+
+            # Test if val is a numeric value or can be converted to a numeric value
+            try:
+                val = float(val)
+            except:
+                logging.warning('Value {} is not a numeric value'.format(val))
+                self.color = 0
+                return
+
+            val_adim = (val-vmin)/(vmax-vmin)
+
+            if isinstance(cmap, wolfpalette):
+                self.color = getIfromRGB(cmap.get_rgba_oneval(val))
+            elif isinstance(cmap, str):
+                cmap = cm.get_cmap(cmap)
+                self.color = getIfromRGB(cmap(val_adim, bytes=True))
+            elif isinstance(cmap, Colormap):
+                self.color = getIfromRGB(cmap(val_adim, bytes=True))
+            elif isinstance(cmap, cm.ScalarMappable):
+                self.color = getIfromRGB(cmap.to_rgba(val, bytes=True)[:3])
+        else:
+            self.color = 0
+
     def init_extra(self):
         """
         Init extra properties --> not compatible with VB6, Fortran codes
@@ -1124,8 +1169,8 @@ class vector:
         self._rotation_center = None
         self._rotation_step = None
 
-        self.linestring = None
-        self.polygon = None
+        self._linestring = None
+        self._polygon = None
 
         # Utile surtout pour les sections en travers
         self.zdatum = 0.
@@ -1139,6 +1184,56 @@ class vector:
         if fromnumpy is not None:
             self.add_vertices_from_array(fromnumpy)
 
+    def add_value(self, key:str, value:Union[int,float,bool,str]):
+        """ Add a value to the properties """
+        self.myprop[key] = value
+
+    def get_value(self, key:str) -> Union[int,float,bool,str]:
+        """ Get a value from the properties """
+        return self.myprop[key]
+
+    def set_color_from_value(self, key:str, cmap:wolfpalette | Colormap | cm.ScalarMappable, vmin:float= 0., vmax:float= 1.):
+        """ Set the color from a value """
+        self.myprop.set_color_from_value(key, cmap, vmin, vmax)
+
+    def set_alpha(self, alpha:int):
+        """ Set the alpha value """
+        self.myprop.alpha = alpha
+        self.myprop.transparent = alpha != 0
+
+    def set_filled(self, filled:bool):
+        """ Set the filled value """
+        self.myprop.filled = filled
+
+    @property
+    def polygon(self) -> Polygon:
+        """ Return the polygon """
+
+        if self._polygon is None:
+            self.prepare_shapely(linestring=False)
+        return self._polygon
+
+    @property
+    def linestring(self) -> LineString:
+        """ Return the linestring """
+
+        if self._linestring is None:
+            self.prepare_shapely(polygon=False)
+        return self._linestring
+
+    def buffer(self, distance:float, resolution:int=16, inplace:bool=True) -> "vector":
+        """ Create a new vector buffered around the vector """
+
+        poly = self.polygon
+        buffered = poly.buffer(distance, resolution=resolution)
+
+        if inplace:
+            self.import_shapelyobj(buffered)
+            return self
+        else:
+            newvec = vector(fromshapely=buffered, name=self.myname)
+            return newvec
+
     def set_legend_text(self, text:str):
         """ Set the legend text """
 
@@ -1165,6 +1260,14 @@ class vector:
 
         self.myprop.update_myprops()
 
+    def set_legend_text_from_value(self, key:str, visible:bool=True):
+        """ Set the legend text from a value """
+
+        if key in self.myprop._values:
+            self.myprop.legendtext = str(self.myprop._values[key])
+            self.myprop.legendvisible = visible
+            self.myprop.update_myprops()
+
     def set_legend_position(self, x:str | float, y:str | float):
         """ Set the legend position """
 
@@ -1392,14 +1495,16 @@ class vector:
     def import_shapelyobj(self, obj):
         """ Importation d'un objet shapely """
 
+        self.myvertices = []
         if isinstance(obj, LineString):
-            xy = np.array(obj.xy).T
-            self.is2D =  xy.shape[1]==2
-            self.add_vertices_from_array(xy)
+            self.is2D = not obj.has_z
+            xyz = np.array(obj.coords)
+            self.add_vertices_from_array(xyz)
+
         elif isinstance(obj, Polygon):
-            xy = np.array(obj.exterior.xy).T
-            self.is2D =  xy.shape[1]==2
-            self.add_vertices_from_array(xy)
+            self.is2D = not obj.has_z
+            xyz = np.array(obj.exterior.coords)
+            self.add_vertices_from_array(xyz)
             self.close_force()
         else:
             logging.warning(_('Object type {} not supported -- Update "import_shapelyobj"').format(type(obj)))
@@ -1513,7 +1618,7 @@ class vector:
         if self.nbvertices==0:
             return False
 
-        poly = self.asshapely_pol()
+        poly = self.polygon
         inside2 = poly.contains(Point([x,y]))
         return inside2
 
@@ -1580,7 +1685,7 @@ class vector:
             xyz[:,2]+=self.zdatum
         return xyz
 
-    def prepare_shapely(self, prepare_shapely:bool = True):
+    def prepare_shapely(self, prepare_shapely:bool = True, linestring:bool = True, polygon:bool = True):
         """
         Conversion Linestring Shapely et rétention de l'objet afin d'éviter de multiples appel
         par ex. dans une boucle.
@@ -1588,17 +1693,23 @@ class vector:
         :param prepare_shapely: Préparation de l'objet Shapely pour une utilisation optimisée
                                 - True par défaut
                                 - see https://shapely.readthedocs.io/en/stable/reference/shapely.prepare.html
+        :param linestring: Préparation du linestring
+        :param polygon: Préparation du polygon
 
         """
 
         self.reset_linestring()
 
-        self.linestring = self.asshapely_ls()
-        self.polygon = self.asshapely_pol()
+        if linestring:
+            self._linestring = self.asshapely_ls()
+        if polygon:
+            self._polygon = self.asshapely_pol()
 
         if prepare_shapely:
-            prepare(self.linestring)
-            prepare(self.polygon)
+            if linestring:
+                prepare(self._linestring)
+            if polygon:
+                prepare(self._polygon)
 
 
     def projectontrace(self, trace):
@@ -1663,6 +1774,8 @@ class vector:
     def intersection(self, vec2:"vector" = None, eval_dist=False,norm=False, force_single=False):
         """
         Calcul de l'intersection avec un autre vecteur
+        Attention, le shapely du vecteur vec2 et self sont automatiquement préparés. Si modifié après intersection, il faut penser à les re-préparer
+        avec self.reset_linestring() ou self.prepare_shapely(). Dans le cas contraire, les anciens vecteurs préparés seront utilisés.
 
         Return :
          - le point d'intersection
@@ -1670,8 +1783,13 @@ class vector:
 
         Utilisation de Shapely
         """
-        ls1 = self.asshapely_ls() if self.linestring is None else self.linestring
-        ls2 = vec2.asshapely_ls() if vec2.linestring is None else vec2.linestring
+
+        # check if the vectors are closed
+        ls1 = self.linestring
+        ls2 = vec2.linestring
+        # ls1 = self.asshapely_ls() if self._linestring is None else self._linestring
+        # ls2 = vec2.asshapely_ls() if vec2._linestring is None else vec2._linestring
+
 
         myinter = ls1.intersection(ls2)
 
@@ -1702,15 +1820,15 @@ class vector:
     def reset_linestring(self):
         """Remise à zéro de l'objet Shapely"""
 
-        if self.linestring is not None:
-            if is_prepared(self.linestring):
-                destroy_prepared(self.linestring)
-            self.linestring=None
+        if self._linestring is not None:
+            if is_prepared(self._linestring):
+                destroy_prepared(self._linestring)
+            self._linestring=None
 
-        if self.polygon is not None:
-            if is_prepared(self.polygon):
-                destroy_prepared(self.polygon)
-            self.polygon=None
+        if self._polygon is not None:
+            if is_prepared(self._polygon):
+                destroy_prepared(self._polygon)
+            self._polygon=None
 
     def add_vertex(self,addedvert: Union[list[wolfvertex], wolfvertex]):
         """
@@ -1980,7 +2098,7 @@ class vector:
 
             if self.myprop.filled:
 
-                ls = self.asshapely_pol()
+                ls = self.polygon
 
                 if False:
 
@@ -2059,6 +2177,20 @@ class vector:
         else:
             self.textimage = None
 
+    def plot_legend_mpl(self, ax:plt.Axes):
+        """
+        Plot Legend on Matplotlib Axes
+        """
+
+        if self.myprop.legendvisible and self.myprop.used:
+
+            ax.text(self.myprop.legendx, self.myprop.legendy, self.myprop.legendtext,
+                    fontsize=self.myprop.legendfontsize,
+                    fontname=self.myprop.legendfontname,
+                    color=getRGBfromI(self.myprop.legendcolor),
+                    rotation=self.myprop.legendorientation,
+                    ha='center', va='center')
+
     def plot_image(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None):
         """ plot attached images """
 
@@ -2076,6 +2208,28 @@ class vector:
             else:
                 logging.warning(_('No image texture available for plot'))
 
+    def plot_matplotlib(self, ax:plt.Axes):
+        """
+        Plot Matplotlib
+        """
+
+        if self.myprop.used:
+
+            if self.myprop.filled:
+                rgb=getRGBfromI(self.myprop.color)
+                if self.myprop.transparent:
+                    ax.fill([curvert.x for curvert in self.myvertices], [curvert.y for curvert in self.myvertices], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.,self.myprop.alpha))
+                else:
+                    ax.fill([curvert.x for curvert in self.myvertices], [curvert.y for curvert in self.myvertices], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.))
+            else:
+                rgb=getRGBfromI(self.myprop.color)
+                if self.myprop.transparent:
+                    ax.plot([curvert.x for curvert in self.myvertices], [curvert.y for curvert in self.myvertices], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.,self.myprop.alpha), linewidth=self.myprop.width)
+                else:
+                    ax.plot([curvert.x for curvert in self.myvertices], [curvert.y for curvert in self.myvertices], color=(rgb[0]/255.,rgb[1]/255.,rgb[2]/255.), linewidth=self.myprop.width)
+
+            self.plot_legend_mpl(ax)
+
     def _get_textfont(self):
         """ Retunr a 'Text_Infos' instance for the legend """
 
@@ -2177,7 +2331,7 @@ class vector:
         while k<self.nbvertices:
             self.myvertices.pop(k)
 
-        if self.linestring is not None or self.polygon is not None:
+        if self._linestring is not None or self._polygon is not None:
             self.prepare_shapely()
 
         self._reset_listogl()
@@ -2783,6 +2937,11 @@ class vector:
             copied_vector = vector(name=name)
 
         copied_vector.myvertices = copy.deepcopy(self.myvertices)
+        # FIXME : deepcopy of properties is not working
+        # copied_vector.myprop = copy.deepcopy(self.myprop)
+        copied_vector.zdatum = self.zdatum
+        copied_vector.closed = self.closed
+        copied_vector.add_zdatum = self.add_zdatum
 
         return copied_vector
 
@@ -2793,19 +2952,35 @@ class vector:
 
         return self.deepcopy_vector(name, parentzone)
 
+    @property
+    def centroid(self):
+        """
+        Return the centroid of the vector
+        """
+
+        return self.polygon.centroid
+
     def set_legend_to_centroid(self, text:str='', visible:bool=True):
         """
         Positionne la légende au centre du vecteur
         """
         self.myprop.legendvisible = visible
 
-        ls = self.asshapely_pol()
-        centroid = ls.centroid
+        centroid = self.centroid
 
         self.myprop.legendx = centroid.x
         self.myprop.legendy = centroid.y
         self.myprop.legendtext = text if text else self.myname
 
+    def set_legend_position_to_centroid(self):
+        """
+        Positionne la légende au centre du vecteur
+        """
+
+        centroid = self.centroid
+        self.myprop.legendx = centroid.x
+        self.myprop.legendy = centroid.y
+
     def set_z(self, new_z:np.ndarray):
         """ Set the z values of the vertices """
         self.z = new_z
@@ -3111,7 +3286,6 @@ class vector:
         if self.parentzone is not None:
             self.parentzone.reset_listogl()
 
-
     def select_points_inside(self, xy:cloud_vertices | np.ndarray):
         """ Select the points inside a polygon
 
@@ -3119,7 +3293,7 @@ class vector:
         :return: list of boolean
         """
 
-        self.prepare_shapely()
+        self.prepare_shapely(True)
 
         if isinstance(xy, cloud_vertices):
             xy = xy.get_xyz()[:,0:2]
@@ -3176,7 +3350,7 @@ class vector:
         """
 
         if self.closed:
-            return self.asshapely_pol().area
+            return self.polygon.area
         else:
             return 0.
 
@@ -3266,6 +3440,62 @@ class zone:
             # Object can be created from a shapely object
             self.import_shapelyobj(fromshapely)
 
+    def add_values(self, key:str, values:np.ndarray):
+        """ add values to the zone """
+
+        if self.nbvectors != values.shape[0]:
+            logging.warning(_('Number of vectors and values do not match'))
+            return
+
+        for curvec, curval in zip(self.myvectors, values):
+            curvec.add_value(key, curval)
+
+    def get_values(self, key:str) -> np.ndarray:
+        """ get values from the zone """
+
+        return np.array([curvec.get_value(key) for curvec in self.myvectors])
+
+    def set_colors_from_value(self, key:str, cmap:wolfpalette | Colormap | cm.ScalarMappable, vmin:float= 0., vmax:float= 1.):
+        """ Set the colors for the zone """
+
+        for curvec in self.myvectors:
+            curvec.set_color_from_value(key, cmap, vmin, vmax)
+
+    def set_alpha(self, alpha:int):
+        """ Set the alpha for the zone """
+
+        for curvec in self.myvectors:
+            curvec.set_alpha(alpha)
+
+    def set_filled(self, filled:bool):
+        """ Set the filled for the zone """
+
+        for curvec in self.myvectors:
+            curvec.set_filled(filled)
+
+    def check_if_open(self):
+        """ Check if the vectors in the zone are open """
+        for curvec in self.myvectors:
+            curvec.check_if_open()
+
+    def buffer(self, distance:float, resolution:int=16, inplace:bool = False) -> 'zone':
+        """ Create a new zone with a buffer around each vector """
+
+        if inplace:
+            newzone = self
+        else:
+            newzone = zone(name=self.myname)
+
+        retmap = list(map(lambda x: x.buffer(distance, resolution, inplace), self.myvectors))
+
+        if inplace:
+            return self
+
+        for curvec in retmap:
+            newzone.add_vector(curvec, forceparent=True)
+
+        return newzone
+
     def set_legend_text(self, text:str):
         """
         Set the legend text for the zone
@@ -3274,6 +3504,14 @@ class zone:
         for curvect in self.myvectors:
             curvect.set_legend_text(text)
 
+    def set_legend_text_from_values(self, key:str):
+        """
+        Set the legend text for the zone from a value
+        """
+
+        for curvect in self.myvectors:
+            curvect.set_legend_text_from_value(key)
+
     def set_legend_position(self, x, y):
         """
         Set the legend position for the zone
@@ -3285,7 +3523,12 @@ class zone:
     @property
     def area(self):
         """ Compute the area of the zone """
-        return sum([curvec.surface for curvec in self.myvectors])
+        return sum(self.areas)
+
+    @property
+    def areas(self):
+        """ List of all areas """
+        return [curvec.surface for curvec in self.myvectors]
 
     def set_cache(self):
         """
@@ -3644,6 +3887,16 @@ class zone:
             for curvect in self.myvectors:
                 curvect.plot_image(sx, sy, xmin, ymin, xmax, ymax, size)
 
+    def plot_matplotlib(self, ax:plt.Axes):
+        """
+        Plot the zone using matplotlib
+
+        :param ax: matplotlib Axes
+        :param kwargs: additional arguments
+        """
+
+        for curvect in self.myvectors:
+            curvect.plot_matplotlib(ax)
 
     def select_vectors_from_point(self,x:float,y:float,inside=True):
         """
@@ -5294,11 +5547,11 @@ class zone:
 
     def set_legend_to_centroid(self):
         """
-        Set the legend to the centroid of the zone
+        Set the legend to the centroid of the vectors
         """
 
         for curvec in self.myvectors:
-            curvec.set_legend_to_centroid()
+            curvec.set_legend_position_to_centroid()
 
 class Zones(wx.Frame, Element_To_Draw):
     """
@@ -5413,24 +5666,29 @@ class Zones(wx.Frame, Element_To_Draw):
         self._rotation_center = None
         self._rotation_step = None
 
+        only_firstlast = False # By default, we are using all vertices
         if self.filename!='':
             # lecture du fichier
 
             if self.filename.endswith('.dxf'):
                 self.is2D=False
                 self.import_dxf(self.filename)
+                only_firstlast = True # We limit the number of vertices to the first and last ones to accelerate the process
 
             elif self.filename.endswith('.shp'):
                 self.is2D=False
                 self.import_shapefile(self.filename, bbox=bbox)
+                only_firstlast = True # We limit the number of vertices to the first and last ones to accelerate the process
 
             elif self.filename.endswith('.gpkg'):
                 self.is2D=False
                 self.import_gpkg(self.filename, bbox=bbox)
+                only_firstlast = True # We limit the number of vertices to the first and last ones to accelerate the process
 
             elif Path(filename).is_dir() and self.filename.endswith('.gdb'):
                 self.is2D=False
                 self.import_gdb(self.filename, bbox=bbox)
+                only_firstlast = True # We limit the number of vertices to the first and last ones to accelerate the process
 
             elif self.filename.endswith('.vec') or self.filename.endswith('.vecz'):
 
@@ -5476,13 +5734,149 @@ class Zones(wx.Frame, Element_To_Draw):
                         logging.warning(_('Error while reading extra properties of {}'.format(self.filename)))
 
             if find_minmax:
-                self.find_minmax(True)
+                logging.info(_('Finding min and max values'))
+                self.find_minmax(True, only_firstlast)
 
         if colors is not None:
             self.colorize_data(colors, filled=True)
 
         if plotted and self.has_OGLContext and not self.shared:
+            logging.info(_('Preparing OpenGL lists'))
             self.prep_listogl()
+            logging.info(_('OpenGL lists ready'))
+
+    @property
+    def mynames(self) -> list[str]:
+        """ Return the names of all zones """
+
+        return [curzone.myname for curzone in self.myzones]
+
+    def add_values(self, key:str, values:np.ndarray | dict):
+        """
+        Add values to the zones
+        """
+
+        if isinstance(values, dict):
+            for k, val in values.items():
+                if not isinstance(val, np.ndarray):
+                    val = np.asarray(val)
+
+                if k in self.mynames:
+                    self[k].add_values(key, val)
+
+        elif isinstance(values, np.ndarray):
+            if values.shape[0] != self.nbzones:
+                logging.warning(_('Number of values does not match the number of zones'))
+                return
+
+            for idx, curzone in enumerate(self.myzones):
+                curzone.add_values(key, values[idx])
+
+    def get_values(self, key:str) -> np.ndarray:
+        """
+        Get values from the zones
+        """
+
+        return np.asarray([curzone.get_values(key) for curzone in self.myzones])
+
+    def set_colors_from_value(self, key:str, cmap:wolfpalette | str | Colormap | cm.ScalarMappable, vmin:float = 0., vmax:float = 1.):
+        """
+        Set colors to the zones
+        """
+
+        if isinstance(cmap, str):
+            cmap = cm.get_cmap(cmap)
+
+        for curzone in self.myzones:
+            curzone.set_colors_from_value(key, cmap, vmin, vmax)
+
+    def set_alpha(self, alpha:int):
+        """
+        Set alpha to the zones
+        """
+
+        for curzone in self.myzones:
+            curzone.set_alpha(alpha)
+
+    def set_filled(self, filled:bool):
+        """
+        Set filled to the zones
+        """
+
+        for curzone in self.myzones:
+            curzone.set_filled(filled)
+
+    def check_if_open(self):
+        """ Check if the vectors in the zone are open """
+        for curzone in self.myzones:
+            curzone.check_if_open()
+
+    def concatenate_all_vectors(self) -> list[vector]:
+        """ Concatenate all vectors in the zones """
+        ret = []
+        for curzone in self.myzones:
+            ret.extend(curzone.myvectors)
+        return ret
+
+    def prepare_shapely(self):
+        """ Prepare shapely objects for all vectors in zones """
+        allvec = self.concatenate_all_vectors()
+        list(map(lambda x: x.prepare_shapely(True), allvec))
+
+    def filter_contains(self, others:list[vector]) -> "Zones":
+        """ Create a new "Zones" instance with
+        vectors in 'others' contained in the zones """
+
+        if isinstance(others, Zones):
+            allvec = others.concatenate_all_vectors()
+        elif isinstance(others, list):
+            allvec = others
+        else:
+            logging.warning(_('Unknown type for others'))
+            return None
+
+        centroids = [curvec.centroid for curvec in allvec]
+        newzones = Zones()
+
+        for curzone in self.myzones:
+            if curzone.nbvectors != 1:
+                logging.warning(_('Zone {} has more than one vector'.format(curzone.myname)))
+                continue
+
+            poly = curzone[0].polygon
+            # element-wise comparison
+            contains = list(map(lambda x: poly.contains(x), centroids))
+
+            newzone = zone(name=curzone.myname, parent=newzones)
+            newzone.myvectors = list(map(lambda x: allvec[x], np.where(contains)[0]))
+            newzones.add_zone(newzone, forceparent=True)
+
+        return newzones
+
+    @property
+    def areas(self):
+        """ List of areas of all zones """
+
+        return [curzone.areas for curzone in self.myzones]
+
+    def buffer(self, distance:float, resolution:int = 16, inplace:bool = True):
+        """ Buffer all zones """
+
+        if inplace:
+            newzones = self
+        else:
+            newzones = Zones()
+
+        retmap = list(map(lambda x: x.buffer(distance, resolution, inplace=inplace), self.myzones))
+
+        for curzone in retmap:
+            newzones.add_zone(curzone, forceparent=True)
+
+        newzones.find_minmax(True)
+        if inplace:
+            return self
+
+        return newzones
 
     def set_cache(self):
         """ Set cache for all zones """
@@ -5571,6 +5965,22 @@ class Zones(wx.Frame, Element_To_Draw):
         for curzone in self.myzones:
             curzone.set_legend_text(text)
 
+    def set_legend_text_from_values(self, key:str):
+        """
+        Set the legend text for the zones from the values
+        """
+
+        for curzone in self.myzones:
+            curzone.set_legend_text_from_values(key)
+
+    def set_legend_to_centroid(self):
+        """
+        Set the legend to the centroid of the zones
+        """
+
+        for curzone in self.myzones:
+            curzone.set_legend_to_centroid()
+
     def set_legend_position(self, x, y):
         """
         Set the legend position for the zones
@@ -5583,7 +5993,8 @@ class Zones(wx.Frame, Element_To_Draw):
     def nbzones(self):
         return len(self.myzones)
 
-    def import_shapefile(self, fn:str, bbox:Polygon = None):
+    def import_shapefile(self, fn:str,
+                         bbox:Polygon = None, colname:str = None):
         """
         Import shapefile by using geopandas
 
@@ -5591,41 +6002,69 @@ class Zones(wx.Frame, Element_To_Draw):
 
         """
 
+        logging.info(_('Importing shapefile {}'.format(fn)))
         content = gpd.read_file(fn, bbox=bbox)
 
-        for idx, row in content.iterrows():
-            if 'NAME' in row.keys():
+        self.import_GeoDataFrame(content, colname=colname)
+
+    def import_GeoDataFrame(self, content:gpd.GeoDataFrame,
+                            bbox:Polygon = None, colname:str = None):
+        """
+        Import a GeoDataFrame geopandas
+
+        Shapefile == 1 zone
+        """
+
+        logging.info(_('Importing GeoDataFrame'))
+
+        if bbox is not None:
+            # filter content
+            content = content.cx[bbox.bounds[0]:bbox.bounds[2], bbox.bounds[1]:bbox.bounds[3]]
+
+        logging.info(_('Converting DataFrame into zones'))
+        if colname is not None and colname not in content.columns:
+            logging.warning(_('Column {} not found in the DataFrame'.format(colname)))
+            logging.info(_('We are using the available known columns'))
+            colname = ''
+
+        def add_zone_from_row(row):
+            idx, row = row
+            keys = list(row.keys())
+            if colname in keys:
+                name = row[colname]
+            elif 'NAME' in keys:
                 name = row['NAME']
-            elif 'location' in row.keys():
+            elif 'location' in keys:
                 name = row['location'] # tuilage gdal
-            elif 'name' in row.keys():
+            elif 'Communes' in keys:
+                name = row['Communes']
+            elif 'name' in keys:
                 name = row['name']
-            elif 'MAJ_NIV3T' in row.keys():
+            elif 'MAJ_NIV3T' in keys:
                 # WALOUS
                 name = row['MAJ_NIV3T']
-            elif 'NATUR_DESC' in row.keys():
+            elif 'NATUR_DESC' in keys:
                 name = row['NATUR_DESC']
+            elif 'mun_name_f' in keys:
+                name = row['mun_name_f'].replace('[','').replace(']','').replace("'",'')
+            elif 'mun_name_fr' in keys:
+                name = row['mun_name_fr']
             else:
                 name = str(idx)
 
             poly = row['geometry']
 
             newzone = zone(name=name, parent = self, fromshapely = poly)
-            self.add_zone(newzone)
-
-    def export_to_shapefile(self, filename:str):
-        """
-        Export to shapefile.
+            return newzone
 
-        The first vector of each zone will be exported.
+        self.myzones = list(map(add_zone_from_row, content.iterrows()))
 
-        If you want to export all vectors, you have to use "export_shape" of the zone object.
+        pass
 
-        FIXME: Add support of data fields
+    def export_GeoDataFrame(self) -> gpd.GeoDataFrame:
+        """
+        Export to a GeoDataFrame
         """
-
-        import geopandas as gpd
-
         names=[]
         geoms=[]
 
@@ -5642,9 +6081,9 @@ class Zones(wx.Frame, Element_To_Draw):
             for curvect in curzone.myvectors[:1]:
                 if curvect.is2D:
                     if curvect.closed:
-                        geoms.append(curvect.asshapely_pol())
+                        geoms.append(curvect.polygon)
                     else:
-                        geoms.append(curvect.asshapely_ls())
+                        geoms.append(curvect.polygon)
                 else:
                     if curvect.closed:
                         geoms.append(curvect.asshapely_pol3D())
@@ -5654,6 +6093,20 @@ class Zones(wx.Frame, Element_To_Draw):
         gdf = gpd.GeoDataFrame({'id':names,'geometry':geoms})
         gdf.crs = 'EPSG:31370'
 
+        return gdf
+
+    def export_to_shapefile(self, filename:str):
+        """
+        Export to shapefile.
+
+        The first vector of each zone will be exported.
+
+        If you want to export all vectors, you have to use "export_shape" of the zone object.
+
+        FIXME: Add support of data fields
+        """
+
+        gdf = self.export_GeoDataFrame()
         gdf.to_file(filename)
 
     def export_active_zone_to_shapefile(self, filename:str):
@@ -6070,10 +6523,14 @@ class Zones(wx.Frame, Element_To_Draw):
         :param only_firstlast : si True, ne prend en compte que le premier et le dernier vertex de chaque vecteur
         """
 
-        if update or self._first_find_minmax:
-            for zone in self.myzones:
-                zone.find_minmax(update or self._first_find_minmax, only_firstlast)
-            self._first_find_minmax = False
+        if self.nbzones > 100:
+            with ThreadPoolExecutor() as executor:
+                # zone.find_minmax(update or self._first_find_minmax, only_firstlast)
+                futures = [executor.submit(zone.find_minmax, update or self._first_find_minmax, only_firstlast) for zone in self.myzones]
+                wait(futures)
+        else:
+            for curzone in self.myzones:
+                curzone.find_minmax(update or self._first_find_minmax, only_firstlast)
 
         if self.nbzones > 0:
 
@@ -6100,6 +6557,12 @@ class Zones(wx.Frame, Element_To_Draw):
         for curzone in self.myzones:
             curzone.plot(sx=sx, sy=sy, xmin=xmin, ymin=ymin, xmax=xmax, ymax=ymax, size=size)
 
+    def plot_matplotlib(self, ax:plt.Axes):
+        """ Plot with matplotlib """
+
+        for curzone in self.myzones:
+            curzone.plot_matplotlib(ax)
+
     def select_vectors_from_point(self, x:float, y:float, inside=True):
         """
         Sélection de vecteurs dans chaque zones sur base d'une coordonnée
@@ -8170,9 +8633,10 @@ class Zones(wx.Frame, Element_To_Draw):
         Zones (a new object).
         """
         copied_Zones = Zones(idx=name)
-        for zne in self.myzones:
-            new_zne = zne.deepcopy_zone(parent= copied_Zones)
-            copied_Zones.add_zone(new_zne,forceparent=True)
+        copied_Zones.myzones = list(map(lambda zne: zne.deepcopy_zone(parent= copied_Zones), self.myzones))
+        # for zne in self.myzones:
+        #     new_zne = zne.deepcopy_zone(parent= copied_Zones)
+        #     copied_Zones.add_zone(new_zne,forceparent=True)
         copied_Zones.find_minmax(True)
         return copied_Zones