wolfhece 2.1.98__py3-none-any.whl → 2.1.100__py3-none-any.whl

wolfhece/wolf_array.py

@@ -49,19 +49,19 @@ from copy import deepcopy
 from enum import Enum
 
 try:
-    from osgeo import gdal
+    from .PyTranslate import _
 except ImportError as e:
     print(e)
-    raise Exception(_('Error importing GDAL library'))
+    raise Exception(_('Error importing modules'))
 
 try:
-    from .Coordinates_operations import reproject_and_resample_raster
+    from osgeo import gdal
 except ImportError as e:
     print(e)
-    raise Exception(_('Error importing modules'))
+    raise Exception(_('Error importing GDAL library'))
 
 try:
-    from .PyTranslate import _
+    from .Coordinates_operations import reproject_and_resample_raster
 except ImportError as e:
     print(e)
     raise Exception(_('Error importing modules'))
@@ -277,7 +277,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 +344,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 +364,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 +381,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 +405,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 +421,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 +433,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 +475,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 +642,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 +664,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 +689,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 +759,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
@@ -994,9 +994,9 @@ 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')
@@ -1035,8 +1035,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 +1173,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 +1191,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 +1221,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 +1232,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
 
         """
 
@@ -7186,7 +7188,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 +7198,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)
-
-        # démasquage des mailles contenues
-        mask[myij[:,0],myij[:,1]] = False
+        myij = self.get_ij_inside_polygon(myvect, usemask=True, eps=eps)
 
-        # annulation des valeurs en dehors du polygone
-        self.array.data[np.where(mask)] = self.nullvalue
+        self.array.mask.fill(True) # Mask everything
 
-        # 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 +7225,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 +7243,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 +7272,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 +7300,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 +7313,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 +7340,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 +7349,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 +7358,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 +7382,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 +7397,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 +7413,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 +7426,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
@@ -7525,7 +7519,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                 if update_min_max:
                     self.mypal.distribute_values(self.array.min(), self.array.max())
 
-    def write_all(self, newpath:str = None, EPSG:int = 31370):
+    def write_all(self, newpath:str | Path = None, EPSG:int = 31370):
         """
         Ecriture de tous les fichiers d'un Wolf array
 
@@ -7586,7 +7580,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)
@@ -7903,7 +7897,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 +7908,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 """
@@ -8190,7 +8238,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
@@ -8561,7 +8609,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 +8618,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 """
@@ -8764,8 +8817,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