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

wolfhece/wolf_array.py

@@ -43,6 +43,7 @@ from scipy.ndimage import laplace, label, sum_labels
 import pygltflib
 from shapely.geometry import Point, LineString, MultiLineString, Polygon, MultiPolygon, MultiPoint
 from shapely.ops import linemerge, substring, polygonize_full
+from shapely import contains, contains_properly, contains_xy, touches, prepare, destroy_prepared, is_prepared
 from os.path import dirname,basename,join
 import logging
 from typing import Literal
@@ -379,7 +380,51 @@ class header_wolf():
 
         self.head_blocks[_key] = deepcopy(value)
 
-    def set_origin(self, x:float, y:float, z:float):
+    @property
+    def resolution(self):
+        return self.get_resolution()
+
+    @resolution.setter
+    def resolution(self, value:tuple[float]):
+
+        if len(value) == 2:
+            self.set_resolution(value[0], value[1])
+        elif len(value) == 3:
+            self.set_resolution(value[0], value[1], value[2])
+
+    @property
+    def origin(self):
+        return self.get_origin()
+
+    @origin.setter
+    def origin(self, value:tuple[float]):
+
+        if len(value) == 2:
+            self.set_origin(value[0], value[1])
+        elif len(value) == 3:
+            self.set_origin(value[0], value[1], value[2])
+
+    @property
+    def translation(self):
+        return self.get_translation()
+
+    @translation.setter
+    def translation(self, value:tuple[float]):
+        if len(value) == 2:
+            self.set_translation(value[0], value[1])
+        elif len(value) == 3:
+            self.set_translation(value[0], value[1], value[2])
+
+    def set_resolution(self, dx:float, dy:float, dz:float= 0.):
+        """
+        Set resolution
+        """
+
+        self.dx = dx
+        self.dy = dy
+        self.dz = dz
+
+    def set_origin(self, x:float, y:float, z:float = 0.):
         """
         Set origin
 
@@ -391,7 +436,28 @@ class header_wolf():
         self.origy = y
         self.origz = z
 
-    def set_translation(self, tr_x:float, tr_y:float, tr_z:float):
+    def get_origin(self):
+        """
+        Return origin
+        """
+
+        return (self.origx, self.origy, self.origz)
+
+    def get_resolution(self):
+        """
+        Return resolution
+        """
+
+        return (self.dx, self.dy, self.dz)
+
+    def get_translation(self):
+        """
+        Return translation
+        """
+
+        return (self.translx, self.transly, self.translz)
+
+    def set_translation(self, tr_x:float, tr_y:float, tr_z:float= 0.):
         """
         Set translation
 
@@ -576,6 +642,44 @@ class header_wolf():
         else:
             raise Exception(_("The number of coordinates is not correct"))
 
+    def transform(self):
+        """ Return the affine transformation.
+
+        Similar to rasterio.transform.Affine
+
+        In WOLF, the convention is :
+         - origin is at the lower-left corner
+         - the origin is at the corner of the cell dx, dy, so the center of the cell is at dx/2, dy/2
+         - X axis is along the rows - i index
+         - Y axis is along the columns - j index
+
+         So, the affine transformation is :
+            (dx, 0, origx + translx + dx /2, 0, dy, origy + transly + dy/2)
+        """
+        from rasterio.transform import Affine
+        return Affine(self.dx, 0, self.origx + self.translx + self.dx / 2,
+                      0, self.dy, self.origy + self.transly + self.dy / 2)
+
+    def _transform_gmrio(self):
+        """ Return the affine transformation.
+
+        !! Inverted ij/ji convention !!
+
+        Similar to rasterio.transform.Affine
+
+        In WOLF, the convention is :
+         - origin is at the lower-left corner
+         - the origin is at the corner of the cell dx, dy, so the center of the cell is at dx/2, dy/2
+         - X axis is along the rows - i index
+         - Y axis is along the columns - j index
+
+         So, the affine transformation is :
+            (dx, 0, origx + translx + dx /2, 0, dy, origy + transly + dy/2)
+        """
+        from rasterio.transform import Affine
+        return Affine(0, self.dy, -(self.origy + self.transly),
+                      self.dx, 0, -(self.origx + self.transly))
+
     def get_xy_from_ij_array(self, ij:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
         """
         Converts array coordinates (numpy cells) to this array's world coodinates.
@@ -1028,6 +1132,23 @@ class header_wolf():
 
                     self.head_blocks[getkeyblock(i)] = curhead
 
+    @classmethod
+    def read_header(cls, filename:str) -> "header_wolf":
+        """
+        alias for read_txt_header
+        """
+        newhead = cls()
+        newhead.read_txt_header(filename)
+        return newhead
+
+    def write_header(self, filename:str,
+                     wolftype:int,
+                     forceupdate:bool=False):
+        """
+        alias for write_txt_header
+        """
+        self.write_txt_header(filename, wolftype, forceupdate)
+
     def write_txt_header(self,
                          filename:str,
                          wolftype:int,
@@ -1576,6 +1697,14 @@ class CropDialog(wx.Dialog):
             self.ex.SetValue(str(header.origx + header.nbx * header.dx))
             self.ey.SetValue(str(header.origy + header.nby * header.dy))
 
+    def get_crop(self):
+        """ Return the crop values """
+        try:
+            return [[float(self.ox.Value), float(self.oy.Value)], [float(self.ex.Value), float(self.ey.Value)]]
+        except:
+            logging.error(_('Values must be numbers'))
+            return None
+
 import string
 class IntValidator(wx.Validator):
     ''' Validates data as it is entered into the text controls. '''
@@ -1912,6 +2041,8 @@ class Ops_Array(wx.Frame):
 
         self.labelling = wx.Button(self.tools, wx.ID_ANY, _("Labelling"), wx.DefaultPosition,wx.DefaultSize, 0)
 
+        self.statistics = wx.Button(self.tools, wx.ID_ANY, _("Statistics"), wx.DefaultPosition,wx.DefaultSize, 0)
+
         self.clean = wx.Button(self.tools, wx.ID_ANY, _("Clean"), wx.DefaultPosition,wx.DefaultSize, 0)
 
         self.extract_selection = wx.Button(self.tools, wx.ID_ANY, _("Extract selection"), wx.DefaultPosition,wx.DefaultSize, 0)
@@ -1930,6 +2061,7 @@ class Ops_Array(wx.Frame):
         Toolssizer.Add(self.labelling, 1, wx.EXPAND)
         Toolssizer.Add(self.clean, 1, wx.EXPAND)
         Toolssizer.Add(self.extract_selection, 1, wx.EXPAND)
+        Toolssizer.Add(self.statistics, 1, wx.EXPAND)
         Toolssizer.Add(cont_sizer, 1, wx.EXPAND)
 
         self.ApplyTools.SetToolTip(_("Apply Nullvalue into memory/object"))
@@ -1938,6 +2070,7 @@ class Ops_Array(wx.Frame):
         self.labelling.SetToolTip(_("Labelling of contiguous zones using Scipy.label function\n\nReplacing the current values by the labels"))
         self.clean.SetToolTip(_("Clean the array\n\nRemove small isolated patches of data"))
         self.extract_selection.SetToolTip(_("Extract the current selection"))
+        self.statistics.SetToolTip(_("Compute statistics on the array\n\nResults are displayed in a dialog box"))
 
         self.tools.SetSizer(Toolssizer)
         self.tools.Layout()
@@ -2310,6 +2443,7 @@ class Ops_Array(wx.Frame):
         self.filter_zone.Bind(wx.EVT_BUTTON, self.OnFilterZone)
         self.clean.Bind(wx.EVT_BUTTON, self.OnClean)
         self.labelling.Bind(wx.EVT_BUTTON, self.OnLabelling)
+        self.statistics.Bind(wx.EVT_BUTTON, self.OnStatistics)
         self.extract_selection.Bind(wx.EVT_BUTTON, self.OnExtractSelection)
         self._contour_int.Bind(wx.EVT_BUTTON, self.OnContourInt)
         self._contour_list.Bind(wx.EVT_BUTTON, self.OnContourList)
@@ -2784,6 +2918,40 @@ class Ops_Array(wx.Frame):
 
         self.parentarray.labelling()
 
+    def OnStatistics(self, event:wx.MouseEvent):
+        """ Statistics on the array """
+
+        ret = self.parentarray.statistics()
+
+        ret_frame = wx.Frame(None, -1, _('Statistics of {} on selected values').format(self.parentarray.idx), size = (300, 200))
+
+        icon = wx.Icon()
+        icon_path = Path(__file__).parent / "apps/wolf_logo2.bmp"
+        icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
+        ret_frame.SetIcon(icon)
+
+        ret_panel = wx.Panel(ret_frame, -1)
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+        # Add a cpGrid and put statistics in it
+        cp = CpGrid(ret_panel, wx.ID_ANY, style=wx.WANTS_CHARS | wx.TE_CENTER)
+        cp.CreateGrid(len(ret), 2)
+
+        sizer.Add(cp, 1, wx.EXPAND)
+
+        for i, (key,val) in enumerate(ret.items()):
+            if i != len(ret)-1:
+                cp.SetCellValue(i, 0, key)
+                cp.SetCellValue(i, 1, str(val))
+
+        ret_panel.SetSizer(sizer)
+        ret_panel.Layout()
+
+        ret_frame.SetSize((300, 200))
+        ret_frame.Centre()
+
+        ret_frame.Show()
+
     def OnExtractSelection(self, event:wx.MouseEvent):
         """ Extract the current selection """
 
@@ -5122,7 +5290,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param fname: filename/filepath - if provided, the file will be read on disk
         :param mold: initialize from a copy a the mold object --> must be a WolArray if not None
         :param masknull: mask data based on the nullvalue
-        :param crop: crop data based on the spatial extent [[xmin, xmax],[ymin,ymax]]
+        :param crop: crop data based on the spatial extent [[xmin, xmax], [ymin,ymax]]
         :param whichtype: type of the numpy array (float32 as default)
         :param preload: True = load data during initialization ; False = waits for the display to be required
         :param create: True = create a new array from wxDialog
@@ -5885,6 +6053,30 @@ class WolfArray(Element_To_Draw, header_wolf):
         if reset_plot:
             self.reset_plot()
 
+    def statistics(self, inside_polygon:vector | Polygon = None):
+        """
+        Statistics on Selected data or the whole array if no selection
+
+        :param inside_polygon: vector or Polygon to select data inside the polygon
+        :return: mean, std, median, sum, values
+        """
+
+        if inside_polygon is not None:
+            ij = self.get_ij_inside_polygon(inside_polygon)
+            vals = self.array[ij]
+        elif self.SelectionData.nb == 0 or self.SelectionData.myselection == 'all':
+            logging.info(_('No selection -- statistics on the whole array'))
+            vals = self.array[~self.array.mask]	# all values
+        else:
+            vals = self.SelectionData.get_values_sel()
+
+        mean = np.mean(vals)
+        std = np.std(vals)
+        median = np.median(vals)
+        sum = np.sum(vals)
+
+        return {_('Mean'): mean, _('Std'): std, _('Median'): median, _('Sum'): sum, _('Values'): vals}
+
     def export_geotif(self, outdir:str= '', extent:str= '', EPSG:int = 31370):
         """
         Export de la matrice au format Geotiff (Lambert 72 - EPSG:31370)
@@ -5975,7 +6167,15 @@ class WolfArray(Element_To_Draw, header_wolf):
         band.SetNoDataValue(nullvalue)
         band.WriteArray(np.flipud(arr.data.transpose()))
         band.FlushCache()
-        band.ComputeStatistics(True)
+        try:
+            band.ComputeStatistics(True)
+        except RuntimeError as e:
+            # If the array is mainly composed of null values, ComputeStatistics(True) will fail because ComputeStatistics(True) takes a subset of the data to compute statistics (and it may only find null values resulting to an error while in the array, it is not the case)
+            try:
+                band.ComputeStatistics(0)  # Using 0 for exact stats instead of True (which implies approximate)
+            except RuntimeError as e:
+                print("Warning: ComputeStatistics failed:", e)
+
 
 
     def get_dxdy_min(self):
@@ -6073,12 +6273,16 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                 fn_crop = fn + '_crop.tif'
                 if type(crop) is np.ndarray:
-                    pass
+                    if crop.shape == (4,):
+                        logging.error(_('Crop must be a list or a numpy array with 4 values - [[xmin, xmax], [ymin, ymax]]'))
+                        crop = [[crop[0], crop[1]], [crop[2], crop[3]]]
                 elif type(crop) is list:
-                    pass
+                    if len(crop) == 4:
+                        logging.error(_('Crop must be a list or a numpy array with 4 values - [[xmin, xmax], [ymin, ymax]]'))
+                        crop = [[crop[0], crop[1]], [crop[2], crop[3]]]
                 else:
                     if not self.wx_exists:
-                        logging.error(_('Crop must be a list or a numpy array with 4 values - xmin, xmax, ymin, ymax'))
+                        logging.error(_('WX App is required to display the UI'))
                         return
 
                     raster_in:gdal.Dataset
@@ -6141,8 +6345,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                             newcrop.Destroy()
                             return
                         else:
-                            crop = [float(newcrop.ox.Value), float(newcrop.ex.Value),
-                                    float(newcrop.oy.Value), float(newcrop.ey.Value)]
+                            crop = [[float(newcrop.ox.Value), float(newcrop.ex.Value)],
+                                    [float(newcrop.oy.Value), float(newcrop.ey.Value)]]
 
                             tmpdx = float(newcrop.dx.Value)
                             tmpdy = float(newcrop.dy.Value)
@@ -6153,7 +6357,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                     newcrop.Destroy()
 
-                xmin, xmax, ymin, ymax = crop
+                [xmin, xmax], [ymin, ymax] = crop
 
                 gdal.Translate(tmpfile, fn, projWin=[xmin, ymax, xmax, ymin])
             else:
@@ -7800,7 +8004,8 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return newArray
 
-    def mask_outsidepoly(self, myvect: vector, eps:float = 0., set_nullvalue:bool=True):
+    def mask_outsidepoly(self, myvect: vector, eps:float = 0.,
+                         set_nullvalue:bool=True, method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict'):
         """
         Mask nodes outside a polygon and set values to nullvalue
 
@@ -7811,7 +8016,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         # (mesh coord, 0-based)
 
         # trouve les indices dans le polygone
-        myij = self.get_ij_inside_polygon(myvect, usemask=True, eps=eps)
+        myij = self.get_ij_inside_polygon(myvect, usemask=True, eps=eps, method=method)
 
         self.array.mask.fill(True) # Mask everything
 
@@ -7824,7 +8029,8 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.count()
 
-    def mask_insidepoly(self, myvect: vector, eps:float = 0., set_nullvalue:bool=True):
+    def mask_insidepoly(self, myvect: vector, eps:float = 0.,
+                        set_nullvalue:bool=True, method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='mpl'):
         """
         Mask nodes inside a polygon and set values to nullvalue
 
@@ -7835,7 +8041,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         # (mesh coord, 0-based)
 
         # 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=False, eps=eps, method=method)
 
         if set_nullvalue:
             # annulation des valeurs en dehors du polygone
@@ -7846,12 +8052,47 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.count()
 
+    def mask_insidepolys(self, myvects: list[vector], eps:float = 0.,
+                        set_nullvalue:bool=True, method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='mpl'):
+        """
+        Mask nodes inside a polygon and set values to nullvalue
+
+        :param myvect: target vector in global coordinates
+        """
+        # The polygon here is in world coordinates
+        # (coord will be converted back with translation, origin and dx/dy)
+        # (mesh coord, 0-based)
+
+        # trouve les indices dans le polygone
+        for myvect in myvects:
+            myij = self.get_ij_inside_polygon(myvect, usemask=False, eps=eps, method=method)
+            # masquage des mailles contenues
+            self.array.mask[myij[:,0],myij[:,1]] = True
+
+            if set_nullvalue:
+                # annulation des valeurs en dehors du polygone
+                self.array.data[myij[:,0],myij[:,1]] = self.nullvalue
+
+        self.count()
+
     # *************************************************************************************************************************
     # POSITION and VALUES associated to a vector/polygon/polyline
     # These functions can not be stored in header_wolf, because wa can use the mask of the array to limit the search
     # These functions are also present in WolfResults_2D, but they are not exactly the same due to the structure of the results
     # *************************************************************************************************************************
-    def get_xy_inside_polygon(self, myvect: vector | Polygon, usemask:bool=True):
+    def get_xy_inside_polygon(self, myvect: vector | Polygon, usemask:bool=True,
+                                  method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict'):
+
+        if method == 'mpl':
+            return self.get_xy_inside_polygon_mpl(myvect, usemask)
+        elif method == 'shapely_strict':
+            return self.get_xy_inside_polygon_shapely(myvect, usemask, strictly=True)
+        elif method == 'shapely_wboundary':
+            return self.get_xy_inside_polygon_shapely(myvect, usemask, strictly=False)
+        elif method == 'rasterio':
+            return self.get_xy_inside_polygon_rasterio(myvect, usemask)
+
+    def get_xy_inside_polygon_mpl(self, myvect: vector | Polygon, usemask:bool=True):
         """
         Return the coordinates inside a polygon
 
@@ -7880,7 +8121,10 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypointsxy
 
-    def get_xy_inside_polygon_shapely(self, myvect: vector | Polygon, usemask:bool=True):
+    def get_xy_inside_polygon_shapely(self,
+                                      myvect: vector | Polygon,
+                                      usemask:bool=True,
+                                      strictly:bool=True):
         """
         Return the coordinates inside a polygon
 
@@ -7889,15 +8133,29 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
 
         if isinstance(myvect, vector):
-            # force la mise à jour des min/max
             myvect.find_minmax()
-            polygon = myvect.asshapely_pol()
+            polygon = myvect.polygon
         elif isinstance(myvect, Polygon):
             polygon = myvect
 
+        if not is_prepared(polygon):
+            prepare(polygon) # Prepare the polygon for **faster** contains check -- VERY IMPORTANT
+            to_destroy = True
+        else:
+            to_destroy = False
         mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect)
 
-        inside = np.asarray([polygon.contains(Point(x,y)) for x,y in mypointsxy])
+        if strictly:
+            inside = contains_xy(polygon, mypointsxy[:,0], mypointsxy[:,1])
+        else:
+            points= np.array([Point(x,y) for x,y in mypointsxy])
+            boundary = polygon.boundary
+            inside = contains(polygon, points)
+            on_border = list(map(lambda point: boundary.contains(point), points))
+            inside = np.logical_or(inside, on_border)
+
+        if to_destroy:
+            destroy_prepared(polygon) # Destroy the prepared polygon
 
         mypointsxy = mypointsxy[np.where(inside)]
 
@@ -7908,6 +8166,33 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypointsxy
 
+    def get_xy_inside_polygon_rasterio(self, myvect: vector | Polygon, usemask:bool=True):
+        """
+        Return the coordinates inside a polygon
+        """
+        # force la mise à jour des min/max
+        myvect.find_minmax()
+
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect)
+
+        from rasterio.features import geometry_mask
+
+        poly = myvect.polygon
+        mask = geometry_mask([poly], out_shape=(self.nbx, self.nby),
+                             transform=self._transform_gmrio(),
+                             invert=True,
+                             all_touched=False)
+        # filter mypointsxy where mask is True
+        # mypointsij is a vector of (i,j) indices
+        mypointsxy = mypointsxy[mask[mypointsij[:, 0], mypointsij[:, 1]]]
+
+        if usemask:
+            mypointsij = mypointsij[mask[mypointsij[:, 0], mypointsij[:, 1]]]
+            mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
+            mypointsxy = mypointsxy[np.where(mymask)]
+
+        return mypointsxy
+
     def get_xy_under_polyline(self, myvect: vector, usemask:bool=True):
         """
         Return the coordinates along a polyline
@@ -7921,7 +8206,27 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypoints
 
-    def get_ij_inside_polygon(self, myvect: vector, usemask:bool=True, eps:float = 0.):
+    def get_ij_inside_polygon(self, myvect: vector | Polygon,
+                              usemask:bool=True, eps:float = 0.,
+                              method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict'):
+        """
+        Return the indices inside a polygon
+
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
+        :param eps: epsilon for the intersection
+        """
+
+        if method == 'mpl':
+            return self.get_ij_inside_polygon_mpl(myvect, usemask, eps)
+        elif method == 'shapely_strict':
+            return self.get_ij_inside_polygon_shapely(myvect, usemask, eps, strictly=True)
+        elif method == 'shapely_wboundary':
+            return self.get_ij_inside_polygon_shapely(myvect, usemask, eps, strictly=False)
+        elif method == 'rasterio':
+            return self._get_ij_inside_polygon_rasterio(myvect, usemask, eps)
+
+    def get_ij_inside_polygon_mpl(self, myvect: vector | Polygon, usemask:bool=True, eps:float = 0.):
         """
         Return the indices inside a polygon
 
@@ -7931,7 +8236,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
 
         # force la mise à jour des min/max
-        myvect.find_minmax()
+        if isinstance(myvect, vector):
+            myvect.find_minmax()
 
         mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect, eps=eps)
 
@@ -7949,32 +8255,201 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypointsij
 
-    def intersects_polygon(self, myvect: vector | Polygon, usemask:bool=True):
+    def get_ij_inside_polygon_shapely(self, myvect: vector | Polygon,
+                                      usemask:bool=True,
+                                      eps:float = 0.,
+                                      strictly:bool=True):
+        """
+        Return the indices inside a polygon with the contains method of shapely
+
+        :param myvect: target vector
+        :param usemask: limit potential nodes to unmaksed nodes
+        :param eps: epsilon for the intersection
+        :param strictly: if True, the points on the border are not considered inside
+        """
+
+        # force la mise à jour des min/max
+        if isinstance(myvect, vector):
+            myvect.find_minmax()
+            poly = myvect.polygon
+        elif isinstance(myvect, Polygon):
+            poly = myvect
+
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect, eps=eps)
+
+        if not is_prepared(poly):
+            prepare(poly)  # Prepare the polygon for **faster** contains check -- VERY IMPORTANT
+            to_destroy = True
+        else:
+            to_destroy = False
+
+        if strictly:
+            inside = contains_xy(poly, mypointsxy[:,0], mypointsxy[:,1])
+        else:
+            points= np.array([Point(x,y) for x,y in mypointsxy])
+            boundary = poly.boundary
+            inside = contains(poly, points)
+            on_border = list(map(lambda point: boundary.contains(point), points))
+            inside = np.logical_or(inside, on_border)
+
+        if to_destroy:
+            destroy_prepared(poly) # Destroy the prepared polygon
+
+        mypointsij = mypointsij[np.where(inside)]
+
+        if usemask:
+            mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
+            mypointsij = mypointsij[np.where(mymask)]
+
+        return mypointsij
+
+    def _get_ij_inside_polygon_rasterio(self, myvect: vector | Polygon, usemask:bool=True, eps:float = 0.):
+        """
+        Return the indices inside a polygon with the geometry_mask method of rasterio.
+
+        :remark: get_ij_inside_polygon_shapely is more efficient
+
+        FIXME : geometry_mask seems strange -- it does not work as documented -- RatsrIO 1.3.x
+
+        :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
+        if isinstance(myvect, vector):
+            myvect.find_minmax()
+            poly = myvect.polygon
+        elif isinstance(myvect, Polygon):
+            poly = myvect
+
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect, eps=eps)
+
+        from rasterio.features import geometry_mask
+
+        mask = geometry_mask([poly], out_shape=(self.nbx, self.nby),
+                             transform=self._transform_gmrio(),
+                             invert=True,
+                             all_touched=False)
+        # filter mypointsij where mask is True
+        # mypointsij is a vector of (i,j) indices
+        mypointsij = mypointsij[mask[mypointsij[:, 0], mypointsij[:, 1]]]
+
+        if usemask:
+            mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
+            mypointsij = mypointsij[np.where(mymask)]
+
+        return mypointsij
+
+    def intersects_polygon(self, myvect: vector | Polygon,
+                           usemask:bool=True,
+                           method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict',
+                           buffer:float= 0.) -> bool:
         """ Return True if the array intersects the polygon
 
         :param myvect: target vector
         :param usemask: limit potential nodes to unmaksed nodes
         """
 
-        return self.get_xy_inside_polygon(myvect, usemask).shape[0] > 0
+        if buffer > 0.:
+            bufvect = myvect.buffer(buffer, inplace= False)
+            return self.get_xy_inside_polygon(bufvect, usemask, method).shape[0] > 0
+        else:
+            return self.get_xy_inside_polygon(myvect, usemask, method).shape[0] > 0
 
-    def intersects_polygon_shapely(self, myvect: vector | Polygon, eps:float = 0., usemask:bool=True):
+    def intersects_polygon_shapely(self, myvect: vector | Polygon,
+                                   eps:float = 0.,
+                                   usemask:bool=True,
+                                   buffer:float= 0.) -> bool:
         """ Return True if the array intersects the polygon
 
         :param myvect: target vector
         :param usemask: limit potential nodes to unmaksed nodes
+        :param eps: epsilon for the intersection
+        :param buffer: buffer for the intersection - using buffer from Shapely [m]
+        """
+        if buffer > 0.:
+            poly = myvect.polygon.buffer(buffer)
+            return self.get_xy_inside_polygon_shapely(poly, usemask).shape[0] > 0
+        else:
+            return self.get_xy_inside_polygon_shapely(myvect, usemask).shape[0] > 0
+
+    def interects_listofpolygons(self, myvects:zone | list[vector],
+                                 usemask:bool=True,
+                                 method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict',
+                                 buffer:float= 0.) -> list[bool]:
+        """
+        Element-wise intersection with a list of polygons
         """
-        return self.get_xy_inside_polygon_shapely(myvect, usemask).shape[0] > 0
 
-    def get_ij_under_polyline(self, myvect: vector, usemask:bool=True):
+        if isinstance(myvects, zone):
+            myvects = myvects.myvectors
+        elif isinstance(myvects, list):
+            pass
+        else:
+            logging.error("Bad type")
+            return {}
+
+        return list(map(lambda x: self.intersects_polygon(x, usemask, method, buffer), myvects))
+
+    def intersects_zones(self, zones:Zones | list[zone],
+                         usemask:bool=True,
+                         method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict',
+                         buffer:float = 0.) -> list[list[bool]]:
+        """
+        Element-wise intersection with a list of zones
+        """
+
+        if isinstance(zones, Zones):
+            zones = zones.myzones
+        elif isinstance(zones, list):
+            pass
+        else:
+            logging.error("Bad type")
+            return {}
+
+        return list(map(lambda x: self.interects_listofpolygons(x, usemask, method, buffer), zones))
+
+    def get_total_area_if_intersects(self, myvects:Zones | list[vector],
+                                usemask:bool=True,
+                                method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict',
+                                buffer:float= 0.,
+                                coefficient:float = 1.) -> float | list[float]:
+        """
+        Return the area of the intersection with a list of polygons
+        """
+
+        if isinstance(myvects, Zones):
+            ret = []
+            for curzone in myvects.myzones:
+                myvects = curzone.myvectors
+                intersects = self.interects_listofpolygons(myvects, usemask, method, buffer)
+                ret.append(sum([x.area for x in myvects if intersects[myvects.index(x)]]) * coefficient)
+            return ret
+        elif isinstance(myvects, list):
+            intersects = self.interects_listofpolygons(myvects, usemask, method, buffer)
+            return sum([x.area for x in myvects if intersects[myvects.index(x)]]) * coefficient
+
+    def get_ij_under_polyline(self, myvect: vector, usemask:bool=True, step_factor:float=1.):
         """
         Return the indices along a polyline
 
         :param myvect: target vector
         :param usedmask: limit potential nodes to unmaksed nodes
+        :param step_factor: step factor for the discretization of myvect (<1 for thinner, >1 for coarser)
         """
 
-        ds = min(self.dx, self.dy)
+        if step_factor>=1.0:
+            logging.warning("Step_factor greater than 1.0 may lead to lots of missing (i,j) even if faster")
+        else:
+            def mod_fix(x, y, tol=1e-10):
+                result = np.mod(x, y)
+                return 0 if np.isclose(result, 0, atol=tol) else (y if np.isclose(result, y, atol=tol) else result)
+            assert mod_fix(1.0,step_factor)==0, "1.0 should be a multiple of step_factor"
+
+        # assert step_factor<=1., "Step factor must be <= 1"
+
+        ds = step_factor*min(self.dx, self.dy)
         pts = myvect._refine2D(ds)
 
         allij = np.asarray([self.get_ij_from_xy(curpt.x, curpt.y) for curpt in pts])
@@ -7990,7 +8465,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return allij
 
-    def get_values_insidepoly(self, myvect: vector, usemask:bool=True, getxy:bool=False):
+    def get_values_insidepoly(self, myvect: vector, usemask:bool=True, getxy:bool=False) -> tuple[np.ndarray, np.ndarray | None]:
         """
         Récupération des valeurs contenues dans un polygone
 
@@ -8005,6 +8480,44 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             return myvalues, None
 
+    def get_values_inside_listofpolygons(self, myvects:zone | list[vector], usemask:bool=True, getxy:bool=False) -> dict:
+        """
+        Récupération des valeurs contenues dans une instance Zones ou une liste de vecteurs
+        """
+
+        ret = {}
+        if isinstance(myvects, zone):
+            out = ret[myvects.myname] = {}
+            myvects = myvects.myvectors
+        elif isinstance(myvects, list):
+            out = ret
+        else:
+            logging.error("Bad type")
+            return {}
+
+        for vec in myvects:
+            out[vec.myname] = self.get_values_insidepoly(vec, usemask, getxy)
+
+
+    def get_values_inside_zones(self, zones:Zones | list[zone], usemask:bool=True, getxy:bool=False) -> dict:
+        """
+        Récupération des valeurs contenues dans une instance Zones ou une liste de "zone"
+        """
+
+        ret = {}
+        if isinstance(zones, Zones):
+            out = ret[myzones.myname] = {}
+            myzones = zones.myzones
+        elif isinstance(zones, list):
+            myzones = zones
+            out = ret
+        else:
+            logging.error("Bad type")
+            return {}
+
+        for zone in myzones:
+            out[zone.myname] = self.get_values_inside_listofpolygons(zone, usemask, getxy)
+
     def get_values_underpoly(self, myvect: vector, usemask:bool=True, getxy:bool=False):
         """
         Récupération des valeurs contenues sous une polyligne
@@ -8047,6 +8560,63 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return self.get_values_underpoly(myvect, usemask, getxy)
 
+    def count_insidepoly(self, myvect: vector,
+                         usemask:bool=True,
+                         method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict',
+                         coefficient:float = 1.):
+        """
+        Compte le nombre de valeurs contenues dans un polygone
+
+        :param myvect: target vector
+        :param usemask: (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param method: (optional) method to use
+        :param coefficient: (optional) coefficient to apply to the count (default 1.)
+        """
+
+        ij = self.get_ij_inside_polygon(myvect, usemask, method=method)
+        return ij.shape[0] * coefficient
+
+    def count_inside_listofpolygons(self, myvects:zone | list[vector],
+                                    usemask:bool=True,
+                                    method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict',
+                                    coefficient:float = 1.):
+        """
+        Compte le nombre de valeurs contenues dans une instance Zones ou une liste de vecteurs
+
+        :param myvects: target vectors or zone
+        :param usemask: (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param method: (optional) method to use
+        :param coefficient: (optional) coefficient to apply to the count (default 1.)
+        """
+
+        if isinstance(myvects, zone):
+            myvects = myvects.myvectors
+        else:
+            logging.error("Bad type")
+            return {}
+
+        return list(map(lambda vec: self.count_insidepoly(vec, usemask, method=method, coefficient=coefficient), myvects))
+
+    def count_inside_zones(self, zones:Zones | list[zone],
+                           usemask:bool=True,
+                           method:Literal['mpl', 'shapely_strict', 'shapely_wboundary', 'rasterio']='shapely_strict',
+                           coefficient:float = 1.):
+        """
+        Compte le nombre de valeurs contenues dans une instance Zones ou une liste de "zone"
+
+        :param zones: target zones or list of zones
+        :param usemask: (optional) restreint les éléments aux éléments non masqués de la matrice
+        :param method: (optional) method to use
+        :param coefficient: (optional) coefficient to apply to the count (default 1.)
+        """
+
+        if isinstance(zones, Zones):
+            zones = zones.myzones
+        else:
+            logging.error("Bad type")
+
+        return list(map(lambda loczone: self.count_inside_listofpolygons(loczone, usemask, method=method, coefficient=coefficient), zones))
+
     # *************************************************************************************************************************
     # END POSITION and VALUES associated to a vector/polygon/polyline
     # *************************************************************************************************************************
@@ -9073,7 +9643,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 self.mypal.isopop(self.get_working_array(), self.nbnotnull)
 
-        if VERSION_RGB==1 :
+        if VERSION_RGB==1 or which == 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, WOLF_ARRAY_FULL_UINTEGER8]:
                 # FIXME: Currently, only some types are supported in Cython/OpenGL library
@@ -9098,7 +9668,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                 self._tmp_float32 = None
 
 
-        if VERSION_RGB==1 :
+        if VERSION_RGB==1 or which == 1:
             if self.shading:
                 pond = (self.shaded.array-.5)*2.
                 pmin = (1. - self.shaded.alpha) * self.rgb
@@ -9107,7 +9677,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                     self.rgb[pond<0,i] = self.rgb[pond<0,i] * (1.+pond[pond<0]) - pmin[pond<0,i] * pond[pond<0]
                     self.rgb[pond>0,i] = self.rgb[pond>0,i] * (1.-pond[pond>0]) + pmax[pond>0,i] * pond[pond>0]
 
-        if VERSION_RGB==1 : self.rgb[self.array.mask] = [1., 1., 1., 0.]
+        if VERSION_RGB==1 or which == 1: self.rgb[self.array.mask] = [1., 1., 1., 0.]
 
         if self.myops is not None:
             # update the wx
@@ -9254,22 +9824,94 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.mygrid = {}
         self.gridmaxscales = -1
 
-    def plot_matplotlib(self, figax:tuple=None, getdata_im:bool=False):
+    def plot_matplotlib(self, figax:tuple=None,
+                        getdata_im:bool=False,
+                        update_palette:bool=True,
+                        vmin:float=None, vmax:float=None,
+                        figsize:tuple=None,
+                        Walonmap:bool=False,
+                        cat:str='IMAGERIE/ORTHO_2022_ETE'):
         """
         Plot the array - Matplotlib version
 
         Using imshow and RGB array
+
+        Plot the array using Matplotlib.
+        This method visualizes the array data using Matplotlib's `imshow` function.
+        It supports optional overlays, custom palettes, and value range adjustments.
+
+        Notes:
+        ------
+        - The method applies a mask to the data using the `nullvalue` attribute before plotting.
+        - If `Walonmap` is True, the method fetches and overlays a map image using the WalOnMap service.
+        - The aspect ratio of the plot is set to 'equal'.
+
+        :param figax: A tuple containing a Matplotlib figure and axis (fig, ax). If None, a new figure and axis are created.
+        :type figax: tuple, optional (Default value = None)
+        :param getdata_im: If True, returns the image object along with the figure and axis. Default is False, then it only returns (fig, ax).
+        :type getdata_im: bool, optional (Default value = False)
+        :param update_palette: If True, updates the color palette before plotting. Default is True.
+        :type update_palette: bool, optional (Default value = True)
+        :param vmin: Minimum value for color scaling. If None, the minimum value is determined automatically. Default is None.
+        :type vmin: float, optional (Default value = None)
+        :param vmax: Maximum value for color scaling. If None, the maximum value is determined automatically. Default is None.
+        :type vmax: float, optional (Default value = None)
+        :param figsize: Size of the figure in inches (width, height). Only used if `figax` is None. Default is None.
+        :type figsize: tuple, optional (Default value = None)
+        :param Walonmap: If True, overlays a map image using the WalOnMap service. Default is False.
+        :type Walonmap: bool, optional (Default value = False)
+        :param cat: The category of the map to fetch from the WalOnMap service. Default is 'IMAGERIE/ORTHO_2022_ETE'.
+            Available orthos:
+            - `'IMAGERIE/ORTHO_1971'`
+            - `'IMAGERIE/ORTHO_1994_2000'`
+            - `'IMAGERIE/ORTHO_2006_2007'`
+            - `'IMAGERIE/ORTHO_2009_2010'`
+            - `'IMAGERIE/ORTHO_2012_2013'`
+            - `'IMAGERIE/ORTHO_2015'`
+            - `'IMAGERIE/ORTHO_2016'`
+            - `'IMAGERIE/ORTHO_2017'`
+            - `'IMAGERIE/ORTHO_2018'`
+            - `'IMAGERIE/ORTHO_2019'`
+            - `'IMAGERIE/ORTHO_2020'`
+            - `'IMAGERIE/ORTHO_2021'`
+            - `'IMAGERIE/ORTHO_2022_PRINTEMPS'`
+            - `'IMAGERIE/ORTHO_2022_ETE'`
+            - `'IMAGERIE/ORTHO_2023_ETE'`
+            - `'IMAGERIE/ORTHO_LAST'`
+        :type cat: str, optional (Default value = `'IMAGERIE/ORTHO_2022_ETE'`)
+        :return: If `getdata_im` is False, returns (fig, ax), where `fig` is the Matplotlib figure and `ax` is the axis. If `getdata_im` is True, returns (fig, ax, im), where `im` is the image object created by `imshow`.
+        :rtype: tuple
         """
 
         self.mask_data(self.nullvalue)
-        self.updatepalette(0)
+        if update_palette:
+            self.updatepalette(0)
+
         if figax is None:
-            fig, ax = plt.subplots()
+            fig, ax = plt.subplots(figsize=figsize)
         else:
             fig, ax = figax
 
-        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))
+        if Walonmap:
+            from .PyWMS import getWalonmap
+            from PIL import Image
+
+            try:
+                IO_image = getWalonmap(cat, self.origx, self.origy, self.origx + self.nbx * self.dx, self.origy +self.nby * self.dy, w=1000, tofile=False) # w=self.nbx, h=self.nby
+
+                image = Image.open(IO_image)
+
+                ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(self.origx, self.origx + self.dx * self.nbx, self.origy, self.origy + self.dy * self.nby), alpha=1, origin='lower')
+            except Exception as e:
+                logging.error(_('Error while fetching the map image from WalOnMap'))
+                logging.error(e)
+
+        if (vmin is None) and (vmax is None):
+            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))
+        else:
+            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), vmin=vmin, vmax=vmax)
         ax.set_aspect('equal')
 
         if getdata_im:
@@ -9601,7 +10243,8 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return indicesX,indicesY,contourgen,interior
 
-    def imshow(self, figax:tuple[Figure, Axis] = None, cmap:Colormap = None, step_ticks=100.) -> tuple[Figure, Axis]:
+    def imshow(self, figax:tuple[Figure, Axis] = None,
+               cmap:Colormap = None, step_ticks=100.) -> tuple[Figure, Axis]:
         """
         Create Matplotlib image from WolfArray
         """
@@ -9616,11 +10259,11 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if cmap is None:
             # update local colors if not already done
-            if self[i].rgb is None:
-                self[i].updatepalette(0)
+            if self.rgb is None:
+                self.updatepalette(1)
 
             # Pointing RGB
-            colors = self[i].rgb
+            colors = self.rgb
             colors[self.array.mask,3] = 0.
             # Plot
             colors = colors.swapaxes(0,1)
@@ -9847,6 +10490,292 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return zones
 
+    def inpaint(self, mask_array:"WolfArray" = None, test_array:"WolfArray" = None,
+                ignore_last:int = 1, multiprocess:bool = True):
+        """ InPaintaing holes in the array
+
+        :param mask_array: where computation is done
+        :param test_array: used in test -- interpolation is accepted if new value is over test_array
+        :param ignore_last: number of last patches to ignore
+        :param multiprocess: use multiprocess for inpainting
+        """
+
+        from .eikonal import inpaint_array
+
+        if mask_array is None:
+            mask_array = self.array.mask
+        elif isinstance(mask_array, WolfArray):
+            mask_array = mask_array.array.data
+
+        if test_array is None:
+            test_array = np.ones(self.array.data.shape) * self.array.data.min()
+        elif isinstance(test_array, WolfArray):
+            test_array = test_array.array.data
+
+        time, wl_np, wd_np = inpaint_array(self.array.data,
+                                            mask_array,
+                                            test_array,
+                                            ignore_last_patches= ignore_last,
+                                            dx = self.dx,
+                                            dy = self.dy,
+                                            NoDataValue = self.nullvalue,
+                                            inplace=True,
+                                            multiprocess= multiprocess)
+
+        wd = WolfArray(mold=self)
+        wd.array[:,:] = wd_np[:,:]
+        wd.mask_data(self.nullvalue)
+
+        wl = self
+
+        self.mask_data(self.nullvalue)
+        self.reset_plot()
+        return time, wl, wd
+
+    def _inpaint_waterlevel_dem_dtm(self, dem:"WolfArray", dtm:"WolfArray",
+                                    ignore_last:int = 1, use_fortran:bool = False,
+                                    multiprocess:bool = True):
+        """ InPaintaing waterlevel holes in the array.
+
+        We use DEM and DTM to mask and constraint the inpainting process.
+
+        :param dem: Digital Elevation Model (same as simulation model)
+        :param dtm: Digital Terrain Model
+        :param ignore_last: number of last patches to ignore
+        :param use_fortran: use Fortran inpainting code
+        :param multiprocess: use multiprocess for inpainting
+        """
+
+        if use_fortran:
+            import shutil
+            from tempfile import TemporaryDirectory
+            # check if hoels.exe is available in PATH
+            if shutil.which('holes.exe') is None:
+                logging.error(_('holes.exe not found in PATH'))
+                logging.info(_('We use the Python version of inpainting'))
+                use_fortran = False
+
+            else:
+                with TemporaryDirectory() as tmpdirname:
+                    # create mask from DEM, DTM and WL
+
+                    mask = self._create_building_holes_dem_dtm(dem, dtm, ignore_last)
+
+                    # save mask and dtm to temporary files
+                    locdir = Path(tmpdirname)
+                    wl_name = locdir / 'array.bin'
+                    mask_name = locdir / 'mask.bin'
+                    dtm_name = locdir / 'dtm.bin'
+
+                    mask.write_all(mask_name)
+                    dtm.write_all(dtm_name)
+
+                    oldname = self.filename
+                    self.write_all(wl_name)
+                    self.filename = oldname
+
+                    # call holes.exe
+                    olddir = os.getcwd()
+
+                    # change to temporary directory
+                    os.chdir(locdir)
+                    shell_command = f'holes.exe inpaint in={wl_name} mask={mask_name} dem={dtm_name} avoid_last={ignore_last} out=temp'
+                    logging.info(shell_command)
+                    logging.info('Inpainting holes using holes.exe')
+                    os.system(shell_command)
+                    logging.info('Done - reading inpainted array')
+
+                    # read inpainted array
+                    wl = WolfArray(locdir / 'temp_combl.tif')
+                    wd = WolfArray(locdir / 'temp_h.tif')
+
+                    wd.array[wd.array < 0.] = 0.
+                    wd.mask_data(0.)
+
+                    os.chdir(olddir)
+
+                    self.array.data[:,:] = wl.array.data[:,:]
+
+                    time = None
+
+        if not use_fortran:
+
+            from .eikonal import inpaint_waterlevel
+
+            time, wl_np, wd_np = inpaint_waterlevel(self.array.data,
+                                                dem.array.data,
+                                                dtm.array.data,
+                                                ignore_last_patches= ignore_last,
+                                                dx = self.dx,
+                                                dy = self.dy,
+                                                NoDataValue = self.nullvalue,
+                                                inplace=True,
+                                                multiprocess= multiprocess)
+
+            wd = WolfArray(mold=self)
+            wd.array[:,:] = wd_np[:,:]
+            wd.mask_data(self.nullvalue)
+
+            wl = self
+
+        self.mask_data(self.nullvalue)
+        self.reset_plot()
+        return time, wl, wd
+
+    def count_holes(self, mask:"WolfArray" = None):
+        """ Count holes in the array """
+        from .eikonal import count_holes
+
+        if mask is None:
+            mask = self.array.mask
+        elif isinstance(mask, WolfArray):
+            mask = mask.array.data
+
+        return count_holes(mask)
+
+    def select_holes(self, mask:"WolfArray" = None, ignore_last:int = 1):
+        """ Select holes in the array """
+
+        if mask is None:
+            mask = self.array.mask
+        elif isinstance(mask, WolfArray):
+            mask = mask.array.data
+
+        labels, numfeatures = label(mask)
+
+        # count cells in holes
+        nb_cells = np.bincount(labels.ravel())
+
+        # sort by number of cells
+        idx = np.argsort(nb_cells)
+
+        for i in range(ignore_last):
+            labels[labels == idx[-1-i]] = 0
+
+        # select holes but ignoring last ones
+        ij = np.argwhere(labels)
+
+        # Convert i,j to x,y
+
+        xy = self.ij2xy_np(ij)
+
+        self.SelectionData.myselection = list(xy)
+        self.SelectionData.update_nb_nodes_selection()
+
+    def create_mask_holes(self, ignore_last:int = 1) -> "WolfArray":
+        """ Select holes in the array and create a new aray """
+
+        labels, numfeatures = label(self.array.mask)
+
+        # count cells in holes
+        nb_cells = np.bincount(labels.ravel())
+
+        # sort by number of cells
+        idx = np.argsort(nb_cells)
+
+        for i in range(ignore_last):
+            labels[labels == idx[-1-i]] = 0
+
+        newarray = WolfArray(mold=self)
+        # newarray.allocate_ressources()
+        newarray.array.data[:,:] = labels
+        newarray.array.mask[:,:] = ~labels.astype(bool)
+        newarray.set_nullvalue_in_mask()
+
+        return newarray
+
+    def create_binary_mask(self, threshold:float = 0.) -> "WolfArray":
+        """ Create a binary mask from the array """
+
+        newarray = WolfArray(mold=self)
+        newarray.array.data[:,:] = self.array.data > threshold
+        newarray.array.mask[:,:] = ~newarray.array.data.astype(bool)
+        newarray.set_nullvalue_in_mask()
+
+        return newarray
+
+    def fill_holes_with_value(self, value:float, mask:"WolfArray" = None, ignore_last:int = 1):
+        """ Fill holes in the array with a value """
+
+        if mask is None:
+            mask = self.array.mask
+
+        labels, numfeatures = label(mask)
+
+        # count cells in holes
+        nb_cells = np.bincount(labels.ravel())
+
+        # sort by number of cells
+        idx = np.argsort(nb_cells)
+
+        for i in range(ignore_last):
+            labels[labels == idx[-1-i]] = 0
+
+        self.array.data[labels > 0] = value
+        self.array.mask[labels > 0] = False # unmask filled data
+
+    def fill_holes_with_value_if_intersects(self, value:float,
+                                            vects:list[vector] | Zones,
+                                            method:Literal['matplotlib','shapely_strict', 'shapely'] = 'shapely_strict',
+                                            buffer:float = 0.):
+        """ Fill holes in the array with a value if it intersects with the mask """
+
+        if isinstance(vects, Zones):
+            vects = vects.concatenate_all_vectors()
+
+        for vec in vects:
+            self._fill_holes_with_value_if_intersects(value, vec, method, buffer)
+        # list(map(self._fill_holes_with_value_if_intersects, [value]*len(vects), vects, [method]*len(vects), [buffer]*len(vects))) # parallel version
+
+    def _fill_holes_with_value_if_intersects(self, value:float,
+                                            vect:vector,
+                                            method:Literal['matplotlib','shapely_strict', 'shapely'] = 'shapely_strict',
+                                            buffer:float = 0.) -> "WolfArray":
+
+        if buffer > 0.:
+            # As we use a buffer, we check the intersction with the buffer...
+            if self.intersects_polygon(vect, method=method, buffer=buffer):
+                # ...but we fill the original polygon, not the buffered one
+                ij = self.get_ij_inside_polygon(vect, method=method, usemask=False)
+                self.array.data[ij[:,0], ij[:,1]] = value
+                self.array.mask[ij[:,0], ij[:,1]] = False
+        else:
+            ij = self.get_ij_inside_polygon(vect, method=method, buffer=buffer, usemask=False)
+
+            if ij.size[0] > 0:
+                self.array.data[ij[:,0], ij[:,1]] = value
+                self.array.mask[ij[:,0], ij[:,1]] = False
+
+    def _create_building_holes_dem_dtm(self, dem:"WolfArray", dtm:"WolfArray", ignore_last:int = 1) -> "WolfArray":
+        """ Select holes in the array and create a new aray """
+
+        buildings = dem - dtm
+        buildings.array[buildings.array < 0.] = 0.
+        buildings.array[buildings.array > 0.] = dtm.array[buildings.array > 0.]
+        buildings.array[buildings.array == 0.] = dem.array.max() + 1.
+
+        return buildings
+
+    @classmethod
+    def merge(cls, others:list["WolfArrayMB"], abs:bool=True, copy:bool = True) -> "WolfArray":
+        """
+        Merge several WolfArray into a single WolfArray
+
+        :param others: list of WolfArray to merge
+        :param abs: if True -> Global World Coordinates
+        :param copy: if True -> copy data (**Not necessary** if data header CAN BE modified. It can be save memory)
+        """
+
+        newMBArray = WolfArrayMB()
+
+        for curarray in others:
+            newMBArray.add_block(curarray, force_idx=True, copyarray=copy)
+
+        newMBArray.set_header_from_added_blocks()
+
+        return newMBArray.as_WolfArray(abs=abs)
+
+
 class WolfArrayMB(WolfArray):
     """
     Matrice multiblocks
@@ -10073,6 +11002,7 @@ class WolfArrayMB(WolfArray):
         arr.isblock = True
         arr.blockindex = len(self.myblocks) - 1
 
+
     def share_palette(self):
         """Partage de la palette de couleurs entre matrices liées"""
         for cur in self.linkedarrays:
@@ -10775,11 +11705,26 @@ class WolfArrayMB(WolfArray):
             self.translx = 0.
             self.transly = 0.
 
+            self.head_blocks = {}
+            for curblock in self.myblocks.values():
+
+                new_trx = self.origx + self.translx
+                new_try = self.origy + self.transly
+
+                ox = curblock.origx + curblock.translx
+                oy = curblock.origy + curblock.transly
+
+                curblock.origin = (ox - new_trx, oy - new_try)
+                curblock.translation = (new_trx, new_try)
+
+                self.head_blocks[curblock.idx] = curblock.get_header()
+
     def as_WolfArray(self, abs:bool=True, forced_header:header_wolf = None) -> WolfArray:
         """
-        Convert to WolfArray
+        Convert to WolfArray -- Rebin blocks if necessary
 
-        Rebin blocks if necessary
+        :param abs: if True, then the translation is taken into account
+        :param forced_header: if not None, then the header is forced to this value
         """
 
         newArray = WolfArray()
@@ -10889,6 +11834,67 @@ class WolfArrayMB(WolfArray):
 
         return newArray
 
+    def plot_matplotlib(self, figax:tuple=None, getdata_im:bool=False, update_palette:bool=True, vmin:float=None, vmax:float=None, figsize:tuple=None, Walonmap:bool=False, cat:str='IMAGERIE/ORTHO_2022_ETE'):
+        """
+        Plot the multi-block (MB) array - Matplotlib version
+
+        Converts the MB array to single/mono-block and,
+        Uses the `plot_matplotlib` method of the WolfArray class.
+
+        Using imshow and RGB array
+
+        Plot the array using Matplotlib.
+        This method visualizes the array data using Matplotlib's `imshow` function.
+        It supports optional overlays, custom palettes, and value range adjustments.
+
+        Notes:
+        ------
+        - The method applies a mask to the data using the `nullvalue` attribute before plotting.
+        - If `Walonmap` is True, the method fetches and overlays a map image using the WalOnMap service.
+        - The aspect ratio of the plot is set to 'equal'.
+
+        :param figax: A tuple containing a Matplotlib figure and axis (fig, ax). If None, a new figure and axis are created.
+        :type figax: tuple, optional (Default value = None)
+        :param getdata_im: If True, returns the image object along with the figure and axis. Default is False, then it only returns (fig, ax).
+        :type getdata_im: bool, optional (Default value = False)
+        :param update_palette: If True, updates the color palette before plotting. Default is True.
+        :type update_palette: bool, optional (Default value = True)
+        :param vmin: Minimum value for color scaling. If None, the minimum value is determined automatically. Default is None.
+        :type vmin: float, optional (Default value = None)
+        :param vmax: Maximum value for color scaling. If None, the maximum value is determined automatically. Default is None.
+        :type vmax: float, optional (Default value = None)
+        :param figsize: Size of the figure in inches (width, height). Only used if `figax` is None. Default is None.
+        :type figsize: tuple, optional (Default value = None)
+        :param Walonmap: If True, overlays a map image using the WalOnMap service. Default is False.
+        :type Walonmap: bool, optional (Default value = False)
+        :param cat: The category of the map to fetch from the WalOnMap service. Default is 'IMAGERIE/ORTHO_2022_ETE'.
+            Available orthos:
+            - `'IMAGERIE/ORTHO_1971'`
+            - `'IMAGERIE/ORTHO_1994_2000'`
+            - `'IMAGERIE/ORTHO_2006_2007'`
+            - `'IMAGERIE/ORTHO_2009_2010'`
+            - `'IMAGERIE/ORTHO_2012_2013'`
+            - `'IMAGERIE/ORTHO_2015'`
+            - `'IMAGERIE/ORTHO_2016'`
+            - `'IMAGERIE/ORTHO_2017'`
+            - `'IMAGERIE/ORTHO_2018'`
+            - `'IMAGERIE/ORTHO_2019'`
+            - `'IMAGERIE/ORTHO_2020'`
+            - `'IMAGERIE/ORTHO_2021'`
+            - `'IMAGERIE/ORTHO_2022_PRINTEMPS'`
+            - `'IMAGERIE/ORTHO_2022_ETE'`
+            - `'IMAGERIE/ORTHO_2023_ETE'`
+            - `'IMAGERIE/ORTHO_LAST'`
+        :type cat: str, optional (Default value = `'IMAGERIE/ORTHO_2022_ETE'`)
+        :return: If `getdata_im` is False, returns (fig, ax), where `fig` is the Matplotlib figure and `ax` is the axis. If `getdata_im` is True, returns (fig, ax, im), where `im` is the image object created by `imshow`.
+        :rtype: tuple
+        """
+
+        # Convert to single block
+        single_block = self.as_WolfArray()
+
+        return single_block.plot_matplotlib(figax=figax, getdata_im=getdata_im, update_palette=update_palette, vmin=vmin, vmax=vmax, figsize=figsize, Walonmap=Walonmap, cat=cat)
+
 
 class WolfArrayMNAP(WolfArrayMB):
     """