wolfhece 2.0.55__py3-none-any.whl → 2.1.1__py3-none-any.whl

wolfhece/wolf_array.py

@@ -61,7 +61,7 @@ from .opengl.py3d import Cache_WolfArray_plot3D, WolfArray_plot3D
 WOLF_ARRAY_HILLSHAPE = -1
 WOLF_ARRAY_FULL_SINGLE = 1
 WOLF_ARRAY_FULL_DOUBLE = 2
-WOLF_ARRAY_SYM_DOUBLE = 8
+WOLF_ARRAY_SYM_DOUBLE = 12
 WOLF_ARRAY_FULL_LOGICAL = 4
 WOLF_ARRAY_CSR_DOUBLE = 5
 WOLF_ARRAY_FULL_INTEGER = 6
@@ -146,7 +146,7 @@ class header_wolf():
 
         self.head_blocks = {}
 
-        self.nullvalue = 0.
+        self._nullvalue = 0.
 
     def __str__(self) -> str:
         """ Return a string representation of the header """
@@ -168,6 +168,14 @@ class header_wolf():
 
         return ret
 
+    @property
+    def nullvalue(self):
+        return self._nullvalue
+
+    @nullvalue.setter
+    def nullvalue(self, value:float):
+        self._nullvalue = value
+
     @property
     def nbdims(self):
         if self.nbz == 0:
@@ -527,7 +535,7 @@ class header_wolf():
             return None
         elif otherbounds[0][1] < mybounds[0][0]:
             return None
-        elif otherbounds[1][1] < mybounds[0][1]:
+        elif otherbounds[1][1] < mybounds[1][0]:
             return None
         else:
             ox = max(mybounds[0][0], otherbounds[0][0])
@@ -545,20 +553,37 @@ class header_wolf():
             else:
                 return ([ox, ex], [oy, ey])
 
-    def find_union(self, other:"header_wolf") -> tuple[list[float],list[float]]:
+    def find_union(self, other:Union["header_wolf", list["header_wolf"]]) -> tuple[list[float],list[float]]:
         """
         Find the union of two header
 
         :return: tuple of two lists of two floats - ([xmin, xmax],[ymin, ymax])
         """
 
-        mybounds = self.get_bounds()
-        otherbounds = other.get_bounds()
+        if isinstance(other, list):
+
+            for cur in other:
+                assert isinstance(cur, header_wolf), _('All elements in the list must be header_wolf instances')
+
+            [ox,ex], [oy,ey] = self.get_bounds()
+
+            for cur in other:
+                otherbounds = cur.get_bounds()
 
-        ox = min(mybounds[0][0], otherbounds[0][0])
-        oy = min(mybounds[1][0], otherbounds[1][0])
-        ex = max(mybounds[0][1], otherbounds[0][1])
-        ey = max(mybounds[1][1], otherbounds[1][1])
+                ox = min(ox, otherbounds[0][0])
+                oy = min(oy, otherbounds[1][0])
+                ex = max(ex, otherbounds[0][1])
+                ey = max(ey, otherbounds[1][1])
+
+        else:
+
+            mybounds = self.get_bounds()
+            otherbounds = other.get_bounds()
+
+            ox = min(mybounds[0][0], otherbounds[0][0])
+            oy = min(mybounds[1][0], otherbounds[1][0])
+            ex = max(mybounds[0][1], otherbounds[0][1])
+            ey = max(mybounds[1][1], otherbounds[1][1])
 
         return ([ox, ex], [oy, ey])
 
@@ -773,7 +798,11 @@ class header_wolf():
         return test
 
     def align2grid(self, x1:float, y1:float, eps:float=0.0001) -> tuple[float,float]:
-        """ Align coordinates to nearest grid point """
+        """
+        Align coordinates to nearest grid point
+        where the grid is defined by the borders of the array.
+
+        """
 
         if x1-self.origx < 0:
             x2 = np.round((x1 - self.origx + eps) / self.dx) * self.dx + self.origx
@@ -793,6 +822,7 @@ class header_wolf():
                            xstart:float=None, ystart:float=None) -> list[list[float]]:
         """
         Rasterize a segment according to the grid
+        where the grid is defined by the borders of the array.
 
         :param x1: x coordinate of the first point
         :param y1: y coordinate of the first point
@@ -870,47 +900,65 @@ class header_wolf():
 
             return newvector
 
-    def get_xy_infootprint_vect(self, myvect: vector) -> np.ndarray:
+    def get_xy_infootprint_vect(self, myvect: vector, eps:float = 0.) -> tuple[np.ndarray,np.ndarray]:
         """
         Return the coordinates of the cells in the footprint of a vector
 
         :param myvect = target vector
+        :return: tuple of two numpy arrays - (coordinates, indices)
+
         """
 
-        myptsij = self.get_ij_infootprint_vect(myvect)
+        myptsij = self.get_ij_infootprint_vect(myvect, eps=eps)
         mypts=np.asarray(myptsij.copy(),dtype=np.float64)
+
         mypts[:,0] = (mypts[:,0]+.5)*self.dx +self.origx +self.translx
         mypts[:,1] = (mypts[:,1]+.5)*self.dy +self.origy +self.transly
 
         return mypts,myptsij
 
-    def get_ij_infootprint_vect(self, myvect: vector) -> np.ndarray:
+    def get_ij_infootprint_vect(self, myvect: vector, eps:float = 0.) -> np.ndarray:
         """
         Return the indices of the cells in the footprint of a vector
 
         :param myvect = target vector
+        :return : numpy array of indices
         """
 
-        i1, j1 = self.get_ij_from_xy(myvect.xmin, myvect.ymin)
-        i2, j2 = self.get_ij_from_xy(myvect.xmax, myvect.ymax)
+        i1, j1 = self.get_ij_from_xy(myvect.xmin+eps, myvect.ymin+eps)
+        i2, j2 = self.get_ij_from_xy(myvect.xmax-eps, myvect.ymax-eps)
+
         i1 = max(i1,0) # FIXME Why ??? How could i,j be negative ? --> because this fucntion can be called with a vector that is not in the array (e.g. a vector defined by clicks in the UI)
         j1 = max(j1,0)
         i2 = min(i2,self.nbx-1)
         j2 = min(j2,self.nby-1)
+
         xv,yv = np.meshgrid(np.arange(i1,i2+1),np.arange(j1,j2+1))
         mypts = np.hstack((xv.flatten()[:,np.newaxis],yv.flatten()[:,np.newaxis]))
 
         return mypts
 
     def convert_xy2ij_np(self,xy):
-        """ Convert XY coordinates to IJ indices with Numpy without any check/options """
+        """
+        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
+
+        """
+
         return np.asarray((xy[:,0]-self.origx -self.translx)/self.dx-.5,dtype=np.int32), \
                np.asarray((xy[:,1]-self.origy -self.transly)/self.dy-.5,dtype=np.int32)
 
-    def convert_ij2xy_np(self,xy):
-        """ Convert IJ indices to XY coordinates with Numpy without any check/options """
-        return np.asarray((xy[:,0]+.5)*self.dx+self.origx +self.translx ,dtype=np.float64), \
-               np.asarray((xy[:,1]+.5)*self.dy+self.origy +self.transly ,dtype=np.float64)
+    def convert_ij2xy_np(self,ij):
+        """
+        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
+
+        """
+
+        return np.asarray((ij[:,0]+.5)*self.dx+self.origx +self.translx ,dtype=np.float64), \
+               np.asarray((ij[:,1]+.5)*self.dy+self.origy +self.transly ,dtype=np.float64)
 
 class NewArray(wx.Dialog):
     """
@@ -1149,26 +1197,41 @@ class Ops_Array(wx.Frame):
         self.array_ops = wx.Notebook(self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize)
 
         #  panel Selection
+        # -----------------
+
         self.selection = wx.Panel(self.array_ops, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         self.array_ops.AddPage(self.selection, _("Selection"), True)
 
         #  panel Operations
+        # -----------------
+
         self.operation = wx.Panel(self.array_ops, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         self.array_ops.AddPage(self.operation, _("Operators"), False)
 
         #  panel Mask
+        # -----------------
+
         self.mask = wx.Panel(self.array_ops, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         self.array_ops.AddPage(self.mask, _("Mask"), False)
 
         #  panel Interpolation
+        # ---------------------
+
+        # if self.parentarray.nb_blocks>0:
+        #     self.Interpolation  = None
+        # else:
         self.Interpolation = wx.Panel(self.array_ops, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         self.array_ops.AddPage(self.Interpolation, _("Interpolation"), False)
 
         #  panel Tools/Misc
+        # -----------------
+
         self.tools = wx.Panel(self.array_ops, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         self.array_ops.AddPage(self.tools, _("Miscellaneous"), False)
 
-        #  panel PALETTE de couleurs
+        # panel PALETTE de couleurs
+        # -------------------------
+
         self.Palette = PlotPanel(self.array_ops, wx.ID_ANY, toolbar=False)
         self.palgrid = CpGrid(self.Palette, wx.ID_ANY, style=wx.WANTS_CHARS | wx.TE_CENTER)
         self.palapply = wx.Button(self.Palette, wx.ID_ANY, _("Apply"), wx.DefaultPosition, wx.DefaultSize, 0)
@@ -1205,8 +1268,18 @@ class Ops_Array(wx.Frame):
 
         self.palsave = wx.Button(self.Palette, wx.ID_ANY, _("Save to file"), wx.DefaultPosition, wx.DefaultSize, 0)
         self.palsave.SetToolTip(_('Save colormap on .pal file'))
+
+        sizer_loadpal = wx.BoxSizer(wx.HORIZONTAL)
+
         self.palload = wx.Button(self.Palette, wx.ID_ANY, _("Load from file"), wx.DefaultPosition, wx.DefaultSize, 0)
         self.palload.SetToolTip(_('Load colormap from .pal file'))
+
+        self._default_pal = wx.Button(self.Palette, wx.ID_ANY, _("Load precomputed"), wx.DefaultPosition, wx.DefaultSize, 0)
+        self._default_pal.SetToolTip(_('Load a default colormap available in the software'))
+
+        sizer_loadpal.Add(self.palload, 1, wx.EXPAND)
+        sizer_loadpal.Add(self._default_pal, 1, wx.EXPAND)
+
         self.palimage = wx.Button(self.Palette, wx.ID_ANY, _("Create image"), wx.DefaultPosition, wx.DefaultSize, 0)
         self.palimage.SetToolTip(_('Generate colormap image (horizontal, vertical or both) and save to disk'))
         self.paldistribute = wx.Button(self.Palette, wx.ID_ANY, _("Distribute"), wx.DefaultPosition, wx.DefaultSize, 0)
@@ -1240,7 +1313,7 @@ class Ops_Array(wx.Frame):
 
         self.Palette.sizer.Add(self.palchoosecolor, 1, wx.EXPAND)
         self.Palette.sizer.Add(self.palapply, 1, wx.EXPAND)
-        self.Palette.sizer.Add(self.palload, 1, wx.EXPAND)
+        self.Palette.sizer.Add(sizer_loadpal, 1, wx.EXPAND)
         self.Palette.sizer.Add(self.palsave, 1, wx.EXPAND)
         self.Palette.sizer.Add(self.palimage, 1, wx.EXPAND)
         self.Palette.sizer.Add(self.paldistribute, 1 , wx.EXPAND)
@@ -1248,6 +1321,8 @@ class Ops_Array(wx.Frame):
         self.array_ops.AddPage(self.Palette, _("Palette"), False)
 
         # HISTOGRAMMES
+        # ----------------
+
         self.histo = PlotPanel(self.array_ops, wx.ID_ANY, toolbar=True)
         self.histoupdate = wx.Button(self.histo, wx.ID_ANY, _("All data..."), wx.DefaultPosition, wx.DefaultSize, 0)
         self.histoupdatezoom = wx.Button(self.histo, wx.ID_ANY, _("On zoom..."), wx.DefaultPosition, wx.DefaultSize, 0)
@@ -1260,58 +1335,70 @@ class Ops_Array(wx.Frame):
         self.array_ops.AddPage(self.histo, _("Histogram"), False)
 
         # LINKS
+        # ----------------
+
         self.links = wx.Panel(self.array_ops, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         self.array_ops.AddPage(self.links, _("Links"), False)
 
         # Interpolation
-        gSizer1 = wx.GridSizer(0, 2, 0, 0)
-
-        self.interp2D = wx.Button(self.Interpolation, wx.ID_ANY, _("2D Interpolation on selection"), wx.DefaultPosition,
-                                  wx.DefaultSize, 0)
-        self.interp2D.SetToolTip(_('Spatial interpolation based on nodes stored in named groups. \n The interpolation apply only on the current selection.'))
-        gSizer1.Add(self.interp2D, 0, wx.EXPAND)
-        self.interp2D.Bind(wx.EVT_BUTTON, self.interpolation2D)
+        # ----------------
 
-        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'))
+        if self.Interpolation is not None:
 
-        gSizer1.Add(self.m_button7, 0, wx.EXPAND)
-        self.m_button7.Bind(wx.EVT_BUTTON, self.volumesurface)
+            gSizer1 = wx.GridSizer(0, 2, 0, 0)
 
-        self.m_button8 = wx.Button(self.Interpolation, wx.ID_ANY, _("Interpolation on active zone \n polygons"),
-                                   wx.DefaultPosition, wx.DefaultSize, 0)
-        self.m_button8.SetToolTip(_('Spatial interpolation based on all polygons in active zone'))
+            self.interp2D = wx.Button(self.Interpolation, wx.ID_ANY, _("2D Interpolation on selection"), wx.DefaultPosition,
+                                    wx.DefaultSize, 0)
+            self.interp2D.SetToolTip(_('Spatial interpolation based on nodes stored in named groups. \n The interpolation apply only on the current selection.'))
+            gSizer1.Add(self.interp2D, 0, wx.EXPAND)
+            self.interp2D.Bind(wx.EVT_BUTTON, self.interpolation2D)
 
-        gSizer1.Add(self.m_button8, 0, wx.EXPAND)
-        self.m_button8.Bind(wx.EVT_BUTTON, self.interp2Dpolygons)
+            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_button9 = wx.Button(self.Interpolation, wx.ID_ANY, _("Interpolation on active zone \n 3D polylines"),
-                                   wx.DefaultPosition, wx.DefaultSize, 0)
-        self.m_button9.SetToolTip(_('Spatial interpolation based on all polylines in active zone'))
+            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.'))
 
-        gSizer1.Add(self.m_button9, 0, wx.EXPAND)
-        self.m_button9.Bind(wx.EVT_BUTTON, self.interp2Dpolylines)
+            gSizer1.Add(self.m_button7, 0, wx.EXPAND)
+            self.m_button7.Bind(wx.EVT_BUTTON, self.volumesurface)
 
-        self.m_button10 = wx.Button(self.Interpolation, wx.ID_ANY, _("Interpolation on active vector \n polygon"),
+            self.m_button8 = wx.Button(self.Interpolation, wx.ID_ANY, _("Interpolation on active zone \n polygons"),
                                     wx.DefaultPosition, wx.DefaultSize, 0)
-        self.m_button10.SetToolTip(_('Spatial interpolation based on active polygon'))
+            self.m_button8.SetToolTip(_('Spatial interpolation based on all polygons in active zone'))
 
-        gSizer1.Add(self.m_button10, 0, wx.EXPAND)
-        self.m_button10.Bind(wx.EVT_BUTTON, self.interp2Dpolygon)
+            gSizer1.Add(self.m_button8, 0, wx.EXPAND)
+            self.m_button8.Bind(wx.EVT_BUTTON, self.interp2Dpolygons)
 
-        self.m_button11 = wx.Button(self.Interpolation, wx.ID_ANY, _("Interpolation on active vector \n 3D polyline"),
+            self.m_button9 = wx.Button(self.Interpolation, wx.ID_ANY, _("Interpolation on active zone \n 3D polylines"),
                                     wx.DefaultPosition, wx.DefaultSize, 0)
-        self.m_button11.SetToolTip(_('Spatial interpolation based on active polyline'))
+            self.m_button9.SetToolTip(_('Spatial interpolation based on all polylines in active zone'))
+
+            gSizer1.Add(self.m_button9, 0, wx.EXPAND)
+            self.m_button9.Bind(wx.EVT_BUTTON, self.interp2Dpolylines)
+
+            self.m_button10 = wx.Button(self.Interpolation, wx.ID_ANY, _("Interpolation on active vector \n polygon"),
+                                        wx.DefaultPosition, wx.DefaultSize, 0)
+            self.m_button10.SetToolTip(_('Spatial interpolation based on active polygon'))
 
-        gSizer1.Add(self.m_button11, 0, wx.EXPAND)
-        self.m_button11.Bind(wx.EVT_BUTTON, self.interp2Dpolyline)
+            gSizer1.Add(self.m_button10, 0, wx.EXPAND)
+            self.m_button10.Bind(wx.EVT_BUTTON, self.interp2Dpolygon)
 
-        self.Interpolation.SetSizer(gSizer1)
-        self.Interpolation.Layout()
-        gSizer1.Fit(self.Interpolation)
+            self.m_button11 = wx.Button(self.Interpolation, wx.ID_ANY, _("Interpolation on active vector \n 3D polyline"),
+                                        wx.DefaultPosition, wx.DefaultSize, 0)
+            self.m_button11.SetToolTip(_('Spatial interpolation based on active polyline'))
+
+            gSizer1.Add(self.m_button11, 0, wx.EXPAND)
+            self.m_button11.Bind(wx.EVT_BUTTON, self.interp2Dpolyline)
+
+            self.Interpolation.SetSizer(gSizer1)
+            self.Interpolation.Layout()
+            gSizer1.Fit(self.Interpolation)
 
         # Tools
+        # ----------------
+
         Toolssizer = wx.BoxSizer(wx.VERTICAL)
 
         hbox = wx.BoxSizer(wx.HORIZONTAL)
@@ -1322,30 +1409,36 @@ class Ops_Array(wx.Frame):
         hbox.Add(self.lbl_nullval, 0, wx.EXPAND|wx.ALL)
         hbox.Add(self.txt_nullval, 1, wx.EXPAND|wx.ALL)
 
-        self.ApplyTools = wx.Button(self.tools, wx.ID_ANY, _("Apply null value"), wx.DefaultPosition,
-                                 wx.DefaultSize, 0)
+        self.ApplyTools = wx.Button(self.tools, wx.ID_ANY, _("Apply null value"), wx.DefaultPosition,wx.DefaultSize, 0)
 
 
-        self.nullborder = wx.Button(self.tools, wx.ID_ANY, _("Null border"), wx.DefaultPosition,
-                                    wx.DefaultSize, 0)
+        self.nullborder = wx.Button(self.tools, wx.ID_ANY, _("Null border"), wx.DefaultPosition,wx.DefaultSize, 0)
 
-        self.filter_zone = wx.Button(self.tools, wx.ID_ANY, _("Filter zone"), wx.DefaultPosition,
-                                    wx.DefaultSize, 0)
+        self.filter_zone = wx.Button(self.tools, wx.ID_ANY, _("Filter zone"), wx.DefaultPosition,wx.DefaultSize, 0)
+
+        self.labelling = wx.Button(self.tools, wx.ID_ANY, _("Labelling"), wx.DefaultPosition,wx.DefaultSize, 0)
+
+        self.extract_selection = wx.Button(self.tools, wx.ID_ANY, _("Extract selection"), wx.DefaultPosition,wx.DefaultSize, 0)
 
         Toolssizer.Add(hbox, 0, wx.EXPAND)
         Toolssizer.Add(self.ApplyTools, 1, wx.EXPAND)
         Toolssizer.Add(self.nullborder, 1, wx.EXPAND)
         Toolssizer.Add(self.filter_zone, 1, wx.EXPAND)
+        Toolssizer.Add(self.labelling, 1, wx.EXPAND)
+        Toolssizer.Add(self.extract_selection, 1, wx.EXPAND)
 
-        self.ApplyTools.SetToolTip(_("Save modifications into memmory/object"))
-        self.nullborder.SetToolTip(_("Set null value on the border of the array"))
-        self.filter_zone.SetToolTip(_("Filter the array based on cotiiguous zones"))
+        self.ApplyTools.SetToolTip(_("Apply Nullvalue into memmory/object"))
+        self.nullborder.SetToolTip(_("Set null value on the border of the array\n\nYou will be asked for the width of the border (in cells)"))
+        self.filter_zone.SetToolTip(_("Filter the array based on contiguous zones\n\nConservation of the ones which contain selected nodes"))
+        self.labelling.SetToolTip(_("Labelling of contiguous zones using Scipy.label function\n\nReplacing the current values by the labels"))
+        self.extract_selection.SetToolTip(_("Extract the current selection"))
 
         self.tools.SetSizer(Toolssizer)
         self.tools.Layout()
         Toolssizer.Fit(self.tools)
 
         # Selection
+        # ----------------
 
         bSizer15 = wx.BoxSizer(wx.VERTICAL)
 
@@ -1372,7 +1465,7 @@ class Ops_Array(wx.Frame):
         self.LaunchSelection = wx.Button(self.selection, wx.ID_ANY,
                                          _("Action !"), wx.DefaultPosition,
                                          wx.DefaultSize, 0)
-        self.LaunchSelection.SetBackgroundColour((0,128,64,255))
+        # self.LaunchSelection.SetBackgroundColour((0,128,64,255))
         self.LaunchSelection.SetDefault()
         # self.LaunchSelection.SetForegroundColour((255,255,255,255))
         font = wx.Font(12, wx.FONTFAMILY_DECORATIVE, 0, 90, underline = False,faceName ="")
@@ -1413,9 +1506,35 @@ class Ops_Array(wx.Frame):
         bSizer16.Add(self.to_clipboard_str, 0, wx.EXPAND)
         bSizer16.Add(self.to_clipboard_script, 0, wx.EXPAND)
 
-        bSizer21.Add(bSizer16, 1, wx.EXPAND, 5)
+        # MultiBlocks
+        # ----------------
+        # Add a listbox to define the active blocks
+
+        if self.parentarray.nb_blocks>0:
+            self._list = wx.ListBox(self.selection,
+                                    wx.ID_ANY,
+                                    wx.DefaultPosition,
+                                    wx.DefaultSize,
+                                    [_('All')] + [str(i) for i in range(1, self.parentarray.nb_blocks+1)],
+                                    style = wx.LB_MULTIPLE | wx.LB_NEEDED_SB)
+            self._list.SetToolTip(_("Active block"))
+            bSizer16.Add(self._list, 1, wx.EXPAND)
+
+            self._list.Bind(wx.EVT_LISTBOX, self.OnBlockSelect)
+
+            # self._open_block = wx.Button(self.selection, wx.ID_ANY, _("Open block"), wx.DefaultPosition,
+            #                                 wx.DefaultSize, 0)
 
+            # self._open_block.SetToolTip(_("Open the Operation manager for the selected block"))
+            # self._open_block.Bind(wx.EVT_BUTTON, self.OnOpenBlock)
+
+            # bSizer16.Add(self._open_block, 0, wx.EXPAND)
+
+
+        bSizer21.Add(bSizer16, 1, wx.EXPAND, 5)
 
+        # VECTORS Manager
+        # ----------------
 
         bSizer17 = wx.BoxSizer(wx.VERTICAL)
 
@@ -1594,11 +1713,14 @@ class Ops_Array(wx.Frame):
         self.ApplyTools.Bind(wx.EVT_BUTTON, self.OnApplyNullvalue)
         self.nullborder.Bind(wx.EVT_BUTTON, self.OnNullBorder)
         self.filter_zone.Bind(wx.EVT_BUTTON, self.OnFilterZone)
+        self.labelling.Bind(wx.EVT_BUTTON, self.OnLabelling)
+        self.extract_selection.Bind(wx.EVT_BUTTON, self.OnExtractSelection)
 
         self.SelectOp.Bind(wx.EVT_BUTTON, self.OnApplyOpSelect)
         self.palapply.Bind(wx.EVT_BUTTON, self.Onupdatepal)
         self.palsave.Bind(wx.EVT_BUTTON, self.Onsavepal)
         self.palload.Bind(wx.EVT_BUTTON, self.Onloadpal)
+        self._default_pal.Bind(wx.EVT_BUTTON, self.Onloaddefaultpal)
         self.palimage.Bind(wx.EVT_BUTTON, self.Onpalimage)
         self.paldistribute.Bind(wx.EVT_BUTTON, self.Onpaldistribute)
         self.palchoosecolor.Bind(wx.EVT_BUTTON, self.OnClickColorPal)
@@ -1606,8 +1728,36 @@ class Ops_Array(wx.Frame):
         self.histoupdatezoom.Bind(wx.EVT_BUTTON, self.OnClickHistoUpdate)
         self.histoupdateerase.Bind(wx.EVT_BUTTON, self.OnClickHistoUpdate)
 
+    def OnBlockSelect(self, event):
+        """ Select block """
+
+        self.parentarray.active_blocks = self._list.GetSelections()
+
+    # def OnOpenBlock(self, event):
+    #     """ Open block """
+
+    #     sel = self._list.GetSelections()
+
+    #     if len(sel)==0:
+    #         logging.info('No block selected')
+    #         return
+    #     elif len(sel)>1:
+    #         logging.info('Only one block can be selected')
+    #         return
+    #     elif sel[0]==0:
+    #         logging.info('All blocks selected -- Choose only one specific block')
+    #         return
+    #     else:
+    #         keyblock = getkeyblock(sel[0], addone=False)
+
+    #         ops = self.parentarray.myblocks[keyblock].myops
+
+    #         if ops is not None:
+    #             ops.Show()
+
     def interpolation2D(self, event: wx.MouseEvent):
         """ calling Interpolation 2D """
+
         self.parentarray.interpolation2D()
 
     def Unmaskall(self, event: wx.MouseEvent):
@@ -1615,6 +1765,7 @@ class Ops_Array(wx.Frame):
         Unmask all values in the current array
         @author Pierre Archambeau
         """
+
         self.parentarray.mask_reset()
         self.refresh_array()
 
@@ -1623,201 +1774,109 @@ class Ops_Array(wx.Frame):
         Enlève le masque des éléments sélectionnés
         @author Pierre Archambeau
         """
-        curarray: WolfArray
-        curarray = self.parentarray
-
-        if len(curarray.mngselection.myselection) == 0:
-            return
-        else:
-            destxy = curarray.mngselection.myselection
-
-        destij = np.asarray([list(curarray.get_ij_from_xy(x, y)) for x, y in destxy])
 
-        curarray.array.mask[destij[:, 0], destij[:, 1]] = False
+        self.parentarray.SelectionData.Unmasksel()
 
-        self.refresh_array()
 
     def InvertMask(self, event: wx.MouseEvent):
         """ Invert mask """
+
         self.parentarray.mask_invert()
         self.refresh_array()
 
     def interp2Dpolygons(self, event: wx.MouseEvent):
         """
         Bouton d'interpolation sous tous les polygones d'une zone
-        cf _interp2Dpolygon
+        cf WolfArray.interp2Dpolygon
         """
-        choices = ["nearest", "linear", "cubic"]
-        dlg = wx.SingleChoiceDialog(None, "Pick an interpolate method", "Choices", choices)
-        ret = dlg.ShowModal()
-        if ret == wx.ID_CANCEL:
-            dlg.Destroy()
-            return
-
-        method = dlg.GetStringSelection()
-        dlg.Destroy()
-
-        actzone = self.active_zone
 
-        for curvec in actzone.myvectors:
-            curvec: vector
-            self._interp2Dpolygon(curvec, method)
-
-        self.refresh_array()
+        self.parentarray.SelectionData.interp2Dpolygons(self.active_zone)
 
     def interp2Dpolygon(self, event: wx.MouseEvent):
         """
         Bouton d'interpolation sous un polygone
-        cf _interp2Dpolygon
-        """
-        choices = ["nearest", "linear", "cubic"]
-        dlg = wx.SingleChoiceDialog(None, "Pick an interpolate method", "Choices", choices)
-        ret = dlg.ShowModal()
-        if ret == wx.ID_CANCEL:
-            dlg.Destroy()
-            return
-
-        method = dlg.GetStringSelection()
-        dlg.Destroy()
-
-        self._interp2Dpolygon(self.active_vector, method)
-
-        self.refresh_array()
-
-    def _interp2Dpolygon(self, vect: vector, method):
-        """
-        Interpolation sous un polygone
-
-        L'interpolation a lieu :
-          - 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
-        depuis les vertices 3D du polygone
+        cf WolfArray.interp2Dpolygon
         """
-        curarray: WolfArray
-        curarray = self.parentarray
-
-        if len(curarray.mngselection.myselection) == 0:
-            destxy = curarray.get_xy_inside_polygon(vect)
-        else:
-            destxy = curarray.mngselection.myselection
-
-        if len(destxy)==0:
-            return
-
-        destij = np.asarray([list(curarray.get_ij_from_xy(x, y)) for x, y in destxy])
-
-        xyz = vect.asnparray3d()
-
-        newvalues = griddata(xyz[:, :2], xyz[:, 2], destxy, method=method, fill_value=-99999.)
 
-        locmask = np.where(newvalues != -99999.)
-        curarray.array.data[destij[locmask][:, 0], destij[locmask][:, 1]] = newvalues[locmask]
+        self.parentarray.SelectionData.interp2Dpolygon(self.active_vector)
 
     def interp2Dpolylines(self, event: wx.MouseEvent):
         """
         Bouton d'interpolation sous toutes les polylignes de la zone
-        cf _interp2Dpolyline
+        cf parent.interp2Dpolyline
         """
-        actzone = self.active_zone
 
-        for curvec in actzone.myvectors:
-            curvec: vector
-            self._interp2Dpolyline(curvec)
+        self.parentarray.SelectionData.interp2Dpolylines(self.active_zone)
 
-        self.refresh_array()
 
     def interp2Dpolyline(self, event: wx.MouseEvent):
         """
         Bouton d'interpolation sous la polyligne active
-        cf _interp2Dpolyline
-        """
-        self._interp2Dpolyline(self.active_vector)
-
-        self.refresh_array()
-
-    def _interp2Dpolyline(self, vect: vector, usemask=True):
-        """
-        Interpolation sous une polyligne
-
-        L'interpolation a lieu :
-          - uniquement dans les mailles sélectionnées si elles existent
-          - dans les mailles sous la polyligne sinon
-
-        On utilise ensuite "interpolate" de shapely pour interpoler les altitudes des mailles
-        depuis les vertices 3D de la polyligne
+        cf parent.interp2Dpolyline
         """
-        curarray: WolfArray
-        curarray = self.parentarray
-
-        vecls = vect.asshapely_ls()
-        if len(curarray.mngselection.myselection) == 0:
-            allij = curarray.get_ij_under_polyline(vect, usemask)
-            allxy = [curarray.get_xy_from_ij(cur[0], cur[1]) for cur in allij]
-        else:
-            allxy = curarray.mngselection.myselection
-            allij = np.asarray([curarray.get_ij_from_xy(x,y) for x,y in allxy])
 
-        newz = np.asarray([vecls.interpolate(vecls.project(Point(x, y))).z for x, y in allxy])
-        curarray.array.data[allij[:, 0], allij[:, 1]] = newz
+        self.parentarray.SelectionData.interp2Dpolyline(self.active_vector)
 
     def volumesurface(self, event):
         """
         Click on evaluation of stage-storage-surface relation
         """
-        self._volumesurface()
-
-    def _volumesurface(self, show=True):
-        """
-        Evaluation of stage-storage-surface relation
-        """
-        if self.mapviewer is not None:
-            if self.mapviewer.linked:
-                array1 = self.mapviewer.linkedList[0].active_array
-                array2 = self.mapviewer.linkedList[1].active_array
-
-                # transfert des mailles sélectionnées dans l'autre matrice
-                if array1 is self.parentarray:
-                    array2.mngselection.myselection = array1.mngselection.myselection.copy()
-                if array2 is self.parentarray:
-                    array1.mngselection.myselection = array2.mngselection.myselection.copy()
-
-                if len(self.parentarray.mngselection.myselection) == 0 or self.parentarray.mngselection.myselection == 'all':
-                    myarray = array1
-                    axs = myarray.volume_estimation()
-                    myarray = array2
-                    axs = myarray.volume_estimation(axs)
-                else:
-                    myarray = array1.mngselection.get_newarray()
-                    axs = myarray.volume_estimation()
-                    myarray = array2.mngselection.get_newarray()
-                    axs = myarray.volume_estimation(axs)
-            else:
-                if len(self.parentarray.mngselection.myselection) == 0 or self.parentarray.mngselection.myselection == 'all':
-                    myarray = self.parentarray
-                else:
-                    myarray = self.parentarray.mngselection.get_newarray()
-                myarray.volume_estimation()
-        else:
-            if len(self.parentarray.mngselection.myselection) == 0 or self.parentarray.mngselection.myselection == 'all':
-                myarray = self.parentarray
-            else:
-                myarray = self.parentarray.mngselection.get_newarray()
-            myarray.volume_estimation()
 
-        if show:
-            plt.show()
+        self.parentarray.SelectionData.volumesurface()
+
+    # def _volumesurface(self, show=True):
+    #     """
+    #     Evaluation of stage-storage-surface relation
+    #     """
+
+    #     if self.mapviewer is not None:
+    #         if self.mapviewer.linked:
+    #             array1 = self.mapviewer.linkedList[0].active_array
+    #             array2 = self.mapviewer.linkedList[1].active_array
+
+    #             # transfert des mailles sélectionnées dans l'autre matrice
+    #             if array1 is self.parentarray:
+    #                 array2.mngselection.myselection = array1.mngselection.myselection.copy()
+    #             if array2 is self.parentarray:
+    #                 array1.mngselection.myselection = array2.mngselection.myselection.copy()
+
+    #             if len(self.parentarray.mngselection.myselection) == 0 or self.parentarray.mngselection.myselection == 'all':
+    #                 myarray = array1
+    #                 axs = myarray.volume_estimation()
+    #                 myarray = array2
+    #                 axs = myarray.volume_estimation(axs)
+    #             else:
+    #                 myarray = array1.mngselection.get_newarray()
+    #                 axs = myarray.volume_estimation()
+    #                 myarray = array2.mngselection.get_newarray()
+    #                 axs = myarray.volume_estimation(axs)
+    #         else:
+    #             if len(self.parentarray.mngselection.myselection) == 0 or self.parentarray.mngselection.myselection == 'all':
+    #                 myarray = self.parentarray
+    #             else:
+    #                 myarray = self.parentarray.mngselection.get_newarray()
+    #             myarray.volume_estimation()
+    #     else:
+    #         if len(self.parentarray.mngselection.myselection) == 0 or self.parentarray.mngselection.myselection == 'all':
+    #             myarray = self.parentarray
+    #         else:
+    #             myarray = self.parentarray.mngselection.get_newarray()
+    #         myarray.volume_estimation()
+
+    #     if show:
+    #         plt.show()
 
     def OnAllSelect(self, event):
         """
         Select all --> just put "all" in "myselection"
         """
-        self.parentarray.mngselection.myselection = 'all'
+
+        self.parentarray.SelectionData.select_all()
         self.parentarray.myops.nbselect.SetLabelText('All')
 
     def OnMoveSelect(self, event):
         """Transfert de la sélection courante dans un dictionnaire"""
+
         dlg = wx.TextEntryDialog(self, 'Choose id', 'id?')
         ret = dlg.ShowModal()
         idtxt = dlg.GetValue()
@@ -1826,13 +1885,15 @@ class Ops_Array(wx.Frame):
         ret = dlg.ShowModal()
         color = dlg.GetColourData()
 
-        self.parentarray.mngselection.move_selectionto(idtxt, color.GetColour())
+        self.parentarray.SelectionData.move_selectionto(idtxt, color.GetColour())
 
     def reset_selection(self):
         """
         Reset of current selection
         """
-        self.parentarray.mngselection.myselection = []
+
+        self.parentarray.SelectionData.reset()
+
         self.nbselect.SetLabelText('0')
         self.minx.SetLabelText('0')
         self.miny.SetLabelText('0')
@@ -1843,13 +1904,15 @@ class Ops_Array(wx.Frame):
         """
         Reset of current selection and stored ones
         """
+
         self.reset_selection()
-        self.parentarray.mngselection.selections = {}
+        self.parentarray.SelectionData.reset_all()
 
     def OnResetSelect(self, event):
         """
         Click on Reset of current selection
         """
+
         self.reset_selection()
         self.refresh_array()
 
@@ -1857,6 +1920,7 @@ class Ops_Array(wx.Frame):
         """
         Click on reset all
         """
+
         self.reset_all_selection()
         self.refresh_array()
 
@@ -1874,7 +1938,7 @@ class Ops_Array(wx.Frame):
 
             selectobj = self.parentarray.mngselection
 
-            if len(selectobj.selections) > 0:
+            if selectobj.nb > 0:
                 choices = [_("Current selection")]
                 for cur in selectobj.selections.items():
                     choices.append(cur[0])
@@ -1934,10 +1998,11 @@ class Ops_Array(wx.Frame):
         # condition value
         curcondvalue = float(self.condvalue.GetValue())
 
-        self.parentarray.mngselection.condition_select(curcond, curcondvalue)
+        self.parentarray.SelectionData.condition_select(curcond, curcondvalue)
 
     def OnApplyNullvalue(self, event:wx.MouseEvent):
         """ Apply null value to the array """
+
         newnull = self.txt_nullval.Value
         if newnull.lower() == 'nan':
             newnull = np.nan
@@ -1945,12 +2010,14 @@ class Ops_Array(wx.Frame):
             newnull = float(newnull)
 
         if self.parentarray.nullvalue!= newnull:
+
             self.parentarray.nullvalue = newnull
             self.parentarray.mask_data(newnull)
             self.refresh_array()
 
     def refresh_array(self):
         """ Force refresh of the parent array """
+
         if self.parentarray is not None:
             self.parentarray.reset_plot()
 
@@ -1971,8 +2038,19 @@ class Ops_Array(wx.Frame):
     def OnFilterZone(self, event:wx.MouseEvent):
         """ Filter the array based on contiguous zones """
 
+        pass
         self.parentarray.filter_zone()
 
+    def OnLabelling(self, event:wx.MouseEvent):
+        """ Labelling of contiguous zones """
+
+        self.parentarray.labelling()
+
+    def OnExtractSelection(self, event:wx.MouseEvent):
+        """ Extract the current selection """
+
+        self.parentarray.extract_selection()
+
     def OnApplyOpMath(self, event:wx.MouseEvent):
         """ Apply math operator to the array """
 
@@ -1995,7 +2073,7 @@ class Ops_Array(wx.Frame):
         else:
             curcondvalue = float(curcondvalue)
 
-        self.parentarray.mngselection.treat_select(curop, curcond, curopvalue, curcondvalue)
+        self.parentarray.SelectionData.treat_select(curop, curcond, curopvalue, curcondvalue)
 
     def Onmask(self, event:wx.MouseEvent):
         """ Mask nodes based on condition """
@@ -2006,7 +2084,7 @@ class Ops_Array(wx.Frame):
         curopvalue = float(self.opvalue.GetValue())
         curcondvalue = float(self.condvalue.GetValue())
 
-        self.parentarray.mngselection.mask_condition(curop, curcond, curopvalue, curcondvalue)
+        self.parentarray.SelectionData.mask_condition(curop, curcond, curopvalue, curcondvalue)
         self.refresh_array()
 
     def OnManageVectors(self, event:wx.MouseEvent):
@@ -2122,7 +2200,7 @@ class Ops_Array(wx.Frame):
         """ Select nodes inside a vector or set action to add vertices to a vector by clicks"""
 
         if vect.nbvertices > 2:
-            self.parentarray.mngselection.select_insidepoly(vect)
+            self.parentarray.SelectionData.select_insidepoly(vect)
 
         elif self.mapviewer is not None:
             if vect.nbvertices < 3:
@@ -2160,7 +2238,7 @@ class Ops_Array(wx.Frame):
         """ Select nodes along a vector or set action to add vertices to a vector by clicks """
 
         if vect.nbvertices > 1:
-            self.parentarray.mngselection.select_underpoly(vect)
+            self.parentarray.SelectionData.select_underpoly(vect)
 
         elif self.mapviewer is not None:
             if vect.nbvertices < 2:
@@ -2239,6 +2317,7 @@ class Ops_Array(wx.Frame):
 
     def onclose(self, event:wx.MouseEvent):
         """ Hide the window """
+
         self.Hide()
 
     def onshow(self, event:wx.MouseEvent):
@@ -2291,6 +2370,7 @@ class Ops_Array(wx.Frame):
 
     def Onloadpal(self, event:wx.MouseEvent):
         """ Load palette from file """
+
         myarray: WolfArray
         myarray = self.parentarray
         myarray.mypal.readfile()
@@ -2300,6 +2380,36 @@ class Ops_Array(wx.Frame):
 
         self.refresh_array()
 
+    def Onloaddefaultpal(self, event:wx.MouseEvent):
+        """ Load default palette """
+
+        import glob
+
+        # list of all .pal file in model directory
+
+        dirpal = os.path.join(os.path.dirname(__file__), 'models')
+
+        listpal = glob.glob(dirpal + '/*.pal')
+
+        if len(listpal) == 0:
+            logging.info('No default palette found')
+            return
+
+        listpal = [os.path.basename(i) for i in listpal]
+
+        dlg = wx.SingleChoiceDialog(None, 'Choose the default palette', 'Default palette', listpal)
+        ret = dlg.ShowModal()
+
+        if ret == wx.ID_CANCEL:
+            dlg.Destroy()
+
+        self.parentarray.mypal.readfile(dirpal + '/' + dlg.GetStringSelection())
+
+        self.parentarray.mypal.automatic = False
+        self.palauto.SetValue(0)
+
+        self.refresh_array()
+
     def Onpalimage(self, event:wx.MouseEvent):
         """ Create image from palette """
         myarray: WolfArray
@@ -2432,19 +2542,17 @@ class SelectionData():
 
     The selected nodes are stored using their "world" spatial coordinates so that they can be easily transferred to other objects.
     """
+
     myselection:list[tuple[float, float]]
     selections: dict[str:dict['select':list[tuple[float, float]], 'idgllist':int, 'color':list[float]]]
 
     def __init__(self, parent:"WolfArray") -> None:
+
         self.parent: WolfArray
         self.parent = parent
 
         self.wx_exists = wx.GetApp() is not None
 
-        #copy of the resolution
-        self.dx = parent.dx
-        self.dy = parent.dy
-
         self.myselection = []
         self.selections = {}
 
@@ -2452,6 +2560,59 @@ class SelectionData():
         self.hideselection = False
         self.numlist_select = 0 # OpenGL list index
 
+    @property
+    def dx(self) -> float:
+        """ Resolution in x """
+
+        if self.parent is None:
+            return 0.
+        else:
+            return self.parent.dx
+
+    @property
+    def dy(self) -> float:
+        """ Resolution in y """
+
+        if self.parent is None:
+            return 0.
+        else:
+            return self.parent.dy
+
+    @property
+    def nb(self) -> int:
+        """ Number of selected nodes """
+
+        return len(self.myselection)
+
+    def Unmasksel(self, resetplot:bool=True):
+        """ Unmask selection """
+
+        curarray: WolfArray
+        curarray = self.parent
+
+        if self.nb == 0:
+            return
+        else:
+            destxy = self.myselection
+
+        destij = np.asarray([list(curarray.get_ij_from_xy(x, y)) for x, y in destxy])
+
+        curarray.array.mask[destij[:, 0], destij[:, 1]] = False
+
+        if resetplot:
+            curarray.reset_plot()
+
+    def reset(self):
+        """ Reset the selection """
+
+        self.myselection = []
+
+    def reset_all(self):
+        """ Reset the selection """
+
+        self.myselection = []
+        self.selections = {}
+
     def get_string(self, which:str = None) -> str:
         """ Get string of the current selection or of a stored one """
 
@@ -2536,7 +2697,7 @@ class SelectionData():
                 logging.warning(_('Cannot open the clipboard'))
 
 
-    def move_selectionto(self, idx:str, color:list[float]):
+    def move_selectionto(self, idx:str, color:list[float], resetplot:bool=True):
         """
         Transfer current selection to dictionary
 
@@ -2556,7 +2717,10 @@ class SelectionData():
         curdict['color'] = color
 
         self.myselection = []   # reset current selection
-        self.update_nb_nodes_sections()
+        self.update_nb_nodes_selection()
+
+        if resetplot:
+            self.parent.reset_plot()
 
     def plot_selection(self):
         """ Plot current selection and stored selections """
@@ -2594,6 +2758,10 @@ class SelectionData():
 
         #FIXME : Is it a good idea to use SHADER rather than list ?
         if self.update_plot_selection:
+
+            dx = self.dx
+            dy = self.dy
+
             if loclist != 0:
                 glDeleteLists(loclist, 1)
 
@@ -2603,10 +2771,10 @@ class SelectionData():
             glPolygonMode(GL_FRONT_AND_BACK, GL_FILL)
             glBegin(GL_QUADS)
             for cursel in curlist:
-                x1 = cursel[0] - self.dx / 2.
-                x2 = cursel[0] + self.dx / 2.
-                y1 = cursel[1] - self.dy / 2.
-                y2 = cursel[1] + self.dy / 2.
+                x1 = cursel[0] - dx / 2.
+                x2 = cursel[0] + dx / 2.
+                y1 = cursel[1] - dy / 2.
+                y2 = cursel[1] + dy / 2.
                 glColor3f(color[0], color[1], color[2])
                 glVertex2f(x1, y1)
                 glVertex2f(x2, y1)
@@ -2617,10 +2785,10 @@ class SelectionData():
             glPolygonMode(GL_FRONT_AND_BACK, GL_LINE)
             for cursel in curlist:
                 glBegin(GL_LINE_STRIP)
-                x1 = cursel[0] - self.dx / 2.
-                x2 = cursel[0] + self.dx / 2.
-                y1 = cursel[1] - self.dy / 2.
-                y2 = cursel[1] + self.dy / 2.
+                x1 = cursel[0] - dx / 2.
+                x2 = cursel[0] + dx / 2.
+                y1 = cursel[1] - dy / 2.
+                y2 = cursel[1] + dy / 2.
                 glColor3f(0., 1., 0.)
                 glVertex2f(x1, y1)
                 glVertex2f(x2, y1)
@@ -2653,7 +2821,10 @@ class SelectionData():
 
         if self.parent.check_bounds_ij(i, j):
         # if i>=0 and j>=0 and i<self.parent.nbx and j<self.parent.nby:
-            self.add_node_to_selectionij(i, j, verif)
+            self._add_node_to_selectionij(i, j, verif)
+            return 0 # useful for MB
+        else:
+            return -1 # useful for MB
 
     def add_nodes_to_selection(self, xy:list[float], verif:bool=True):
         """
@@ -2666,9 +2837,9 @@ class SelectionData():
         # on repasse par les i,j car les coordonnées transférées peuvent venir d'un click souris
         # le but est de ne conserver que les coordonnées des CG de mailles
         ij = [self.parent.get_ij_from_xy(x, y) for x, y in xy]
-        self.add_nodes_to_selectionij(ij, verif)
+        self._add_nodes_to_selectionij(ij, verif)
 
-    def add_node_to_selectionij(self, i:int, j:int, verif=True):
+    def _add_node_to_selectionij(self, i:int, j:int, verif=True):
         """
         Add one ij coordinate to the selection
 
@@ -2676,6 +2847,7 @@ class SelectionData():
         :param j: j coordinate
         :param verif: if True, the coordinates are checked to avoid duplicates
         """
+
         x1, y1 = self.parent.get_xy_from_ij(i, j)
 
         if isinstance(self.myselection, str):
@@ -2688,12 +2860,16 @@ class SelectionData():
                 ret = -1
             if ret >= 0:
                 self.myselection.pop(ret)
+
+                return 0
             else:
                 self.myselection.append((x1, y1))
+                return 0
         else:
             self.myselection.append((x1, y1))
+            return 0
 
-    def add_nodes_to_selectionij(self, ij:list[tuple[float, float]], verif:bool=True):
+    def _add_nodes_to_selectionij(self, ij:list[tuple[float, float]], verif:bool=True):
         """
         Add multiple ij coordinates to the selection
 
@@ -2742,7 +2918,7 @@ class SelectionData():
         nbini = len(self.myselection)
 
         myvect.find_minmax()
-        mypoints,_ = self.parent.get_xy_infootprint_vect(myvect)
+        mypoints, _tmpij = self.parent.get_xy_infootprint_vect(myvect)
         path = mpltPath.Path(myvect.asnparray())
         inside = path.contains_points(mypoints)
 
@@ -2759,7 +2935,7 @@ class SelectionData():
                     self.condition_select('Mask',0)
 
         self.hideselection=False
-        self.update_nb_nodes_sections()
+        self.update_nb_nodes_selection()
 
     def select_underpoly(self, myvect: vector):
         """ Select nodes along a polyline """
@@ -2769,16 +2945,17 @@ class SelectionData():
         myvect.find_minmax()
         mypoints = self.parent.get_ij_under_polyline(myvect)
 
-        self.add_nodes_to_selectionij(mypoints, verif=nbini != 0)
+        self._add_nodes_to_selectionij(mypoints, verif=nbini != 0)
 
         if self.parent.myops is not None:
             if self.parent.myops.selectrestricttomask.IsChecked():
                 self.condition_select('Mask',0)
 
-        self.update_nb_nodes_sections()
+        self.update_nb_nodes_selection()
 
-    def update_nb_nodes_sections(self):
+    def update_nb_nodes_selection(self):
         """ Update the number of selected nodes """
+
         if self.myselection=='all':
             nb = self.parent.nbnotnull
         else:
@@ -2800,13 +2977,31 @@ class SelectionData():
         else:
             self.update_plot_selection = True
 
+        if nb>0:
+            if self.myselection=='all':
+                [xmin, xmax], [ymin, ymax] = self.parent.get_bounds()
+            else:
+                xmin = np.min(np.asarray(self.myselection)[:, 0])
+                ymin = np.min(np.asarray(self.myselection)[:, 1])
+                xmax = np.max(np.asarray(self.myselection)[:, 0])
+                ymax = np.max(np.asarray(self.myselection)[:, 1])
+        else:
+            xmin = -99999.
+            ymin = -99999.
+            xmax = -99999.
+            ymax = -99999.
+
         if self.parent.myops is not None:
+
             self.parent.myops.nbselect.SetLabelText(str(nb))
             if nb>0:
-                self.parent.myops.minx.SetLabelText(str(np.min(np.asarray(self.myselection)[:, 0])))
-                self.parent.myops.miny.SetLabelText(str(np.min(np.asarray(self.myselection)[:, 1])))
-                self.parent.myops.maxx.SetLabelText(str(np.max(np.asarray(self.myselection)[:, 0])))
-                self.parent.myops.maxy.SetLabelText(str(np.max(np.asarray(self.myselection)[:, 1])))
+
+                self.parent.myops.minx.SetLabelText('{:.3f}'.format(xmin))
+                self.parent.myops.miny.SetLabelText('{:.3f}'.format(ymin))
+                self.parent.myops.maxx.SetLabelText('{:.3f}'.format(xmax))
+                self.parent.myops.maxy.SetLabelText('{:.3f}'.format(ymax))
+
+        return nb, xmin, xmax, ymin, ymax
 
     def condition_select(self, cond, condval, condval2=0, usemask=False):
         array = self.parent.array
@@ -2867,7 +3062,7 @@ class SelectionData():
                         # interval without equality
                         ij = np.argwhere(((array<condval) | (array>condval2)) & mask)
 
-                    self.add_nodes_to_selectionij(ij, nbini != 0)
+                    self._add_nodes_to_selectionij(ij, nbini != 0)
                 except:
                     logging.error(_('Error in condition_select -- nbini == 0 ! -- Please report this bug, specifying the context'))
                     return
@@ -2904,7 +3099,7 @@ class SelectionData():
                         ij = np.argwhere(((array[ijall[:, 0], ijall[:, 1]]<condval) | (array[ijall[:, 0], ijall[:, 1]]>condval2)) & (mask[ijall[:, 0], ijall[:, 1]]))
 
                     ij = ij.flatten()
-                    self.add_nodes_to_selectionij(ijall[ij], nbini != 0)
+                    self._add_nodes_to_selectionij(ijall[ij], nbini != 0)
                 except:
                     logging.error(_('Error in condition_select ! -- Please report this bug, specifying the context'))
                     return
@@ -2945,7 +3140,7 @@ class SelectionData():
                         # Mask
                         ij = np.argwhere(np.logical_not(array.mask))
 
-                    self.add_nodes_to_selectionij(ij, nbini != 0)
+                    self._add_nodes_to_selectionij(ij, nbini != 0)
                 except:
                     logging.error(_('Error in condition_select -- nbini == 0 ! -- Please report this bug, specifying the context'))
                     return
@@ -2989,12 +3184,12 @@ class SelectionData():
                         ij = np.argwhere(np.logical_not(array.mask[ijall[:, 0], ijall[:, 1]]))
 
                     ij = ij.flatten()
-                    self.add_nodes_to_selectionij(ijall[ij], nbini != 0)
+                    self._add_nodes_to_selectionij(ijall[ij], nbini != 0)
                 except:
                     logging.error(_('Error in condition_select ! -- Please report this bug, specifying the context'))
                     return
 
-        self.update_nb_nodes_sections()
+        self.update_nb_nodes_selection()
 
     def treat_select(self, op, cond, opval, condval):
         # operationChoices = [ u"+", u"-", u"*", u"/", u"replace'" ]
@@ -3289,34 +3484,48 @@ class SelectionData():
 
         return z
 
-    def get_header(self):
-        array: WolfArray
+    def _get_header(self):
+        """ Header corresponding to the selection """
 
         array = self.parent
         sel = np.asarray(self.myselection)
 
         myhead = header_wolf()
 
-        myhead.dx = array.dx
-        myhead.dy = array.dy
-        myhead.translx = 0.  # array.translx
-        myhead.transly = 0.  # array.transly
+        if self.dx == 0. or self.dy == 0.:
+            logging.error(_('dx or dy is null in get_header - Abort !'))
+            return None
+
+        myhead.dx = self.dx
+        myhead.dy = self.dy
+        myhead.translx = 0.
+        myhead.transly = 0.
 
-        myhead.origx = np.amin(sel[:, 0]) - array.dx / 2.
-        myhead.origy = np.amin(sel[:, 1]) - array.dy / 2.
+        myhead.origx = np.amin(sel[:, 0]) - self.dx / 2.
+        myhead.origy = np.amin(sel[:, 1]) - self.dy / 2.
 
-        ex = np.amax(sel[:, 0]) + array.dx / 2.
-        ey = np.amax(sel[:, 1]) + array.dy / 2.
+        ex = np.amax(sel[:, 0]) + self.dx / 2.
+        ey = np.amax(sel[:, 1]) + self.dy / 2.
 
-        myhead.nbx = int((ex - myhead.origx) / array.dx)
-        myhead.nby = int((ey - myhead.origy) / array.dy)
+        myhead.nbx = int((ex - myhead.origx) / self.dx)
+        myhead.nby = int((ey - myhead.origy) / self.dy)
 
         return myhead
 
     def get_newarray(self):
+        """ Create a new array from the selection """
+
+        if self.nb == 0:
+            return None
 
         newarray = WolfArray()
-        newarray.init_from_header(self.get_header())
+
+        lochead = self._get_header()
+        if lochead is None:
+            logging.error(_('Error in get_newarray !'))
+            return
+
+        newarray.init_from_header(self._get_header())
 
         sel = np.asarray(self.myselection)
         if len(sel) == 1:
@@ -3333,6 +3542,325 @@ class SelectionData():
 
         return newarray
 
+    def select_all(self):
+        """ Select all nodes """
+
+        self.myselection = 'all'
+        self.update_nb_nodes_selection()
+
+    def interp2Dpolygons(self, working_zone:zone, method:Literal["nearest", "linear", "cubic"] = None, resetplot:bool = True):
+        """
+        Interpolation sous tous les polygones d'une zone
+        cf parent.interp2Dpolygon
+        """
+
+        if method is None:
+            choices = ["nearest", "linear", "cubic"]
+            dlg = wx.SingleChoiceDialog(None, "Pick an interpolate method", "Choices", choices)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            method = dlg.GetStringSelection()
+            dlg.Destroy()
+
+        self.parent.interpolate_on_polygons(working_zone, method)
+
+        if resetplot:
+            self.parent.reset_plot()
+
+    def interp2Dpolygon(self, working_vector:vector, method:Literal["nearest", "linear", "cubic"] = None, resetplot:bool = True):
+        """
+        Interpolation sous un polygone
+        cf parent.interp2Dpolygon
+        """
+
+        if method is None:
+            choices = ["nearest", "linear", "cubic"]
+            dlg = wx.SingleChoiceDialog(None, "Pick an interpolate method", "Choices", choices)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            method = dlg.GetStringSelection()
+            dlg.Destroy()
+
+        self.parent.interpolate_on_polygon(working_vector, method)
+
+        if resetplot:
+            self.parent.reset_plot()
+
+    def interp2Dpolylines(self, working_zone:zone, resetplot:bool = True):
+        """
+        Interpolation sous toutes les polylignes de la zone
+        cf parent.interp2Dpolyline
+        """
+
+        self.parent.interpolate_on_polylines(working_zone)
+
+        if resetplot:
+            self.parent.reset_plot()
+
+    def interp2Dpolyline(self, working_vector:vector, resetplot:bool = True):
+        """
+        Interpolation sous la polyligne active
+        cf parent.interp2Dpolyline
+        """
+
+        self.parent.interpolate_on_polyline(working_vector)
+
+        if resetplot:
+            self.parent.reset_plot()
+
+
+    def copy(self, source:"SelectionData"):
+
+        self.myselection = source.myselection.copy()
+
+    def volumesurface(self, show=True):
+        """
+        Evaluation of stage-storage-surface relation
+        """
+
+        if self.parent.get_mapviewer() is not None:
+
+            mapviewer = self.parent.get_mapviewer()
+
+            if mapviewer.linked:
+
+                array1:WolfArray = mapviewer.linkedList[0].active_array
+                array2:WolfArray = mapviewer.linkedList[1].active_array
+
+                # transfert des mailles sélectionnées dans l'autre matrice
+                if array1 is self.parent:
+                    array2.SelectionData.copy(array1.SelectionData)
+
+                if array2 is self.parent:
+                    array1.SelectionData.copy(array2.SelectionData)
+
+                if self.nb == 0 or self.myselection == 'all':
+                    myarray = array1
+                    axs = myarray.volume_estimation()
+
+                    myarray = array2
+                    axs = myarray.volume_estimation(axs)
+                else:
+                    myarray = array1.mngselection.get_newarray()
+                    axs = myarray.volume_estimation()
+
+                    myarray = array2.mngselection.get_newarray()
+                    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.volume_estimation()
+        else:
+            if self.nb == 0 or self.myselection == 'all':
+                myarray = self.parent
+            else:
+                myarray = self.get_newarray()
+
+            myarray.volume_estimation()
+
+        if show:
+            plt.show()
+
+class SelectionDataMB(SelectionData):
+    """ Extension of SelectionData to manage multiple blocks """
+
+    def __init__(self, parent:"WolfArrayMB"):
+        SelectionData.__init__(self, parent)
+
+        self.parent:"WolfArrayMB" = parent
+
+    @property
+    def nb(self):
+
+        return np.sum([cur.SelectionData.nb for cur in self.parent.active_blocks])
+
+    def Unmasksel(self):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.Unmasksel(resetplot=False)
+
+        self.parent.reset_plot()
+
+    def reset(self):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.reset()
+
+    def select_all(self):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.select_all()
+
+    def reset_all(self):
+        """ Reset the selection """
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.reset_all()
+
+    def get_string(self, which:str = None) -> str:
+
+        logging.error(_('Not yet implemented for Multi-Blocks'))
+
+    def get_script(self, which:int = None) -> str:
+
+        logging.error(_('Not yet implemented for Multi-Blocks'))
+
+    def get_newarray(self):
+
+        logging.error(_('Not yet implemented for Multi-Blocks'))
+
+    def add_node_to_selection(self, x:float, y:float, verif:bool=True):
+        """ Add a node to the selection """
+
+        for curblock in self.parent.active_blocks:
+            ret = curblock.SelectionData.add_node_to_selection(x, y, verif)
+
+    def add_nodes_to_selection(self, xy:list[float], verif:bool=True):
+        """ Add nodes to the selection """
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.add_nodes_to_selection(xy, verif)
+
+    def select_insidepoly(self, myvect: vector):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.select_insidepoly(myvect)
+
+    def select_underpoly(self, myvect: vector):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.select_underpoly(myvect)
+
+    def update_nb_nodes_selection(self):
+
+        ret = []
+        for curblock in self.parent.active_blocks:
+            ret.append(curblock.SelectionData.update_nb_nodes_selection())
+
+        nb = np.sum([cur[0] for cur in ret])
+        xmin = np.min([cur[1] for cur in ret if cur[1] != -99999.])
+        ymin = np.min([cur[3] for cur in ret if cur[3] != -99999.])
+        xmax = np.max([cur[2] for cur in ret if cur[2] != -99999.])
+        ymax = np.max([cur[4] for cur in ret if cur[4] != -99999.])
+
+        if self.parent.myops is not None:
+
+            self.parent.myops.nbselect.SetLabelText(str(nb))
+            if nb>0:
+                self.parent.myops.minx.SetLabelText('{:.3f}'.format(xmin))
+                self.parent.myops.miny.SetLabelText('{:.3f}'.format(ymin))
+                self.parent.myops.maxx.SetLabelText('{:.3f}'.format(xmax))
+                self.parent.myops.maxy.SetLabelText('{:.3f}'.format(ymax))
+
+
+    def condition_select(self, cond, condval, condval2=0, usemask=False):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.condition_select(cond, condval, condval2, usemask)
+
+    def treat_select(self, op, cond, opval, condval):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.treat_select(op, cond, opval, condval)
+
+    def mask_condition(self, op, cond, opval, condval):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.mask_condition(op, cond, opval, condval)
+
+    def plot_selection(self):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.plot_selection()
+
+    def move_selectionto(self, idx:str, color:list[float]):
+
+        for curblock in self.parent.active_blocks:
+            curblock.SelectionData.move_selectionto(idx, color, resetplot=False)
+
+        self.parent.reset_plot()
+
+    def copy_to_clipboard(self, which:int = None, typestr:Literal['string', 'script'] = 'string'):
+
+        logging.error(_('Not yet implemented for Multi-Blocks'))
+
+    def interp2Dpolygons(self, working_zone:zone, method:Literal["nearest", "linear", "cubic"] = None):
+        """
+        Interpolation sous tous les polygones d'une zone
+        cf parent.interp2Dpolygon
+        """
+
+        if method is None:
+            choices = ["nearest", "linear", "cubic"]
+            dlg = wx.SingleChoiceDialog(None, "Pick an interpolate method", "Choices", choices)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            method = dlg.GetStringSelection()
+            dlg.Destroy()
+
+        self.parent.interpolate_on_polygons(working_zone, method)
+
+        self.parent.reset_plot()
+
+    def interp2Dpolygon(self, working_vector:vector, method:Literal["nearest", "linear", "cubic"] = None):
+        """
+        Interpolation sous un polygone
+        cf parent.interp2Dpolygon
+        """
+
+        if method is None:
+            choices = ["nearest", "linear", "cubic"]
+            dlg = wx.SingleChoiceDialog(None, "Pick an interpolate method", "Choices", choices)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            method = dlg.GetStringSelection()
+            dlg.Destroy()
+
+        self.parent.interpolate_on_polygon(working_vector, method)
+
+        self.parent.reset_plot()
+
+    def interp2Dpolylines(self, working_zone:zone, resetplot:bool = True):
+        """
+        Interpolation sous toutes les polylignes de la zone
+        cf parent.interp2Dpolyline
+        """
+
+        self.parent.interpolate_on_polylines(working_zone)
+
+        self.parent.reset_plot()
+
+    def interp2Dpolyline(self, working_vector:vector, resetplot:bool = True):
+        """
+        Interpolation sous la polyligne active
+        cf parent.interp2Dpolyline
+        """
+
+        self.parent.interpolate_on_polyline(working_vector)
+
+        self.parent.reset_plot()
+
+    def volumesurface(self, show=True):
+        """
+        Evaluation of stage-storage-surface relation
+        """
+
+        logging.error(_('Not yet implemented for Multi-Blocks'))
 
 class WolfArray(Element_To_Draw, header_wolf):
     """
@@ -3398,6 +3926,9 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.mngselection = None
 
+        self.myblocks = None
+        self._active_blocks = None
+
         self.flipupd=False
         self.array:ma.masked_array = None       # numpy masked array to stored numerical data
 
@@ -3425,7 +3956,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.shaded.mypal.defaultgray()
             self.shaded.mypal.automatic = False
 
-        self.nullvalue = nullvalue
+        self._nullvalue = nullvalue
         self.nbnotnull = 99999      # number of non-null values in the entire aray
         self.nbnotnullzoom = 99999  # number of non-null values in the current visible part in mapviwer
         self.nbtoplot = 0
@@ -3464,6 +3995,9 @@ class WolfArray(Element_To_Draw, header_wolf):
 
             self.head_blocks = header.head_blocks.copy()
 
+            if self.nb_blocks>0:
+                self.myblocks = {}
+
             self.allocate_ressources()
 
             # # FIXME Why not initialize with nullvalue ?
@@ -3532,6 +4066,16 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
+    def extract_selection(self):
+        """ Extract the current selection """
+
+        newarray = self.SelectionData.get_newarray()
+
+        mapviewer = self.get_mapviewer()
+
+        if mapviewer is not None:
+            mapviewer.add_object('array', newobj = newarray, ToCheck = True, id = self.idx + '_extracted')
+
     def crop_array(self, bbox:list[list[float],list[float]]) -> "WolfArray":
         """ Crop the data based on the bounding box """
         imin, jmin = self.get_ij_from_xy(bbox[0][0], bbox[1][0])
@@ -3605,6 +4149,93 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.myops.SetTitle(_('Operations on array: ') + self.idx)
             self.myops.Show()
 
+    @property
+    def nullvalue(self) -> float:
+        """ Return the null value """
+
+        return self._nullvalue
+
+    @nullvalue.setter
+    def nullvalue(self, value:float):
+        """ Set the null value """
+
+        self._nullvalue = value
+
+    @property
+    def SelectionData(self) -> SelectionData:
+        """ Return the data of the selection """
+
+        return self.mngselection
+
+    @property
+    def active_blocks(self) -> list["WolfArray"]:
+        """ Return the active blocks """
+
+        if self.nb_blocks>0 and self._active_blocks is not None:
+
+            if isinstance(self._active_blocks, list):
+                return [self.myblocks[cur] for cur in self._active_blocks]
+            elif self._active_blocks == 0:
+                return [k for k in self.myblocks.values()]
+            elif self._active_blocks in self.myblocks:
+                return [self.myblocks[self._active_blocks]]
+            else:
+                return None
+
+        else:
+            return [self]
+
+    @active_blocks.setter
+    def active_blocks(self, value:Union[str, int, list[int]]):
+        """
+        Set the active blocks
+
+        :param value: name of the block or index 1-based or list of index 1-based
+
+        """
+
+        if isinstance(value, str):
+            if value in self.myblocks:
+                self._active_blocks = value
+                logging.info(_(f'Block found - {value}'))
+            else:
+                self._active_blocks = None
+                logging.info(_('Block not found'))
+
+        elif isinstance(value, int):
+
+            if value == 0:
+                self._active_blocks = 0
+                logging.info(_('All blocks selected'))
+            else:
+                value = getkeyblock(value, addone=False)
+
+                if value in self.myblocks:
+                    self._active_blocks = value
+                    logging.info(_(f'Block found - {value}'))
+                else:
+                    self._active_blocks = None
+                    logging.info(_('Block not found'))
+
+        elif isinstance(value, list):
+
+            if 0 in value:
+                self._active_blocks = 0
+                logging.info(_('All blocks selected'))
+            else:
+                value = [getkeyblock(cur, addone=False) for cur in value]
+                value = [cur for cur in value if cur in self.myblocks]
+
+                if len(value)>0:
+                    self._active_blocks = value
+                    logging.info(_('List of blocks selected'))
+                else:
+                    self._active_blocks = None
+                    logging.info(_('No block found'))
+
+        else:
+            logging.error(_('Unknown type for active_blocks'))
+
     @property
     def dtype(self):
         """
@@ -3707,7 +4338,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.reset_plot()
 
-    def filter_independent_zones(self, n_largest:int = 1):
+    def filter_independent_zones(self, n_largest:int = 1, reset_plot:bool = True):
         """
         Filtre des zones indépendantes et conservation des n plus grandes
 
@@ -3721,7 +4352,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         # convertion en masked array
         labeled_array = ma.asarray(labeled_array)
         # application du masque
-        labeled_array.mask = self.array.mask
+        labeled_array.mask[:,:] = self.array.mask[:,:]
 
         longueur = []
         labeled_array[labeled_array.mask] = 0
@@ -3737,8 +4368,61 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.set_nullvalue_in_mask()
 
-        self.reset_plot()
+        if reset_plot:
+            self.reset_plot()
 
+    def filter_zone(self, set_null:bool = False, reset_plot:bool = True):
+        """
+        Filtre des zones et conservation de celles pour lesquelles des
+        mailles sont sélectionnées
+
+        """
+
+        if self.SelectionData.nb == 0:
+            logging.info(_('No selection -- no filtering'))
+            return
+
+        if self.SelectionData.myselection == 'all':
+            logging.info(_('All nodes selected -- no filtering'))
+            return
+
+        # labellisation
+        labeled_array = self.array.data.copy()
+        labeled_array[np.where(self.array.mask)] = 0
+
+        labeled_array, num_features = label(labeled_array)
+
+        # récupération des zones utiles
+        vals_ij = [self.get_ij_from_xy(cur[0], cur[1]) for cur in self.SelectionData.myselection]
+        vals = list(set([labeled_array[int(cur[0]), int(cur[1])] for cur in vals_ij]))
+
+        self.array.mask[:,:] = True
+
+        for j in vals:
+            self.array.mask[labeled_array == j] = False
+
+        if set_null:
+            self.set_nullvalue_in_mask()
+
+        if reset_plot:
+            self.reset_plot()
+
+    def labelling(self, reset_plot:bool = True):
+        """
+        Labelling of the array using Scipy
+
+        """
+
+        # labellisation
+        labeled_array = self.array.data.copy()
+        labeled_array[np.where(self.array.mask)] = 0
+
+        labeled_array, num_features = label(labeled_array)
+
+        self.array.data[:,:] = labeled_array[:,:].astype(self.dtype)
+
+        if reset_plot:
+            self.reset_plot()
 
     def export_geotif(self, outdir='', extent = ''):
         """
@@ -3902,10 +4586,12 @@ class WolfArray(Element_To_Draw, header_wolf):
 
     def add_ops_sel(self):
         """
-        Add :
-           - Ops_Array (GUI) if mapviewer is not None
-           - create SelectionData (Selection manager) if None
+        Adding selection manager and operations array
+
+        - Ops_Array (GUI) if mapviewer is not None
+        - create SelectionData (Selection manager) if None
         """
+
         if self.wx_exists and self.mapviewer is not None:
             self.myops = Ops_Array(self, self.mapviewer)
             self.myops.Hide()
@@ -3913,7 +4599,11 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.myops = None
 
         if self.mngselection is None:
-            self.mngselection = SelectionData(self)
+
+            if self.nb_blocks>0:
+                self.mngselection = SelectionDataMB(self)
+            else:
+                self.mngselection = SelectionData(self)
 
     def change_gui(self, newparentgui):
         """
@@ -4039,6 +4729,82 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         plt.show()
 
+    def interpolate_on_polygon(self, working_vector: vector, method:Literal["nearest", "linear", "cubic"]="linear"):
+        """
+        Interpolation sous un polygone
+
+        L'interpolation a lieu :
+          - 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
+        depuis les vertices 3D du polygone
+        """
+
+        if self.mngselection is None:
+            destxy = self.get_xy_inside_polygon(working_vector)
+        else:
+            if self.SelectionData.nb == 0:
+                destxy = self.get_xy_inside_polygon(working_vector)
+            else:
+                destxy = self.SelectionData.myselection
+
+        if len(destxy)==0:
+            logging.debug(_('No points to interpolate'))
+            return
+
+        destij = np.asarray([list(self.get_ij_from_xy(x, y)) for x, y in destxy])
+
+        xyz = working_vector.asnparray3d()
+
+        newvalues = griddata(xyz[:, :2], xyz[:, 2], destxy, method=method, fill_value=-99999.)
+
+        locmask = np.where(newvalues != -99999.)
+        self.array.data[destij[locmask][:, 0], destij[locmask][:, 1]] = newvalues[locmask]
+
+    def interpolate_on_polygons(self, working_zone:zone, method:Literal["nearest", "linear", "cubic"]="linear"):
+        """
+        Interpolation sous plusieurs polygones d'une même zone
+
+        """
+
+        for curvec in working_zone.myvectors:
+            self.interpolate_on_polygon(curvec, method)
+
+    def interpolate_on_polyline(self, working_vector:vector, usemask=True):
+        """
+        Interpolation sous une polyligne
+
+        L'interpolation a lieu :
+          - uniquement dans les mailles sélectionnées si elles existent
+          - dans les mailles sous la polyligne sinon
+
+        On utilise ensuite "interpolate" de shapely pour interpoler les altitudes des mailles
+        depuis les vertices 3D de la polyligne
+        """
+
+        vecls = working_vector.asshapely_ls()
+
+        if self.SelectionData is None:
+            allij = self.get_ij_under_polyline(working_vector, usemask)
+            allxy = [self.get_xy_from_ij(cur[0], cur[1]) for cur in allij]
+        else:
+            if self.SelectionData.nb == 0:
+                allij = self.get_ij_under_polyline(working_vector, usemask)
+                allxy = [self.get_xy_from_ij(cur[0], cur[1]) for cur in allij]
+            else:
+                allxy = self.SelectionData.myselection
+                allij = np.asarray([self.get_ij_from_xy(x,y) for x,y in allxy])
+
+        newz = np.asarray([vecls.interpolate(vecls.project(Point(x, y))).z for x, y in allxy])
+        self.array.data[allij[:, 0], allij[:, 1]] = newz
+
+    def interpolate_on_polylines(self, working_zone:zone, usemask=True):
+
+        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'):
         """
         See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
@@ -4195,7 +4961,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                     curvec.add_vertex(wolfvertex(coords[curpt,0],coords[curpt,1], coords[curpt,2]))
                 curvec.close_force()
 
-                self.myops._interp2Dpolygon(curvec, "linear")
+                self.interpolate_on_polygon(curvec, "linear")
 
         self.reset_plot()
         return
@@ -4546,7 +5312,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return axs
 
-    def paste_all(self, fromarray:"WolfArray"):
+    def paste_all(self, fromarray:"WolfArray", mask_after:bool=True):
         """ Paste all the values from another WolfArray """
 
         fromarray: WolfArray
@@ -4583,8 +5349,9 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.array.data[usefulij_dest] = fromarray.array.data[usefulij]
 
-        self.mask_data(self.nullvalue)
-        self.reset_plot()
+        if mask_after:
+            self.mask_data(self.nullvalue)
+            self.reset_plot()
 
     def set_values_sel(self, xy:list[float], z:list[float], update:bool=True):
         """
@@ -4594,6 +5361,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param z: [z1,z2,...]
         :param update: update the plot
         """
+
         sel = np.asarray(xy)
 
         if len(sel) == 1:
@@ -4779,6 +5547,10 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         assert self.shape == mask.shape, _('Bad shape')
 
+        if self.array is None:
+            logging.debug(_('No array !!'))
+            return
+
         if link:
             self.array.mask = mask
         else:
@@ -5024,7 +5796,60 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return newArray
 
-    def mask_outsidepoly(self, myvect: vector):
+    def concatenate(self, list_arr:list["WolfArray"], nullvalue:float = 0.):
+        """
+        Concatenate the values from another WolfArrays into a new one
+
+        :param list_arr: list of WolfArray objects
+        :return: a new WolfArray
+        :return_type: WolfArray
+        """
+
+        list_arr:list[WolfArray]
+
+        for curarray in list_arr:
+            assert isinstance(curarray, WolfArray), "The list must contain WolfArray objects"
+            assert curarray.nbdims == self.nbdims, "The arrays must have the same number of dimensions"
+            assert curarray.dx == self.dx and curarray.dy == self.dy, "The arrays must have the same dx and dy"
+            assert curarray.translx == 0 and curarray.transly == 0, "The translations must be zero"
+            assert (np.abs(curarray.origx-self.origx)%int(self.dx) == 0)and(np.abs(curarray.origy-self.origy)%int(self.dy) == 0), "The origins are not compatible! You need to do some interpolation stuff"
+            assert self.translx == 0 and self.transly == 0, "The translations must be zero"
+            assert self.wolftype == curarray.wolftype, "The arrays must have the same wolftype"
+
+        # create an array
+        newArray = WolfArray(nullvalue=nullvalue, whichtype=self.wolftype)
+
+        Xlim,Ylim = self.find_union(list_arr)
+
+        newArray.origx  = Xlim[0]
+        newArray.origy  = Ylim[0]
+        newArray.dx     = self.dx
+        newArray.dy     = self.dy
+
+        newArray.nbx = int(np.diff(Xlim)[0]/newArray.dx)
+        newArray.nby = int(np.diff(Ylim)[0]/newArray.dy)
+
+        newArray.translx = 0.
+        newArray.transly = 0.
+
+        newArray.array = np.ma.masked_array(np.ones((newArray.nbx, newArray.nby), dtype=self.dtype) * nullvalue, mask=True, dtype=self.dtype)
+
+        newArray.paste_all(self, mask_after=False)
+
+        for curarray in list_arr:
+            Array_intersect = curarray.find_intersection(self, ij=True)
+
+            if Array_intersect is not None:
+                logging.info(_("There is intersection. By default, the array {} overlaps the first one.".format(curarray.filename)))
+
+            newArray.paste_all(curarray, mask_after=False)
+
+        newArray.mask_data(nullvalue)
+
+
+        return newArray
+
+    def mask_outsidepoly(self, myvect: vector, eps:float = 0.):
         """
         Mask nodes outside a polygon and set values to nullvalue
 
@@ -5038,27 +5863,51 @@ class WolfArray(Element_To_Draw, header_wolf):
         mask[:,:] = True # Mask everything
 
         # trouve les indices dans le polygone
-        myij = self.get_ij_inside_polygon(myvect, False)
+        myij = self.get_ij_inside_polygon(myvect, usemask=False, eps=eps)
+
         # démasquage des mailles contenues
         mask[myij[:,0],myij[:,1]] = False
+
         # 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
+        # recherche du nouveau masque, sinon les valeurs no_data à
+        # l'intérieur du polygone vont pollluer la matrice
+
+        # 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)
+
+        self.count()
+
+    def mask_insidepoly(self, myvect: vector, eps:float = 0.):
+        """
+        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
+        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
 
-        # 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)
+        # masquage des mailles contenues
+        self.array.mask[myij[:,0],myij[:,1]] = True
 
+        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 dur to the structure of the results
+    # 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, usemask:bool=True):
         """
@@ -5069,7 +5918,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
 
         myvect.find_minmax()
-        mypointsxy,mypointsij = self.get_xy_infootprint_vect(myvect)
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect)
         myvert = myvect.asnparray()
         path = mpltPath.Path(myvert)
         inside = path.contains_points(mypointsxy)
@@ -5096,7 +5945,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypoints
 
-    def get_ij_inside_polygon(self, myvect: vector, usemask:bool=True):
+    def get_ij_inside_polygon(self, myvect: vector, usemask:bool=True, eps:float = 0.):
         """
         Return the indices inside a polygon
 
@@ -5104,12 +5953,16 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param usemask : limit potential nodes to unmaksed nodes
         """
 
+        # force la mise à jour des min/max
         myvect.find_minmax()
-        mypointsij = self.get_ij_infootprint_vect(myvect)
+
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect, eps=eps)
+
+        # Conversion des coordonnées en numpy pour plus d'efficacité (du moins on espère)
         myvert = myvect.asnparray()
-        i,j =self.convert_xy2ij_np(myvert)
-        path = mpltPath.Path(np.column_stack([i,j]))
-        inside = path.contains_points(mypointsij)
+
+        path = mpltPath.Path(myvert)
+        inside = path.contains_points(mypointsxy)
 
         mypointsij = mypointsij[np.where(inside)]
 
@@ -5287,6 +6140,11 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         else:
             self.read_txt_header()
+
+            if self.nb_blocks > 0:
+                # At this point, we have the header, we know the number of blocks, if exists
+                self.myblocks = {}
+
             if self.preload:
                 self.read_data()
                 self.loaded = True
@@ -5296,7 +6154,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
         Ecriture de tous les fichiers d'un Wolf array
 
-        :param newpath: path and filename with extension
+        :param newpath: new path and filename with extension -- if None, use the current filename
         """
 
         if isinstance(newpath, Path):
@@ -5308,7 +6166,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         if self.filename.endswith('.tif'):
             self.export_geotif()
         elif self.filename.endswith('.npy'):
-            
+
             writing_header = True
             if self.dtype !=  self.array.data.dtype:
                 logging.warning(_('Data type changed -- Force conversion to internal numpy array'))
@@ -5510,6 +6368,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
             locarray = np.frombuffer(f.read(self.nbx * self.nby * 2), dtype=np.int16)
             self.array = ma.masked_array(locarray.copy(), dtype=np.int16)
+        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)
 
         if self.nbdims == 2:
             self.array = self.array.reshape(self.nbx, self.nby, order='F')
@@ -5606,7 +6467,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         """
 
         if self.nbdims == 2:
-            # FIXME if WolfArray_Sim2D mask linking should work
+            # FIXME if mask linking should work
             # as expected, then we do: self.array.mask.fill(0.0)
             # to avoid replacing the linked mask by a (non linked) one.
 
@@ -5677,6 +6538,25 @@ class WolfArray(Element_To_Draw, header_wolf):
         np.copyto(self.array.mask, self.array.data <= value)
         self.count()
 
+    def mask_greater(self, value):
+        """ Mask cell where values are strictly greater than `value` """
+        if self.array is None:
+            return
+
+        # Copy to prevent unlinking the mask (see `mask_reset`)
+        np.copyto(self.array.mask, self.array.data > value)
+        self.count()
+
+    def mask_greaterequal(self, value):
+        """ Mask cell where values are greater or equal than `value`"""
+        if self.array is None:
+            return
+
+        # Copy to prevent unlinking the mask (see `mask_reset`)
+        np.copyto(self.array.mask, self.array.data >= value)
+        self.count()
+
+
     def set_nullvalue_in_mask(self):
         """ Set nullvalue in masked cells """
         if self.array is None:
@@ -5736,6 +6616,29 @@ class WolfArray(Element_To_Draw, header_wolf):
         y, x = np.meshgrid(y_discr, x_discr)
         return x, y
 
+    def crop_masked_at_edges(self):
+
+        """
+        Crop the array to remove masked cells at the edges of the array
+        :return: cropped array, WolfArray instance
+
+        """
+
+        # Get max indexes
+        Existing_indexes = np.argwhere(self.array.mask!=True)
+        Max_index = np.max(Existing_indexes, 0)
+        Min_index = np.min(Existing_indexes, 0)
+
+        # convert index in location
+        xMax, yMax = self.convert_ij2xy_np(Max_index.reshape((1,2)))
+        xMin, yMin = self.convert_ij2xy_np(Min_index.reshape((1,2)))
+
+        # crop
+        nbx=np.ceil((xMax[0]-xMin[0])/self.dx).astype(int)+1 #+1 otherwise you remove one line
+        nby=np.ceil((yMax[0]-yMin[0])/self.dy).astype(int)+1 #+1 otherwise you remove one column
+        return self.crop(int(Min_index[0]),int(Min_index[1]),int(nbx),int(nby))
+
+
     def crop(self, i_start:int, j_start:int, nbx:int, nby:int, k_start:int=1, nbz:int=1):
         """
         Crop the array
@@ -5779,6 +6682,44 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return newWolfArray
 
+    def extend(self, x_ext:int, y_ext:int):
+
+        # crop is the opposite
+
+        assert x_ext >= 0 and y_ext >= 0
+        assert self.nbdims == 2, "Only 2D arrays are supported"
+
+        # Remember WolfArrays are masked. Therefore
+        # we need to extend mask. In this case, not specifying
+        # anything will expand the mask with "dont mask"
+        # values.
+
+        # extend vertically
+        ex = self.array
+
+        if x_ext > 0:
+            # dtype is important: it allows to keep a Fortran friendly
+            # type I think.
+            ex = ma.append(
+                ex,
+                np.array([0] * ex.shape[1] * x_ext, dtype=ex.dtype).reshape((x_ext, -1)),
+                axis=0,
+            )
+            self.nbx += x_ext
+
+        # extend horizontally
+        if y_ext > 0:
+            ex = ma.append(
+                ex,
+                np.array([0] * ex.shape[0] * y_ext, dtype=ex.dtype).reshape((-1, y_ext)),
+                axis=1,
+            )
+            self.nby += y_ext
+
+        self.array = ex
+
+        self.mask_data(self.nullvalue)
+
     def extremum(self, which:Literal['min','max']='min'):
         """ Return the extremum value """
 
@@ -6354,6 +7295,55 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.array.mask[:,:width] = True
         self.array.mask[:,-width:] = True
 
+    def as_WolfArray(self, abs:bool=True) -> "WolfArray":
+        """
+        Return a WolfArray object from this WolfArray
+        """
+
+        NewArray = WolfArray(mold=self)
+
+        if abs:
+            NewArray.origx += self.translx
+            NewArray.origy += self.transly
+            NewArray.translx = 0.
+            NewArray.transly = 0.
+
+        return NewArray
+
+    def get_unique_values(self):
+        """
+        Return unique values in the array
+        """
+
+        unique = np.ma.unique(self.array)
+
+        while unique[-1] is np.ma.masked and len(unique) > 1:
+            unique = unique[:-1]
+
+        return unique
+
+    def map_values(self, keys_vals:dict, default:float=None):
+        """
+        Apply a mapping to the array
+        """
+
+        vals = self.get_unique_values()
+
+        if default is not None:
+            self.array.data[:,:] = default
+
+        for val in vals:
+            if val not in keys_vals:
+                logging.warning(f"Value {val} not in keys_vals")
+                continue
+
+        for key, val in keys_vals.items():
+            self.array.data[self.array.data == key] = val
+
+        self.mask_data(self.nullvalue)
+
+        self.reset_plot()
+
 class WolfArrayMB(WolfArray):
     """
     Matrice multiblocks
@@ -6366,12 +7356,133 @@ class WolfArrayMB(WolfArray):
 
     def __init__(self, fname=None, mold=None, masknull=True, crop=None, whichtype=WOLF_ARRAY_MB_SINGLE, preload=True,
                  create=False, mapviewer=None, nullvalue=0, srcheader=None):
-        self.myblocks = {}
+
         super().__init__(fname, mold, masknull, crop, whichtype, preload, create, mapviewer, nullvalue, srcheader)
-        # self.wolftype = whichtype
+
+        self._active_blocks = 0
+
+        if self.myblocks is None:
+            self.myblocks = {}
+
+    def extract_selection(self):
+        """ Extract the current selection """
+
+        newarrays = []
+
+        for curblock in self.myblocks.values():
+            newblock = curblock.SelectionData.get_newarray()
+
+            if newblock is not None:
+                newarrays.append(newblock)
+
+        if len(newarrays) == 0:
+            logging.warning(_('No selection to extract'))
+            return None
+
+        newMBarray = WolfArrayMB()
+        for newarray in newarrays:
+            newMBarray.add_block(newarray, force_idx=True)
+
+        mapviewer = self.get_mapviewer()
+
+        if mapviewer is not None:
+            mapviewer.add_object('array', newobj = newarray, ToCheck = True, id = self.idx + '_extracted')
+
+
+    @property
+    def nullvalue(self) -> float:
+        """ Return the null value """
+
+        return self._nullvalue
+
+    @nullvalue.setter
+    def nullvalue(self, value:float):
+        """ Set the null value """
+
+        self._nullvalue = value
+
+        if self.myblocks is not None:
+            for curblock in self.myblocks.values():
+                curblock.nullvalue = value
+
+    def add_ops_sel(self):
+        """ Add operations and selection manager to all blocks """
+
+        super().add_ops_sel()
+
+        if self.myblocks is None:
+            self.myblocks = {}
+
+        for curblock in self.myblocks.values():
+            curblock.add_ops_sel()
+
+    def filter_zone(self, set_null:bool = False):
+        """
+        Filtre des zones et conservation de celles pour lesquelles des
+        mailles sont sélectionnées
+
+        """
+
+        for curblock in self.myblocks.values():
+            curblock.filter_zone(set_null, reset_plot=False)
+
+        self.reset_plot()
+
+    def labelling(self):
+        """
+        Labelling of the array using Scipy
+
+        """
+
+        for curblock in self.myblocks.values():
+            curblock.labelling(reset_plot=False)
+
+        self.reset_plot()
+
+    def interpolate_on_polygon(self, working_vector: vector, method:Literal["nearest", "linear", "cubic"]="linear"):
+        """
+        Interpolation sous un polygone
+
+        L'interpolation a lieu :
+          - 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
+        depuis les vertices 3D du polygone
+        """
+
+        for curblock in self.myblocks.values():
+            curblock.interpolate_on_polygon(working_vector, method)
+
+    def interpolate_on_polygons(self, working_zone: zone, method:Literal["nearest", "linear", "cubic"]="linear"):
+
+        for curvector in working_zone.myvectors:
+            self.interpolate_on_polygon(curvector, method)
+
+    def interpolate_on_polyline(self, working_vector:vector, usemask=True):
+        """
+        Interpolation sous une polyligne
+
+        L'interpolation a lieu :
+          - uniquement dans les mailles sélectionnées si elles existent
+          - dans les mailles sous la polyligne sinon
+
+        On utilise ensuite "interpolate" de shapely pour interpoler les altitudes des mailles
+        depuis les vertices 3D de la polyligne
+        """
+
+        for curblock in self.myblocks.values():
+            curblock.interpolate_on_polyline(working_vector, usemask)
+
+    def interpolate_on_polylines(self, working_zone:zone, usemask=True):
+        """ Interpolation sous les polylignes d'une même zone """
+
+        for curvec in working_zone.myvectors:
+            self.interpolate_on_polyline(curvec, usemask)
 
     def check_bounds_ij(self, i:int, j:int):
         """Check if i and j are inside the array bounds"""
+
         x,y = self.get_xy_from_ij(i,j)
         return self.check_bounds_xy(x,y)
 
@@ -6468,6 +7579,8 @@ class WolfArrayMB(WolfArray):
                 self.loaded = True
             else:
                 raise Exception(_(f"Trying to load an array that doesn't exist ({self.filename})"))
+        else:
+            logging.info(_('Array already loaded'))
 
     def uncheck_plot(self, unload:bool=True, forceresetOGL:bool=False, askquestion:bool=True):
         """ Uncheck plot and apply to each block """
@@ -6491,6 +7604,8 @@ class WolfArrayMB(WolfArray):
 
             self.myblocks = {}
             self.loaded = False
+        else:
+            logging.info(_('Array not unloaded'))
 
     def mask_data(self, value):
         """ Mask cells where values are equal to `value`"""
@@ -6759,6 +7874,15 @@ class WolfArrayMB(WolfArray):
         self.plotting = False
         self.mimic_plotdata()
 
+        # Plot selected nodes
+        if self.mngselection is not None:
+            self.mngselection.plot_selection()
+
+        # Plot zones attached to array
+        if self.myops is not None:
+            self.myops.myzones.plot()
+
+
     def fillonecellgrid(self, curscale, loci, locj, force=False):
         for curblock in self.myblocks.values():
             curblock.fillonecellgrid(curscale, loci, locj, force)
@@ -7067,16 +8191,20 @@ class WolfArrayMB(WolfArray):
     def allocate_ressources(self):
         """ Allocate memory ressources """
 
-        if len(self.myblocks)==0:
-            for id, (key, curhead) in enumerate(self.head_blocks.items()):
-                if self.wolftype == WOLF_ARRAY_MB_SINGLE:
-                    self.myblocks[key] = WolfArray(srcheader=curhead, whichtype=WOLF_ARRAY_FULL_SINGLE)
-                elif self.wolftype == WOLF_ARRAY_MB_INTEGER:
-                    self.myblocks[key] = WolfArray(srcheader=curhead, whichtype=WOLF_ARRAY_FULL_INTEGER)
+        if self.myblocks is None:
+            logging.warning("No blocks to allocate")
+        else:
 
-                self.myblocks[key].isblock = True
-                self.myblocks[key].blockindex = id
-                self.myblocks[key].idx = key
+            if len(self.myblocks)==0:
+                for id, (key, curhead) in enumerate(self.head_blocks.items()):
+                    if self.wolftype == WOLF_ARRAY_MB_SINGLE:
+                        self.myblocks[key] = WolfArray(srcheader=curhead, whichtype=WOLF_ARRAY_FULL_SINGLE)
+                    elif self.wolftype == WOLF_ARRAY_MB_INTEGER:
+                        self.myblocks[key] = WolfArray(srcheader=curhead, whichtype=WOLF_ARRAY_FULL_INTEGER)
+
+                    self.myblocks[key].isblock = True
+                    self.myblocks[key].blockindex = id
+                    self.myblocks[key].idx = key
 
     def set_header_from_added_blocks(self):
         """ Set header from blocks """
@@ -7213,18 +8341,26 @@ class WolfArrayMB(WolfArray):
                     logging.debug(f"Block {curblock.idx} is empty or totally masked.")
 
         return newArray
+
+
 class WolfArrayMNAP(WolfArrayMB):
     """
     Matrice MNAP d'une modélisation WOLF2D
 
-    Elle contient toutes les informations de maillage
+    Elle contient toutes les informations de maillage en Multi-blocks
+    ainsi que les relations de voisinage de blocs.
+
+    Surcharge de WolfArrayMB avec modification des opérations de lecture/écriture
+    car le fichier est au format TEXTE/ASCII et d'une structure spécifique.
+
     """
+
     # Each zone will have the contour of one block.
     contour: Zones
 
     def __init__(self, fname=None, mold=None, masknull=True, crop=None):
         super().__init__(fname, mold, masknull, crop)
-        self.contour = Zones()
+
 
     def write_all(self):
 
@@ -7259,23 +8395,38 @@ class WolfArrayMNAP(WolfArrayMB):
                     f.write(padf(v.x) + padf(v.y) + "\n")
 
     def read_data(self):
-        if os.path.exists(self.filename + '.mnap'):
+
+        # Vérification de l'existence de certains attributs
+        if self.myblocks is None:
+            self.myblocks = {}
+
+        # une matrice WolfArrayMB n'a pas de contour -> ajout d'un attribut spécifique
+        self.contour = Zones()
+
+        if Path(self.filename + '.mnap').exists():
+
             with open(self.filename + '.mnap') as f:
+
+                # Lecture au format texte
                 lines = f.read().splitlines()
 
+                # nombre de blocks dans la première ligne
                 nb_blocks = abs(int(lines[0]))
-                self.contour = Zones()
 
                 decal = 1
                 for i in range(nb_blocks):
+                    # bouclage sur chque block
                     curkey = getkeyblock(i)
-                    curarray = WolfArray()
+
+                    curarray = WolfArray(whichtype=WOLF_ARRAY_FULL_INTEGER8)
                     self.myblocks[curkey] = curarray
 
-                    curarray.wolftype = WOLF_ARRAY_FULL_INTEGER8
+                    assert curarray.wolftype == WOLF_ARRAY_FULL_INTEGER8, "Type de block incorrect"
+
                     curarray.isblock = True
                     curarray.blockindex = i
 
+                    # Recherche des informations de maillage - dx, dy, origx, origy, nbx, nby
                     tmp = re.sub('\\s+', ' ', lines[decal].strip()).split(' ')
                     curarray.dx = float(tmp[0])
                     curarray.dy = float(tmp[1])
@@ -7291,6 +8442,8 @@ class WolfArrayMNAP(WolfArrayMB):
                     curarray.nby = int(tmp[1])
 
                     decal += 4
+
+                    #Lecture de la matrice de maillage pour le block en cours
                     myarray = []
 
                     for j in range(curarray.nby):
@@ -7304,6 +8457,7 @@ class WolfArrayMNAP(WolfArrayMB):
 
                     curarray.array = np.flipud(np.ma.asarray(myarray, order='F')).transpose()
 
+                    #Lecture du contour de block
                     curzone = zone(name=curkey)
                     contourblock = vector(name='contour')
 
@@ -7320,6 +8474,9 @@ class WolfArrayMNAP(WolfArrayMB):
                     curarray.translx = self.translx + self.origx
                     curarray.transly = self.transly + self.origy
 
+                    # Remplissagze du header
+                    # --> la matrice MNAP est la référence d'une simulation 2D
+                    #     pour obtenir les informations de maillage
                     curhead = self.head_blocks[getkeyblock(i)] = header_wolf()
 
                     curhead.nbx = curarray.nbx
@@ -7332,6 +8489,17 @@ class WolfArrayMNAP(WolfArrayMB):
                     curhead.transly = curarray.transly
 
     def read_txt_header(self):
+        """
+        Surcharge de la lecture du header
+
+        Il n'y a pas en tant que tel de header d'un fichier MNAP.
+
+        Les informations de translation sont dans le fichier ".trl".
+
+        Les informations de tailles de maille 'fines',
+        Nbx, Nby et coordonnées d'origine sont dans le fichier ".par"
+
+        """
 
         if os.path.exists(self.filename + '.trl'):
             with open(self.filename + '.trl') as f:
@@ -7349,144 +8517,5 @@ class WolfArrayMNAP(WolfArrayMB):
                 self.origx = float(lines[11])
                 self.origy = float(lines[12])
 
+        # Imposition du type de stockage
         self.wolftype = WOLF_ARRAY_MNAP_INTEGER
-
-
-class WolfArray_Sim2D(WolfArray):
-    """
-    Surcharge de WolfArray pour les matrices fines de simulation
-
-    Objectif : lier la matrice de mask à une source commune
-
-    """
-    def __init__(self,
-                 fname:str=None,
-                 mold:"WolfArray"=None,
-                 masknull:bool=True,
-                 crop:list[float]=None,
-                 whichtype=WOLF_ARRAY_FULL_SINGLE,
-                 preload:bool=True,
-                 create:bool=False,
-                 mapviewer=None,
-                 nullvalue:float=0,
-                 srcheader:header_wolf=None,
-                 masksrc:np.ndarray=None):
-
-        # link to mask source
-        self.masksrc = masksrc
-
-        # FIXME __init__ will initialize a mask of its own and so self.masksrc
-        # will be ignored at this point. That's misleading, I'd thought
-        # that passing a mask would wire it to this array, forever.
-        super().__init__(fname, mold, masknull, crop, whichtype, preload, create, mapviewer, nullvalue, srcheader, mask_source=masksrc)
-
-    def check_plot(self):
-        """
-        Surcharge de la fonction de vérification du plot
-
-        Utile notamment pour lier le masque
-        """
-        self.plotted = True
-
-        if not self.loaded and self.filename != '':
-            self.read_data()
-
-            if self.array is None:
-                #problème à la lecture
-                self.plotted=False
-                return
-
-            if self.masksrc is not None:
-                self.array.mask = self.masksrc
-
-        self.loaded = True
-
-        if self.rgb is None:
-            self.updatepalette(0)
-
-    def read_all(self):
-        """
-        Surcharge de la fonction de lecture de la matrice
-
-        Utile notamment puor le fichier zbin
-        """
-
-        if self.filename[-4:]=='zbin':
-            fileold = self.filename
-
-            self.filename = fileold[:-4]+'top'
-
-            if not os.path.exists(self.filename):
-                return
-
-            self.read_txt_header()
-            self.filename = fileold
-            self.read_data()
-        else:
-            return super().read_all()
-
-    def read_data(self):
-        """
-        Surcharge de la fonction de lecture de la matrice
-
-        Utile notamment puor le fichier zbin
-        """
-
-        if self.filename[-4:]=='zbin':
-            fileold = self.filename
-
-            self.filename = fileold[:-4]+'top'
-
-            if not os.path.exists(self.filename):
-                self.filename = fileold
-                return
-
-            self.read_data()
-            toparray = self.array.copy()
-
-            self.filename = fileold[:-4]+'hbin'
-            if not os.path.exists(self.filename):
-                self.filename = fileold
-                return
-
-            self.read_data()
-            harray = self.array.copy()
-
-            self.array = toparray+harray
-            self.array.mask = self.masksrc
-
-            self.filename = fileold
-        else:
-            return super().read_data()
-
-    def write_all(self):
-        return super().write_all()
-
-    def write_array(self):
-        """
-        Surcharge de la fonction d'écriture de la matrice
-
-        Utile notamment puor le fichier zbin
-        """
-        if self.filename[-4:]=='zbin':
-            fileold = self.filename
-
-            self.filename = fileold[:-4]+'top'
-            if not os.path.exists(self.filename):
-                self.filename = fileold
-                return
-
-            zarray = self.array.copy()
-            self.read_data()
-            toparray = self.array.copy()
-
-            self.array = zarray-toparray
-            self.array[np.where(self.array<0.)]=0.
-
-            self.filename = fileold[:-4]+'hbin'
-            self.write_array()
-
-            self.filename = fileold
-
-        else:
-            return super().write_array()