wolfhece 2.1.99__py3-none-any.whl → 2.1.101__py3-none-any.whl

wolfhece/wolf_array.py

@@ -22,6 +22,7 @@ import logging
 import json
 import tempfile
 from pathlib import Path
+from tqdm import tqdm
 
 try:
     from OpenGL.GL import *
@@ -115,6 +116,7 @@ WOLF_ARRAY_CSR_DOUBLE = 5
 WOLF_ARRAY_FULL_INTEGER = 6
 WOLF_ARRAY_FULL_SINGLE_3D = 7
 WOLF_ARRAY_FULL_INTEGER8 = 8
+WOLF_ARRAY_FULL_UINTEGER8 = 88
 
 WOLF_ARRAY_MB_SINGLE = 3
 WOLF_ARRAY_MB_INTEGER = 9
@@ -277,7 +279,7 @@ class header_wolf():
         ret += _('Spatial extent : \n')
         ret += _('   - Origin : ({} ; {}) \n').format(self.origx, self.origy)
         ret += _('   - End : ({} ; {}) \n').format(self.origx + self.nbx * self.dx, self.origy +self.nby * self.dy)
-        ret += _('   - Widht x Height : {} x {} \n').format(self.nbx * self.dx, self.nby * self.dy)
+        ret += _('   - Width x Height : {} x {} \n').format(self.nbx * self.dx, self.nby * self.dy)
         ret += _('   - Translation : ({} ; {})\n').format(self.translx, self.transly)
         ret += _('Null value : {}\n\n'.format(self.nullvalue))
 
@@ -344,8 +346,8 @@ class header_wolf():
         """
         Return block header
 
-        :param key:int = block's index (0-based) or key (str)
-        :return : header_wolf instance if key is found, None otherwise
+        :param key: block's index (0-based) or key (str)
+        :return: header_wolf instance if key is found, None otherwise
         """
         if key is None:
             return self
@@ -364,7 +366,7 @@ class header_wolf():
         """
         Set block header
 
-        :param value = tuple (key, header_wolf)
+        :param value: tuple (key, header_wolf)
 
         'key' can be an int (0-based) or a str
         If str, please use getkeyblock function to generate the key
@@ -381,9 +383,9 @@ class header_wolf():
         """
         Set origin
 
-        :param x = origin along X
-        :param y = origin along Y
-        :param z = origin along Z
+        :param x: origin along X
+        :param y: origin along Y
+        :param z: origin along Z
         """
         self.origx = x
         self.origy = y
@@ -405,8 +407,8 @@ class header_wolf():
         """
         Return bounds in coordinates
 
-        :param abs = if True, add translation to (x, y) (coordinate to global space)
-        :return : tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax])
+        :param abs: if True, add translation to (x, y) (coordinate to global space)
+        :return: tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax])
         """
         if abs:
             return ([self.origx + self.translx, self.origx + self.translx + float(self.nbx) * self.dx],
@@ -421,7 +423,7 @@ class header_wolf():
 
         Firstly, get_bounds is called to get bounds in coordinates and then get_ij_from_xy is called to get bounds in indices.
 
-        :param abs = if True, add translation to (x, y) (coordinate to global space)
+        :param abs: if True, add translation to (x, y) (coordinate to global space)
         """
         mybounds = self.get_bounds(abs)
 
@@ -433,13 +435,13 @@ class header_wolf():
         """
         Get indices from coordinates
 
-        :param x = X coordinate
-        :param y = Y coordinate
-        :param z = Z coordinate (optional)
-        :param scale = scaling of the spatial resolution (dx,dy,[dz])
-        :param aswolf = if True, return if one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
-        :param abs = if True, remove translation from (x, y, [z]) (coordinate from global space)
-        :param forcedims2 = if True, force to return only 2 indices even if z is supplied
+        :param x: X coordinate
+        :param y: Y coordinate
+        :param z: Z coordinate (optional)
+        :param scale: scaling of the spatial resolution (dx,dy,[dz])
+        :param aswolf: if True, return if one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
+        :param abs: if True, remove translation from (x, y, [z]) (coordinate from global space)
+        :param forcedims2: if True, force to return only 2 indices even if z is supplied
         """
 
         locx = np.float64(x) - self.origx
@@ -475,7 +477,7 @@ class header_wolf():
         :param abs = if True, remove translation from (x, y, [z]) (coordinate from global space)
         :param forcedims2 = if True, force to return only 2 indices even if z is supplied
 
-        :return : numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)
+        :return: numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)
         """
 
         if isinstance(xy,tuple):
@@ -642,17 +644,17 @@ class header_wolf():
     def ij2xy_np(self, ij:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
         """ alias for get_xy_from_ij_array
 
-        :param ij = numpy array containing (i, j, [k]) indices
-        :param scale = scaling of the spatial resolution (dx,dy,[dz])
-        :param aswolf = if True, input is one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
-        :param abs = if True, add translation to results (x, y, [z]) (coordinate to global space)
+        :param ij: numpy array containing (i, j, [k]) indices
+        :param scale: scaling of the spatial resolution (dx,dy,[dz])
+        :param aswolf: if True, input is one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
+        :param abs: if True, add translation to results (x, y, [z]) (coordinate to global space)
 
         ..warning: 'ij' is not the result of np.where() but if you want to use np.where() you can use the following code:
         ```
         np.vstack((ij[0], ij[1])).T
         ```
 
-        :return : numpy array containing (x, y, [z]) coordinates - shape (n, 2) or (n, 3)
+        :return: numpy array containing (x, y, [z]) coordinates - shape (n, 2) or (n, 3)
         """
         return self.get_xy_from_ij_array(ij, scale, aswolf, abs)
 
@@ -664,11 +666,11 @@ class header_wolf():
         """
         alias for get_ij_from_xy_array
 
-        :param xy = numpy array containing (x, y, [z]) coordinates - shape (n, 2) or (n, 3)
-        :param scale = scaling of the spatial resolution (dx,dy,[dz])
-        :param aswolf = if True, return if one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
-        :param abs = if True, remove translation from (x, y, [z]) (coordinate from global space)
-        :param forcedims2 = if True, force to return only 2 indices even if z is supplied
+        :param xy: numpy array containing (x, y, [z]) coordinates - shape (n, 2) or (n, 3)
+        :param scale: scaling of the spatial resolution (dx,dy,[dz])
+        :param aswolf: if True, return if one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
+        :param abs: if True, remove translation from (x, y, [z]) (coordinate from global space)
+        :param forcedims2: if True, force to return only 2 indices even if z is supplied
 
         :return : numpy array containing (i, j, [k]) indices - shape (n, 2) or (n, 3)
         """
@@ -689,8 +691,8 @@ class header_wolf():
         """
         Find the intersection of two header
 
-        @arg other: other header
-        @arg ij: if True, return indices instead of coordinates
+        :param other: other header
+        :param ij: if True, return indices instead of coordinates
 
         :return: None or tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax]) or indices in each header (if ij=True) [[imin1, imax1], [jmin1, jmax1]], [[imin2, imax2], [jmin2, jmax2]]
         """
@@ -759,7 +761,7 @@ class header_wolf():
         """
         Read informations from header .txt
 
-        :param filename : path and filename of the basefile
+        :param filename: path and filename of the basefile
 
         If filename is a Path object, it is converted to a string
         If filename ends with '.tif', nothing is done because infos are in the .tif file
@@ -866,7 +868,7 @@ class header_wolf():
             elif dtype == np.int16:
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER16
             elif dtype == np.uint8:
-                self.wolftype = WOLF_ARRAY_FULL_INTEGER8
+                self.wolftype = WOLF_ARRAY_FULL_UINTEGER8
             elif dtype == np.int8:
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER8
             else:
@@ -994,12 +996,14 @@ class header_wolf():
 
         Nullvalue is not written
 
-        :param filename : path and filename with '.txt' extension, which will NOT be automatically added
-        :param wolftype : type of the WOLF_ARRAY_* array
-        :param forceupdate : if True, the file is rewritten even if it already exists
+        :param filename: path and filename with '.txt' extension, which will NOT be automatically added
+        :param wolftype: type of the WOLF_ARRAY_* array
+        :param forceupdate: if True, the file is rewritten even if it already exists
         """
 
-        assert wolftype in [WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_SYM_DOUBLE, WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_SINGLE_3D, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MNAP_INTEGER, WOLF_ARRAY_FULL_INTEGER16_2], _('The type of array is not correct')
+        assert wolftype in [WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_SYM_DOUBLE, WOLF_ARRAY_FULL_LOGICAL,
+                            WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_SINGLE_3D, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_UINTEGER8,
+                            WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MNAP_INTEGER, WOLF_ARRAY_FULL_INTEGER16_2], _('The type of array is not correct')
 
         if not os.path.exists(filename) or forceupdate:
             with open(filename,'w') as f:
@@ -1035,8 +1039,8 @@ class header_wolf():
         """
         Comparison of two headers
 
-        :param other : other header to compare
-        :param check_mb : if True, the comparison is done on the blocks too
+        :param other: other header to compare
+        :param check_mb: if True, the comparison is done on the blocks too
 
         The nullvalue is not taken into account
         """
@@ -1173,8 +1177,9 @@ class header_wolf():
         """
         Return the coordinates of the cells in the footprint of a vector
 
-        :param myvect = target vector
+        :param myvect: target vector
         :return: tuple of two numpy arrays - (coordinates, indices)
+        :param eps: epsilon to avoid rounding errors
 
         """
 
@@ -1190,8 +1195,9 @@ class header_wolf():
         """
         Return the indices of the cells in the footprint of a vector
 
-        :param myvect = target vector
-        :return : numpy array of indices
+        :param myvect: target vector
+        :return: numpy array of indices
+        :param eps: epsilon to avoid rounding errors
         """
 
         if isinstance(myvect, Polygon):
@@ -1219,7 +1225,7 @@ class header_wolf():
         """
         Convert XY coordinates to IJ indices **(0-based)** with Numpy without any check/options
 
-        :param xy = numpy array of shape (n,2) with XY coordinates
+        :param xy: = numpy array of shape (n,2) with XY coordinates
 
         """
 
@@ -1230,7 +1236,7 @@ class header_wolf():
         """
         Convert IJ indices **(0-based)** to XY coordinates with Numpy without any check/options
 
-        :param ij = numpy array of shape (n,2) with IJ indices
+        :param ij: = numpy array of shape (n,2) with IJ indices
 
         """
 
@@ -1683,11 +1689,11 @@ class Ops_Array(wx.Frame):
 
             self.m_button7 = wx.Button(self.Interpolation, wx.ID_ANY, _("Stage/Volume/Surface evaluation"), wx.DefaultPosition,
                                     wx.DefaultSize, 0)
-            self.m_button7.SetToolTip(_('Evaluate stage-volume-surface relationship. \n Results : plots and arrays saved on disk'))
+            self.m_button7.SetToolTip(_('Evaluate stage-volume-surface relationship.\nResults : csv and array saved on disk\n\n CAUTION : This function will be applied only on the selected area except if you select "all".\nIn the latter case, the computation time could be long if the array are very large.'))
 
             if self.parentarray.nb_blocks>0:
                 self.m_button7.Disable()
-                self.m_button7.SetToolTip(_('Evaluate stage-volume-surface relationship. \n Results : plots and arrays saved on disk\n\nThis function is not available for multi-block arrays.'))
+                self.m_button7.SetToolTip(_('Evaluate stage-volume-surface relationship.\nResults : arrays and csv file saved on disk\n\nThis function is not available for multi-block arrays.'))
 
             gSizer1.Add(self.m_button7, 0, wx.EXPAND)
             self.m_button7.Bind(wx.EVT_BUTTON, self.volumesurface)
@@ -4462,8 +4468,10 @@ class SelectionData():
         if self.nb == 0:
             return None
 
-        newarray = WolfArray()
+        if self.myselection == 'all':
+            return WolfArray(mold=self.parent)
 
+        newarray = WolfArray()
         lochead = self._get_header()
         if lochead is None:
             logging.error(_('Error in get_newarray !'))
@@ -4586,33 +4594,35 @@ class SelectionData():
 
                 if self.nb == 0 or self.myselection == 'all':
                     myarray = array1
-                    axs = myarray.volume_estimation()
+                    fig, axs = myarray.volume_estimation()
 
                     myarray = array2
-                    axs = myarray.volume_estimation(axs)
+                    fig, axs = myarray.volume_estimation(axs)
                 else:
                     myarray = array1.mngselection.get_newarray()
-                    axs = myarray.volume_estimation()
+                    fig, axs = myarray.volume_estimation()
 
                     myarray = array2.mngselection.get_newarray()
-                    axs = myarray.volume_estimation(axs)
+                    fig, axs = myarray.volume_estimation(axs)
             else:
                 if len(self.parent.mngselection.myselection) == 0 or self.parent.mngselection.myselection == 'all':
                     myarray = self.parent
                 else:
                     myarray = self.parent.mngselection.get_newarray()
+                    myarray.SelectionData.selections = self.parent.mngselection.selections.copy()
 
-                myarray.volume_estimation()
+                fig, axs = myarray.volume_estimation()
         else:
             if self.nb == 0 or self.myselection == 'all':
                 myarray = self.parent
             else:
                 myarray = self.get_newarray()
+                myarray.SelectionData.selections = self.selections.copy()
 
-            myarray.volume_estimation()
+            fig, axs = myarray.volume_estimation()
 
         if show:
-            plt.show()
+            fig.show()
 
 class SelectionDataMB(SelectionData):
     """ Extension of SelectionData to manage multiple blocks """
@@ -4875,6 +4885,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                  plotted:bool       = False,
                  need_for_wx:bool   = False,
                  mask_source:np.ndarray = None,
+                 np_source:np.ndarray = None,
                  ) -> None:
         """
         Constructor of the WolfArray class
@@ -4893,6 +4904,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param plotted: True = will be plotted if required by the mapviewer
         :param need_for_wx: True = a wxApp is required (if no application is underway --> Error)
         :param mask_source: mask to link to the data
+        :param np_source: numpy array to link to the data
 
         """
         try:
@@ -4980,7 +4992,16 @@ class WolfArray(Element_To_Draw, header_wolf):
             if self.nb_blocks>0:
                 self.myblocks = {}
 
-            self.allocate_ressources()
+            if np_source is None:
+                self.allocate_ressources()
+            else:
+                assert np_source.shape == (self.nbx, self.nby), _('Shape of np_source is not compatible with header')
+
+                if self.dtype != np_source.dtype:
+                    logging.warning(_('dtype of np_source is not compatible with header -- Conversion will be done'))
+                    np_source = np_source.astype(self.dtype)
+
+                self.array = ma.MaskedArray(np_source, mask= np_source[:,:] == self.nullvalue, copy=False, order='C')
 
             # # FIXME Why not initialize with nullvalue ?
             # self.array = ma.MaskedArray(np.ones((self.nbx, self.nby), order='F', dtype=self.dtype))
@@ -5052,6 +5073,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 self.init_from_new(new)
 
+
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
     def set_opacity(self, alpha:float):
@@ -5092,7 +5114,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             return size * 4
         elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
             return size * 2
-        elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
+        elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_UINTEGER8]:
             return size
         else:
             return size * 4
@@ -5353,6 +5375,8 @@ class WolfArray(Element_To_Draw, header_wolf):
             dtype = np.int16
         elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
             dtype = np.int8
+        elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+            dtype = np.uint8
         elif self.wolftype == WOLF_ARRAY_FULL_LOGICAL:
             dtype = np.int16
 
@@ -5372,6 +5396,8 @@ class WolfArray(Element_To_Draw, header_wolf):
             dtype = gdal.GDT_Int16
         elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
             dtype = gdal.GDT_Byte
+        elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+            dtype = gdal.GDT_Byte
         elif self.wolftype == WOLF_ARRAY_FULL_LOGICAL:
             dtype = gdal.GDT_Int16
 
@@ -5402,6 +5428,8 @@ class WolfArray(Element_To_Draw, header_wolf):
             dtype = _('int16 - 2 bytes per values')
         elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
             dtype = _('int8 - 1 byte per values')
+        elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+            dtype = _('uint8 - 1 byte per values')
         elif self.wolftype == WOLF_ARRAY_FULL_LOGICAL:
             dtype = _('int16 - 2 bytes per values')
 
@@ -6060,7 +6088,7 @@ class WolfArray(Element_To_Draw, header_wolf):
           - uniquement dans les mailles sélectionnées si elles existent
           - dans les mailles contenues dans le polygone sinon
 
-        On utilise ensuite "griddata" pour interpoler les altitudes des mailles
+        On utilise ensuite "griddata" de Scipy pour interpoler les altitudes des mailles
         depuis les vertices 3D du polygone
         """
 
@@ -6123,17 +6151,27 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.array.data[allij[:, 0], allij[:, 1]] = newz
 
     def interpolate_on_polylines(self, working_zone:zone, usemask=True):
+        """ Interpolation sous toutes les polylignes d'une même zone """
 
         for curvec in working_zone.myvectors:
             self.interpolate_on_polyline(curvec, usemask)
 
 
-    def interpolate_on_cloud(self, xy:np.ndarray, z:np.ndarray, method='linear'):
+    def interpolate_on_cloud(self, xy:np.ndarray, z:np.ndarray, method:Literal['linear', 'nearest', 'cubic']= 'linear'):
         """
-        See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
+        Interpolation sur un nuage de points.
 
-            method == nearest, linear or cubic
+        L'interpolation a lieu :
+          - uniquement dans les mailles sélectionnées si elles existent
+          - dans les mailles contenues dans le polygone convexe contenant les points sinon
 
+        Using griddata from Scipy.
+
+        :param xy: numpy.array of vertices - shape (n,2)
+        :param z: numpy.array of values - shape (n,)
+        :param method: method for the interpolation -- 'nearest', 'linear' or 'cubic'
+
+        See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
         """
 
         if self.mngselection.myselection == [] or self.mngselection.myselection == 'all':
@@ -6157,18 +6195,36 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.reset_plot()
 
-    def interpolate_on_triangulation(self, coords, triangles, grid_x=None, grid_y = None, mask_tri=None, interp_method = 'matplotlib'):
-        import matplotlib.tri as mtri
+    def interpolate_on_triangulation(self, coords, triangles,
+                                     grid_x=None, grid_y = None,
+                                     mask_tri=None, interp_method:Literal['matplotlib','scipy'] = 'matplotlib'):
         """
-        See : https://matplotlib.org/stable/gallery/images_contours_and_fields/triinterp_demo.html
+        Interpolation sur une triangulation.
 
-            method == linear
+        L'interpolation a lieu :
+          - uniquement dans les mailles sélectionnées si elles existent
+          - dans les mailles contenues dans la triangulation sinon
+
+        Matplotlib is used by default, but Scipy(griddata) can be used as well. If Matplotlib crashes, try with Scipy.
+        Matplotlib is more strict on the quality of the triangulation.
+
+        :param coords: numpy.array of vertices - shape (n,3)
+        :param triangles: numpy.array of triangles - shape (m,3)
+        :param grid_x: numpy.array of x values where the interpolation will be done -- if None, the grid is created from the array
+        :param grid_y: numpy.array of y values where the interpolation will be done -- if None, the grid is created from the array
+        :param mask_tri: numpy.array of mask for the triangles
+        :param interp_method: method for the interpolation -- 'matplotlib' or 'scipy'
+
+        For matplotlib algo, see : https://matplotlib.org/stable/gallery/images_contours_and_fields/triinterp_demo.html
+        For scipy algo, see : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
 
         """
 
 
         if interp_method =='matplotlib':
 
+            import matplotlib.tri as mtri
+
             use_scipy=False
 
             try:
@@ -6289,10 +6345,16 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.reset_plot()
         return
 
-    def import_from_gltf(self, fn:str='', fnpos:str='', interp_method:Literal['matplotlib','numpy'] = 'matplotlib'):
+    def import_from_gltf(self, fn:str='', fnpos:str='', interp_method:Literal['matplotlib','scipy'] = 'matplotlib'):
         """
-        interp_method == 'matplotlib' or 'griddata'
+        Import from GLTF/GLB format
+
+        :param fn: filename
+        :param fnpos: filename for the position's information
+        :param interp_method: method for the interpolation -- 'matplotlib' or 'scipy'
+
         """
+        #FIXME : add the possibility to use PyVista
 
         if fn == '' or fnpos == '':
             logging.info(_('Retry !! -- Bad files'))
@@ -6457,7 +6519,6 @@ class WolfArray(Element_To_Draw, header_wolf):
         triangles.append([[i + decal, i + decal + 1, i + decal + nby] for i in range(nby - 1)])
         triangles.append([[i + decal + nby, i + decal + 1, i + decal + nby + 1] for i in range(nby - 1)])
 
-        from tqdm import tqdm
         for k in tqdm(range(1, nbx - 1)):
             decal = k * nby
             triangles.append([[i + decal, i + decal + 1, i + decal + nby] for i in range(nby - 1)])
@@ -6497,7 +6558,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mylap
 
-    def volume_estimation(self, axs=None):
+    def volume_estimation(self, axs:plt.Axes= None):
         """ Estimation of the volume of the selected zone """
 
         vect = self.array[np.logical_not(self.array.mask)].flatten()
@@ -6527,58 +6588,125 @@ class WolfArray(Element_To_Draw, header_wolf):
         deltaz = (zmax - zmin) / nb
         curz = zmin
         nbgroupement = []
-        longueur = []
+        labeled_areas = []
         stockage = []
         z = []
 
-        dlg = wx.MessageDialog(None, _("Would you like to calculate relationships on the basis of the largest area ? \n if Yes, no guarantee on the volume increase"), style = wx.YES_NO|wx.YES_DEFAULT)
+        methods = [_("All cells below the elevation (even if cells are disconnected)"),
+                     _("Only the largest connected area below the elevation (not necessarily the same for each elevation)"),
+                        _("Only the area below the elevation (if containing the cells stored in memory selection)")]
+
+        keys_select = list(self.SelectionData.selections.keys())
+        if len(keys_select) == 0:
+            methods = methods[:2]
+            use_memory = False
+
+        dlg = wx.SingleChoiceDialog(None, _("Choose a method for selecting the area to integrate"), _("Labeling?"), methods)
         ret = dlg.ShowModal()
-        if ret == wx.ID_YES:
-            labeled= True
-        dlg.Destroy()
+
+        if ret == wx.ID_CANCEL:
+            dlg.Destroy()
+            return
+
+        if dlg.GetSelection() == 0:
+            labeled = False
+        else:
+            labeled = True
+            if dlg.GetSelection() == 1:
+                use_memory = False
+            else:
+                if len(keys_select) >1:
+                    dlg = wx.SingleChoiceDialog(None, _("Choose a memory selection"), _("Memory selection?"), keys_select)
+                    ret = dlg.ShowModal()
+
+                    if ret == wx.ID_CANCEL:
+                        dlg.Destroy()
+                        return
+
+                    key = keys_select[dlg.GetSelection()]
+                else:
+                    key = keys_select[0]
+
+                xy_key = self.SelectionData.selections[key]['select']
+                if len(xy_key) == 0:
+                    logging.error(_('Empty selection'))
+                    return
+
+                ij_key = self.xy2ij_np(xy_key)
+
+                use_memory = True
 
         extensionmax = WolfArray(mold=self)
         extensionmax.array[:, :] = 0.
 
         if labeled:
-            for i in range(nb + 1):
-                logging.info(_('  Step ') +str(i))
+            for i in tqdm(range(nb + 1)):
                 z.append(curz)
 
+                # Compute difference between the array and the current elevation
                 if i == 0:
                     diff = self.array - (curz + 1.e-3)
                 else:
                     diff = self.array - curz
 
+                # Keep only the negative values
                 diff[diff > 0] = 0.
                 diff.data[diff.mask] = 0.
-                labeled_array, num_features = label(diff.data)
-                labeled_array = ma.asarray(labeled_array)
-                labeled_array.mask = self.array.mask
-
-                # groupement = labeled_array
-                # groupement[labeled_array.mask] = 0
-                # nbgroupement.append(num_features)
-                # for j in range(1, nbgroupement[i] + 1):
-                #     taille = (np.sum(groupement[groupement == j]) // j)
-                #     longueur.append([taille, j])
-
 
-                longueur = list(sum_labels(np.ones(labeled_array.shape, dtype=np.int32), labeled_array, range(1, num_features+1)))
+                if np.count_nonzero(diff < 0.) > 1:
+                    # More than one cell below the elevation
+
+                    # Labeling of the cells below the elevation
+                    labeled_array, num_features = label(diff.data)
+                    # Applying the same mask as the original array
+                    labeled_array = ma.asarray(labeled_array)
+                    labeled_array.mask = self.array.mask
+
+                    if use_memory:
+                        # Use only the labeled areas containing the cells stored in memory selection
+                        labeled_areas = []
+                        for curij in ij_key:
+                            labeled_areas.append(labeled_array[curij[0], curij[1]])
+
+                        # Remove masked value
+                        labeled_areas = [x for x in labeled_areas if x is not ma.masked]
+                        # Remove duplicates
+                        labeled_areas = list(set(labeled_areas))
+
+                        for curarea in labeled_areas:
+                            if curarea ==0:
+                                volume = 0.
+                                surface = 0.
+                                continue
+
+                            # Search
+                            mask = labeled_array == curarea
+                            area = np.where(mask)
+                            volume = -self.dx * self.dy * np.sum(diff[area])
+                            surface = self.dx * self.dy * len(area[0])
+                            extensionmax.array[np.logical_and(mask, extensionmax.array[:, :] == 0.)] = float(i + 1)
 
-                longueur.sort(key=lambda x: x[0], reverse=True)
+                    else:
+                        labeled_areas = list(sum_labels(np.ones(labeled_array.shape, dtype=np.int32), labeled_array, range(1, num_features+1)))
+                        labeled_areas = [[x, y] for x, y in zip(labeled_areas, range(1, num_features+1))]
+                        labeled_areas.sort(key=lambda x: x[0], reverse=True)
+                        jmax = labeled_areas[0][1]
+                        nbmax = labeled_areas[0][0]
+
+                        volume = -self.dx * self.dy * np.sum(diff[labeled_array == jmax])
+                        surface = self.dx * self.dy * nbmax
+                        extensionmax.array[np.logical_and(labeled_array == jmax, extensionmax.array[:, :] == 0.)] = float(i + 1)
+                else:
+                    # Only one cell below the elevation
+                    volume = -self.dx * self.dy * np.sum(diff)
+                    surface = self.dx * self.dy * np.count_nonzero(diff<0.)
+                    extensionmax.array[np.logical_and(diff[:,:]<0., extensionmax.array[:, :] == 0.)] = float(i + 1)
 
-                jmax = longueur[0][1]
-                nbmax = longueur[0][0]
-                volume = -self.dx * self.dy * np.sum(diff[labeled_array == jmax])
-                surface = self.dx * self.dy * nbmax
                 stockage.append([volume, surface])
                 curz += deltaz
 
-                extensionmax.array[np.logical_and(labeled_array == jmax, extensionmax.array[:, :] == 0.)] = float(i + 1)
         else:
-            for i in range(nb + 1):
-                logging.info(_('  Step ') +str(i))
+            for i in tqdm(range(nb + 1)):
                 z.append(curz)
 
                 if i == 0:
@@ -6595,7 +6723,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                 extensionmax.array[np.logical_and(diff[:,:]<0., extensionmax.array[:, :] == 0.)] = float(i + 1)
 
-        dlg = wx.FileDialog(None, _('Choose filename'), wildcard='bin (*.bin)|*.bin|All (*.*)|*.*', style=wx.FD_SAVE)
+        dlg = wx.FileDialog(None, _('Choose filename for zoning result'), wildcard='bin (*.bin)|*.bin|tif (*.tif)|*.tif|All (*.*)|*.*', style=wx.FD_SAVE)
         ret = dlg.ShowModal()
         if ret == wx.ID_CANCEL:
             dlg.Destroy()
@@ -6609,22 +6737,25 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if axs is None:
             fig, axs = plt.subplots(1, 2, tight_layout=True)
+        else:
+            fig = axs[0].get_figure()
+
         axs[0].plot(z, [x[0] for x in stockage])
         axs[0].scatter(z, [x[0] for x in stockage])
         axs[0].set_xlabel(_("Elevation [m]"), size=15)
-        axs[0].set_ylabel(_("Volume [m^3]"), size=15)
+        axs[0].set_ylabel(_("Volume [$m^3$]"), size=15)
         axs[1].step(z, [x[1] for x in stockage], where='post')
         axs[1].scatter(z, [x[1] for x in stockage])
         axs[1].set_xlabel(_("Elevation [m]"), size=15)
-        axs[1].set_ylabel(_("Surface [m^2]"), size=15)
-        plt.suptitle(_("Retention capacity of the selected zone"), fontsize=20)
+        axs[1].set_ylabel(_("Surface [$m^2$]"), size=15)
+        fig.suptitle(_("Retention capacity of the selected zone"), fontsize=20)
 
         with open(fn[:-4] + '_hvs.txt', 'w') as f:
-            f.write('H [m]\tZ [m DNG]\tVolume [m^3]\tSurface [m^2]\n')
+            f.write('H [m]\tZ [m DNG]\tVolume [$m^3$]\tSurface [$m^2$]\n')
             for curz, (curv, curs) in zip(z, stockage):
                 f.write('{}\t{}\t{}\t{}\n'.format(curz - zmin, curz, curv, curs))
 
-        return axs
+        return fig, axs
 
     def paste_all(self, fromarray:"WolfArray", mask_after:bool=True):
         """ Paste all the values from another WolfArray """
@@ -6735,6 +6866,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                 dtype = np.int16
             elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
                 dtype = np.int8
+            elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+                dtype = np.uint8
 
         self.dx = myhead.dx
         self.dy = myhead.dy
@@ -6905,20 +7038,24 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.plotted = False
 
         if unload and self.filename != '':
-            if askquestion and self.wx_exists:
-                dlg = wx.MessageDialog(None,
-                                    _('Do you want to unload data? \n If YES, the data will be reloaded from file once checekd \n If not saved, modifications will be lost !!'),
-                                    style=wx.YES_NO)
-                ret = dlg.ShowModal()
-                if ret == wx.ID_YES:
-                        unload=True
+            if Path(self.filename).exists():
+                # An array can exists with a filename but no written data on disk
+                # In this case, we don't want to delete the data in memory
 
-            if unload:
-                self.delete_lists()
-                self.array = np.zeros([1])
-                if VERSION_RGB==1 : self.rgb = None
-                self.loaded = False
-                return
+                if askquestion and self.wx_exists:
+                    dlg = wx.MessageDialog(None,
+                                        _('Do you want to unload data? \n If YES, the data will be reloaded from file once checekd \n If not saved, modifications will be lost !!'),
+                                        style=wx.YES_NO)
+                    ret = dlg.ShowModal()
+                    if ret == wx.ID_YES:
+                            unload=True
+
+                if unload:
+                    self.delete_lists()
+                    self.array = np.zeros([1])
+                    if VERSION_RGB==1 : self.rgb = None
+                    self.loaded = False
+                    return
 
         if not forceresetOGL:
             if askquestion and self.wx_exists:
@@ -7186,7 +7323,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return newArray
 
-    def mask_outsidepoly(self, myvect: vector, eps:float = 0.):
+    def mask_outsidepoly(self, myvect: vector, eps:float = 0., set_nullvalue:bool=True):
         """
         Mask nodes outside a polygon and set values to nullvalue
 
@@ -7196,31 +7333,21 @@ class WolfArray(Element_To_Draw, header_wolf):
         # (coord will be converted back with translation, origin and dx/dy)
         # (mesh coord, 0-based)
 
-        mask = self.array.mask
-        mask[:,:] = True # Mask everything
-
         # trouve les indices dans le polygone
-        myij = self.get_ij_inside_polygon(myvect, usemask=False, eps=eps)
+        myij = self.get_ij_inside_polygon(myvect, usemask=True, eps=eps)
 
-        # démasquage des mailles contenues
-        mask[myij[:,0],myij[:,1]] = False
+        self.array.mask.fill(True) # Mask everything
 
-        # annulation des valeurs en dehors du polygone
-        self.array.data[np.where(mask)] = self.nullvalue
-
-        # recherche du nouveau masque, sinon les valeurs no_data à
-        # l'intérieur du polygone vont pollluer la matrice
+        # démasquage des mailles contenues
+        self.array.mask[myij[:,0],myij[:,1]] = False
 
-        # Now we have masked everything outside the polygon,
-        # we still have to keep into account values that were
-        # already masked inside the polygon before this operation.
-        # FIXME Why simply not use the previous mask value ?
-        # FIXME This operation seems to contradict mask[:,:] = True
-        self.mask_data(self.nullvalue)
+        if set_nullvalue:
+            # annulation des valeurs en dehors du polygone
+            self.set_nullvalue_in_mask()
 
         self.count()
 
-    def mask_insidepoly(self, myvect: vector, eps:float = 0.):
+    def mask_insidepoly(self, myvect: vector, eps:float = 0., set_nullvalue:bool=True):
         """
         Mask nodes inside a polygon and set values to nullvalue
 
@@ -7233,8 +7360,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         # trouve les indices dans le polygone
         myij = self.get_ij_inside_polygon(myvect, usemask=False, eps=eps)
 
-        # annulation des valeurs en dehors du polygone
-        self.array.data[myij[:,0],myij[:,1]] = self.nullvalue
+        if set_nullvalue:
+            # annulation des valeurs en dehors du polygone
+            self.array.data[myij[:,0],myij[:,1]] = self.nullvalue
 
         # masquage des mailles contenues
         self.array.mask[myij[:,0],myij[:,1]] = True
@@ -7250,8 +7378,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Return the coordinates inside a polygon
 
-        :param myvect : target vector
-        :param usemask : limit potential nodes to unmaksed nodes
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
         """
 
         if isinstance(myvect, vector):
@@ -7279,8 +7407,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Return the coordinates inside a polygon
 
-        :param myvect : target vector
-        :param usemask : limit potential nodes to unmaksed nodes
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
         """
 
         if isinstance(myvect, vector):
@@ -7307,8 +7435,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Return the coordinates along a polyline
 
-        :param myvect : target vector
-        :param usemask : limit potential nodes to unmaksed nodes
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
         """
 
         allij = self.get_ij_under_polyline(myvect, usemask)
@@ -7320,8 +7448,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Return the indices inside a polygon
 
-        :param myvect : target vector
-        :param usemask : limit potential nodes to unmaksed nodes
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
+        :param eps: epsilon for the intersection
         """
 
         # force la mise à jour des min/max
@@ -7346,8 +7475,8 @@ class WolfArray(Element_To_Draw, header_wolf):
     def intersects_polygon(self, myvect: vector | Polygon, usemask:bool=True):
         """ Return True if the array intersects the polygon
 
-        :param myvect : target vector
-        :param usemask : limit potential nodes to unmaksed nodes
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
         """
 
         return self.get_xy_inside_polygon(myvect, usemask).shape[0] > 0
@@ -7355,8 +7484,8 @@ class WolfArray(Element_To_Draw, header_wolf):
     def intersects_polygon_shapely(self, myvect: vector | Polygon, eps:float = 0., usemask:bool=True):
         """ Return True if the array intersects the polygon
 
-        :param myvect : target vector
-        :param usemask : limit potential nodes to unmaksed nodes
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
         """
         return self.get_xy_inside_polygon_shapely(myvect, usemask).shape[0] > 0
 
@@ -7364,8 +7493,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Return the indices along a polyline
 
-        :param myvect = target vector
-        :param usedmask = limit potential nodes to unmaksed nodes
+        :param myvect: target vector
+        :param usedmask: limit potential nodes to unmaksed nodes
         """
 
         ds = min(self.dx, self.dy)
@@ -7388,8 +7517,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Récupération des valeurs contenues dans un polygone
 
-        :param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice
-        :param getxy : (optional) retourne en plus les coordonnées des points
+        :param usemask: (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param getxy: (optional) retourne en plus les coordonnées des points
         """
         mypoints = self.get_xy_inside_polygon(myvect, usemask)
         myvalues = np.asarray([self.get_value(cur[0], cur[1]) for cur in mypoints])
@@ -7403,8 +7532,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Récupération des valeurs contenues sous une polyligne
 
-        :param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice
-        :param getxy : (optional) retourne en plus les coordonnées des points
+        :param usemask: (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param getxy: (optional) retourne en plus les coordonnées des points
         """
         mypoints = self.get_xy_under_polyline(myvect, usemask)
 
@@ -7419,8 +7548,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Récupération de toutes les valeurs contenues dans un polygone
 
-        :param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice
-        :param getxy : (optional) retourne en plus les coordonnées des points
+        :param usemask: (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param getxy: (optional) retourne en plus les coordonnées des points
 
         ICI on retourne le résultat de get_values_insidepoly, car une seule matrice, mais une autre classe pourrait vouloir faure autre chose
           C'est le cas notamment de Wolfresults_2D
@@ -7432,8 +7561,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Récupération de toutes les valeurs sous la polyligne
 
-        :param usemask : (optional) restreint les éléments aux éléments non masqués de la matrice
-        :param getxy : (optional) retourne en plus les coordonnées des points
+        :param usemask: (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param getxy: (optional) retourne en plus les coordonnées des points
 
         ICI on retourne le résultat de get_values_underpoly, car une seule matrice, mais une autre classe pourrait vouloir faure autre chose
           C'est le cas notamment de Wolfresults_2D
@@ -7562,6 +7691,9 @@ class WolfArray(Element_To_Draw, header_wolf):
                 elif locarray.dtype == np.int8:
                     self.wolftype = WOLF_ARRAY_FULL_INTEGER8
                     logging.warning(_('Data type changed to int8'))
+                elif locarray.dtype == np.uint8:
+                    self.wolftype = WOLF_ARRAY_FULL_UINTEGER8
+                    logging.warning(_('Data type changed to uint8'))
                 else:
                     logging.error(_('Unsupported type in numpy file -- Abort wrting header file'))
                     writing_header = False
@@ -7586,7 +7718,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param factor: factor of resolution change -- > 1.0 : decrease resolution, < 1.0 : increase resolution
         :type factor: float
         :return: new shape
-        :rtype: Tuple[int, int]
+        :rtype: Tuple[int, int], Tuple[float, float]
         """
 
         newdx = self.dx * float(factor)
@@ -7869,6 +8001,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER8]:
             locarray = np.frombuffer(f.read(self.nbx * self.nby * 2), dtype=np.int8)
             self.array = ma.masked_array(locarray.copy(), dtype=np.int8)
+        elif self.wolftype in [WOLF_ARRAY_FULL_UINTEGER8]:
+            locarray = np.frombuffer(f.read(self.nbx * self.nby * 2), dtype=np.uint8)
+            self.array = ma.masked_array(locarray.copy(), dtype=np.uint8)
 
         if self.nbdims == 2:
             self.array = self.array.reshape(self.nbx, self.nby, order='F')
@@ -7903,7 +8038,8 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return xyz[filter]
 
-    def set_general_frame_from_xyz(self, fname:str, dx:float, dy:float, border_size:int=5):
+    @classmethod
+    def set_general_frame_from_xyz(cls, fname:str, dx:float, dy:float, border_size:int=5, delimiter:str=',', fillin:bool=False):
         """
         Lecture d'un fichier texte xyz et initialisation des données de base
 
@@ -7913,19 +8049,72 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param border_size: nombre de mailles de bordure en plus de l'extension spatiale du fichier
         """
 
-        my_file = XYZFile(fname)
+        my_file = XYZFile(fname, delimiter=delimiter)
         my_file.read_from_file()
         (xlim, ylim) = my_file.get_extent()
 
-        self.dx = dx
-        self.dy = dy
-        self.origx = m.floor(xlim[0]) - float(border_size) * self.dx
-        self.origy = m.floor(ylim[0]) - float(border_size) * self.dy
-        self.nbx = int((m.floor(xlim[1]) - m.ceil(xlim[0])) / self.dx) + 2*border_size
-        self.nby = int((m.floor(ylim[1]) - m.ceil(ylim[0])) / self.dy) + 2*border_size
+        Array = WolfArray()
+        Array.dx = dx
+        Array.dy = dy
+        Array.origx = m.floor(xlim[0]) - dx/2. - float(border_size) * Array.dx
+        Array.origy = m.floor(ylim[0]) - dy/2. - float(border_size) * Array.dy
+        Array.nbx = int((m.floor(xlim[1]) - m.ceil(xlim[0])) / Array.dx) + 1 + 2*border_size
+        Array.nby = int((m.floor(ylim[1]) - m.ceil(ylim[0])) / Array.dy) + 1 + 2*border_size
+
+        Array.array = np.ma.zeros((Array.nbx, Array.nby), dtype=np.float32)
 
-        self.array = np.ma.zeros((self.nbx, self.nby))
-        return my_file
+        if fillin:
+            Array.fillin_from_xyz(my_file.xyz)
+
+        return Array
+
+    @classmethod
+    def set_general_frame_from_xyz_dir(cls, path:str, bounds:list, delimiter:str=',', dxdy:tuple[float, float]= None, border_size:int=5, fillin:bool=True):
+        """
+        Lecture d'un dossier contenant des fichiers texte xyz, initialisation des données de base et chargement de la matrice
+        Renvoie un WolfArray or False si le fichier n'est pas dans les limites
+
+        :param path: chemin du dossier avec les fichier xyz
+        :dtype path: str
+        :param bounds: limites de l'extension spatiale
+        :dtype bounds: list
+        :param delimiter: délimiteur des fichiers xyz
+        :dtype delimiter: str
+        :param border_size: nombre de mailles de bordure en plus de l'extension spatiale du fichier
+        :dtype border_size: int
+        """
+
+        Data_xyz = XYZFile('nothing.xyz', folder=path, bounds=bounds, delimiter=delimiter)
+
+        if Data_xyz.nblines == 0:
+            logging.info(f"File not in the boundaries for {path.split(os.sep)[-1]}")
+            return False
+
+        xlim, ylim = Data_xyz.get_extent()
+
+        if dxdy is None:
+            # We assume dx and dy are equals within xyz file
+            dx = np.diff(Data_xyz.xyz[0:2,0])[0]
+            logging.info(f"dx = {dx} ; dy = {dx}")
+            dy = dx
+        else:
+            dx,dy = dxdy
+            assert dx is not None and dy is not None, _('dx and dy must be defined')
+
+        Array = WolfArray()
+        Array.dx = dx
+        Array.dy = dy
+        Array.origx = m.floor(xlim[0]) -dx/2. - float(border_size) * Array.dx
+        Array.origy = m.floor(ylim[0]) -dy/2. - float(border_size) * Array.dy
+        Array.nbx = int((m.floor(xlim[1]) - m.ceil(xlim[0])) / Array.dx) +1 + 2*border_size
+        Array.nby = int((m.floor(ylim[1]) - m.ceil(ylim[0])) / Array.dy) +1 + 2*border_size
+
+        Array.array = np.ma.zeros((Array.nbx, Array.nby))
+
+        if fillin:
+            Array.fillin_from_xyz(Data_xyz.xyz)
+
+        return Array
 
     def fillin_from_xyz(self, xyz:np.ndarray):
         """ Remplissage du tableau à partir d'un tableau xyz """
@@ -8027,6 +8216,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                     value=np.int16(value)
                 elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER8]:
                     value=np.int8(value)
+                elif self.wolftype in [WOLF_ARRAY_FULL_UINTEGER8]:
+                    value=np.uint8(value)
         except:
             logging.error(_('Type not supported : {} - {}'.format(value, type(value))))
             logging.warning(_('Masking operation compromised'))
@@ -8190,7 +8381,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         assert type(k_start) == int, "k_start must be an integer"
         assert type(nbz) == int, "nbz must be an integer"
 
-        newWolfArray = WolfArray()
+        newWolfArray = WolfArray(nullvalue=self.nullvalue)
         newWolfArray.nbx = nbx
         newWolfArray.nby = nby
         newWolfArray.dx = self.dx
@@ -8383,7 +8574,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if VERSION_RGB==1 :
             if self.nbx * self.nby > 1_000_000 : logging.info(_('Computing colors'))
-            if self.wolftype not in [WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_INTEGER8]:
+            if self.wolftype not in [WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_UINTEGER8]:
                 # FIXME: Currently, only some types are supported in Cython/OpenGL library
                 self._tmp_float32 = self.array.astype(dtype=np.float32)
                 self.rgb = self.mypal.get_rgba(self._tmp_float32)
@@ -8394,6 +8585,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif VERSION_RGB in [2 ,3]:
             if self.wolftype not in [WOLF_ARRAY_FULL_SINGLE,
                                      WOLF_ARRAY_FULL_INTEGER8,
+                                     WOLF_ARRAY_FULL_UINTEGER8,
                                      WOLF_ARRAY_FULL_INTEGER16,
                                      WOLF_ARRAY_FULL_INTEGER16_2,
                                      WOLF_ARRAY_FULL_INTEGER,
@@ -8561,7 +8753,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.mygrid = {}
         self.gridmaxscales = -1
 
-    def plot_matplotlib(self):
+    def plot_matplotlib(self, figax:tuple=None, getdata_im:bool=False):
         """
         Plot the array - Matplotlib version
 
@@ -8570,14 +8762,19 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.mask_data(self.nullvalue)
         self.updatepalette(0)
+        if figax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig, ax = figax
 
-        fig, ax = plt.subplots()
-
-        ax.imshow(self.array.transpose(), origin='lower', cmap=self.mypal,
+        im = ax.imshow(self.array.transpose(), origin='lower', cmap=self.mypal,
                    extent=(self.origx, self.origx + self.dx * self.nbx, self.origy, self.origy + self.dy * self.nby))
         ax.set_aspect('equal')
 
-        return fig, ax
+        if getdata_im:
+            return fig, ax, im
+        else:
+            return fig, ax
 
     def fillonecellgrid(self, curscale, loci, locj, force=False):
         """ Fill one cell of the plotted grid """
@@ -8638,6 +8835,14 @@ class WolfArray(Element_To_Draw, header_wolf):
                             elif self.nbnotnull > 0:
                                 wolfogl.addmeall_int8_pal(self.array, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart,
                                                 jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst))
+                        elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_uint8_pal(self.array, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart,
+                                                jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst))
+                            elif self.nbnotnull > 0:
+                                wolfogl.addmeall_uint8_pal(self.array, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart,
+                                                jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst))
                         elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
                             if self.nbnotnull != self.nbx * self.nby:
                                 if self.nbnotnull > 0:
@@ -8694,6 +8899,14 @@ class WolfArray(Element_To_Draw, header_wolf):
                             elif self.nbnotnull > 0:
                                 wolfogl.addmeall_int8_pal_mask(self.array, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart,
                                                 jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst), self.array.mask)
+                        elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_uint8_pal_mask(self.array, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart,
+                                                jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst), self.array.mask)
+                            elif self.nbnotnull > 0:
+                                wolfogl.addmeall_uint8_pal_mask(self.array, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart,
+                                                jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst), self.array.mask)
                         elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
                             if self.nbnotnull != self.nbx * self.nby:
                                 if self.nbnotnull > 0:
@@ -8764,8 +8977,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         The borders are computed on basis of the current *mask*
 
-        :param filename : if provided, write 'sux', 'sux' and 'xy' files
-        :param abs : add translation coordinates (Global World Coordinates)
+        :param filename: if provided, write 'sux', 'sux' and 'xy' files
+        :param abs: add translation coordinates (Global World Coordinates)
 
         :return indicesX, indicesY, contourgen, interior
 
@@ -8961,6 +9174,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                 return WOLF_ARRAY_FULL_INTEGER
             elif curarray.dtype == np.int8:
                 return WOLF_ARRAY_FULL_INTEGER8
+            elif curarray.dtype == np.uint8:
+                return WOLF_ARRAY_FULL_UINTEGER8
 
         self.array = np.ma.array(array.copy())
         self.wolftype = wolftype_from_npz(array)