wolfhece 2.2.34__py3-none-any.whl → 2.2.35__py3-none-any.whl

wolfhece/wolf_array.py

@@ -756,7 +756,7 @@ class header_wolf():
     def ij2xy_np(self, ij:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
         """ alias for get_xy_from_ij_array
 
-        :param ij: numpy array containing (i, j, [k]) indices
+        :param ij: numpy array containing (i, j, [k]) indices - like np.argwhere() - shape (n, 2) or (n, 3)
         :param scale: scaling of the spatial resolution (dx,dy,[dz])
         :param aswolf: if True, input is one-based (as Wolf VB6 or Fortran), otherwise 0-based (default Python standard)
         :param abs: if True, add translation to results (x, y, [z]) (coordinate to global space)
@@ -770,6 +770,13 @@ class header_wolf():
         """
         return self.get_xy_from_ij_array(ij, scale, aswolf, abs)
 
+    def ij2xy_np_ij_from_npwhere(self, ij:np.ndarray, scale:float=1., aswolf:bool=False, abs:bool=True) -> np.ndarray:
+        """ alias for get_xy_from_ij_array but with ij as np.where result
+        """
+
+        ij = np.vstack((ij[0], ij[1])).T
+        return self.get_xy_from_ij_array(ij, scale, aswolf, abs)
+
     def xy2ij(self, x:float, y:float, z:float=0., scale:float=1., aswolf:bool=False, abs:bool=True, forcedims2:bool=False) -> Union[tuple[np.int32,np.int32], tuple[np.int32,np.int32,np.int32]]:
         """ alias for get_ij_from_xy """
         return self.get_ij_from_xy(x, y, z, scale, aswolf, abs, forcedims2)
@@ -1874,6 +1881,11 @@ class Ops_Array(wx.Frame):
         if self.wx_exists:
             self.set_GUI()
 
+    @property
+    def usemask(self):
+        """ Return the usemask Value """
+        return self.selectrestricttomask.GetValue()
+
     @property
     def idx(self):
         """ Return the idx of the parentarray """
@@ -2192,9 +2204,15 @@ class Ops_Array(wx.Frame):
         bSizer16_2 = wx.BoxSizer(wx.VERTICAL)
         bSizer16_3 = wx.BoxSizer(wx.VERTICAL)
 
-        selectmethodChoices = [_("by clicks"), _("inside active vector"), _("inside active zone"),
-                               _("inside temporary vector"), _("along active vector"), _("along active zone"),
-                               _("along temporary vector")]
+        selectmethodChoices = [_("by clicks"),
+                               _("inside active vector"),
+                               _("inside active zone"),
+                               _("inside temporary vector"),
+                               _("along active vector"),
+                               _("along active zone"),
+                               _("along temporary vector"),
+                            #    _("outside active vector")
+                               ]
         self.selectmethod = wx.RadioBox(self.selection, wx.ID_ANY, _("How to select nodes?"), wx.DefaultPosition,
                                         wx.DefaultSize, selectmethodChoices, 1, wx.RA_SPECIFY_COLS)
         self.selectmethod.SetSelection(0)
@@ -2445,21 +2463,65 @@ class Ops_Array(wx.Frame):
         sizermask.Add(maskdata, 1, wx.EXPAND)
         maskdata.Bind(wx.EVT_BUTTON, self.Onmask)
 
+        sizer_unmask = wx.BoxSizer(wx.HORIZONTAL)
         unmaskall = wx.Button(self.mask, wx.ID_ANY, _("Unmask all"), wx.DefaultPosition, wx.DefaultSize, 0)
-        sizermask.Add(unmaskall, 1, wx.EXPAND)
+        sizer_unmask.Add(unmaskall, 1, wx.EXPAND)
         unmaskall.Bind(wx.EVT_BUTTON, self.Unmaskall)
         unmaskall.SetToolTip(_("Unmask all values in the current array"))
 
         unmasksel = wx.Button(self.mask, wx.ID_ANY, _("Unmask selection"), wx.DefaultPosition, wx.DefaultSize, 0)
-        sizermask.Add(unmasksel, 1, wx.EXPAND)
-        unmasksel.Bind(wx.EVT_BUTTON, self.Unmasksel)
+        sizer_unmask.Add(unmasksel, 1, wx.EXPAND)
+        unmasksel.Bind(wx.EVT_BUTTON, self.Unmask_selection)
         unmasksel.SetToolTip(_("Unmask all values in the current selection \n If you wish to unmask some of the currently masked data, you have to first select the desired nodes by unchecking the 'Use mask to retrict' on the 'Selection' panel, otherwise it is impossible to select these nodes"))
 
+        sizermask.Add(sizer_unmask, 1, wx.EXPAND)
+
         invertmask = wx.Button(self.mask, wx.ID_ANY, _("Invert mask"), wx.DefaultPosition, wx.DefaultSize, 0)
         sizermask.Add(invertmask, 1, wx.EXPAND)
         invertmask.Bind(wx.EVT_BUTTON, self.InvertMask)
         invertmask.SetToolTip(_("Logical operation on mask -- mask = ~mask"))
 
+        sizer_maskunmask_poly = wx.BoxSizer(wx.HORIZONTAL)
+
+        mask_in_poly = wx.Button(self.mask, wx.ID_ANY, _("Mask inside active vector (+NoData)"), wx.DefaultPosition, wx.DefaultSize, 0)
+        sizer_maskunmask_poly.Add(mask_in_poly, 1, wx.EXPAND)
+        mask_in_poly.Bind(wx.EVT_BUTTON, self.Mask_inside_active_vector)
+        mask_in_poly.SetToolTip(_("Mask all values inside the active vector and set NoData to masked values"))
+
+        mask_out_poly = wx.Button(self.mask, wx.ID_ANY, _("Mask outside active vector (+NoData)"), wx.DefaultPosition, wx.DefaultSize, 0)
+        sizer_maskunmask_poly.Add(mask_out_poly, 1, wx.EXPAND)
+        mask_out_poly.Bind(wx.EVT_BUTTON, self.Mask_outside_active_vector)
+        mask_out_poly.SetToolTip(_("Mask all values outside the active vector and set NoData to masked values"))
+
+        sizermask.Add(sizer_maskunmask_poly, 1, wx.EXPAND)
+
+        sizer_maskunmask_poly_wonodata = wx.BoxSizer(wx.HORIZONTAL)
+
+        mask_in_poly_nodata = wx.Button(self.mask, wx.ID_ANY, _("Mask inside active vector"), wx.DefaultPosition, wx.DefaultSize, 0)
+        sizer_maskunmask_poly_wonodata.Add(mask_in_poly_nodata, 1, wx.EXPAND)
+        mask_in_poly_nodata.Bind(wx.EVT_BUTTON, self.Mask_inside_active_vector_wo_nodata)
+        mask_in_poly_nodata.SetToolTip(_("Mask all values inside the active vector"))
+
+        mask_out_poly_nodata = wx.Button(self.mask, wx.ID_ANY, _("Mask outside active vector"), wx.DefaultPosition, wx.DefaultSize, 0)
+        sizer_maskunmask_poly_wonodata.Add(mask_out_poly_nodata, 1, wx.EXPAND)
+        mask_out_poly_nodata.Bind(wx.EVT_BUTTON, self.Mask_outside_active_vector_wo_nodata)
+        mask_out_poly_nodata.SetToolTip(_("Mask all values outside the active vector"))
+
+        sizermask.Add(sizer_maskunmask_poly_wonodata, 1, wx.EXPAND)
+
+        mask_inside_polys =wx.BoxSizer(wx.HORIZONTAL)
+        mask_in_polys = wx.Button(self.mask, wx.ID_ANY, _("Mask inside active zone (+NoData)"), wx.DefaultPosition, wx.DefaultSize, 0)
+        mask_inside_polys.Add(mask_in_polys, 1, wx.EXPAND)
+        mask_in_polys.Bind(wx.EVT_BUTTON, self.Mask_inside_active_zone)
+        mask_in_polys.SetToolTip(_("Mask all values inside the active zone and set NoData to masked values"))
+
+        mask_inside_polys_nodata = wx.Button(self.mask, wx.ID_ANY, _("Mask inside active zone"), wx.DefaultPosition, wx.DefaultSize, 0)
+        mask_inside_polys.Add(mask_inside_polys_nodata, 1, wx.EXPAND)
+        mask_inside_polys_nodata.Bind(wx.EVT_BUTTON, self.Mask_inside_active_zone_wo_nodata)
+        mask_inside_polys_nodata.SetToolTip(_("Mask all values inside the active zone"))
+
+        sizermask.Add(mask_inside_polys, 1, wx.EXPAND)
+
         self.mask.Layout()
         sizermask.Fit(self.mask)
 
@@ -2630,13 +2692,13 @@ class Ops_Array(wx.Frame):
         self.parentarray.mask_reset()
         self.refresh_array()
 
-    def Unmasksel(self, event:wx.MouseEvent):
+    def Unmask_selection(self, event:wx.MouseEvent):
         """
         Enlève le masque des éléments sélectionnés
         @author Pierre Archambeau
         """
 
-        self.parentarray.SelectionData.Unmasksel()
+        self.parentarray.SelectionData.unmask_selection()
 
 
     def InvertMask(self, event: wx.MouseEvent):
@@ -2645,6 +2707,42 @@ class Ops_Array(wx.Frame):
         self.parentarray.mask_invert()
         self.refresh_array()
 
+    def Mask_inside_active_vector(self, event: wx.MouseEvent):
+        """ Mask inside the active vector """
+        if self.active_vector is not None:
+            self.parentarray.mask_insidepoly(self.active_vector,)
+            self.refresh_array()
+
+    def Mask_inside_active_vector_wo_nodata(self, event: wx.MouseEvent):
+        """ Mask inside the active vector without setting NoData """
+        if self.active_vector is not None:
+            self.parentarray.mask_insidepoly(self.active_vector, set_nullvalue=False)
+            self.refresh_array()
+
+    def Mask_outside_active_vector(self, event: wx.MouseEvent):
+        """ Mask outside the active vector """
+        if self.active_vector is not None:
+            self.parentarray.mask_outsidepoly(self.active_vector)
+            self.refresh_array()
+
+    def Mask_inside_active_zone(self, event: wx.MouseEvent):
+        """ Mask inside the active zone """
+        if self.active_zone is not None:
+            self.parentarray.mask_insidepolys(self.active_zone.myvectors)
+            self.refresh_array()
+
+    def Mask_inside_active_zone_wo_nodata(self, event: wx.MouseEvent):
+        """ Mask inside the active zone without setting NoData """
+        if self.active_zone is not None:
+            self.parentarray.mask_insidepolys(self.active_zone.myvectors, set_nullvalue=False)
+            self.refresh_array()
+
+    def Mask_outside_active_vector_wo_nodata(self, event: wx.MouseEvent):
+        """ Mask outside the active vector without setting NoData """
+        if self.active_vector is not None:
+            self.parentarray.mask_outsidepoly(self.active_vector, set_nullvalue=False)
+            self.refresh_array()
+
     def interp2Dpolygons(self, event: wx.MouseEvent):
         """
         Bouton d'interpolation sous tous les polygones d'une zone
@@ -2685,48 +2783,6 @@ class Ops_Array(wx.Frame):
 
         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"
@@ -2784,9 +2840,7 @@ class Ops_Array(wx.Frame):
         else:
             structure = np.ones((3, 3))
 
-        usemask = self.selectrestricttomask.GetValue()
-
-        self.parentarray.SelectionData.erode_selection(nb, usemask, structure)
+        self.parentarray.SelectionData.erode_selection(nb, self.usemask, structure)
         self.refresh_array()
 
     def OnExpandSelection(self, event):
@@ -2797,9 +2851,7 @@ class Ops_Array(wx.Frame):
         else:
             structure = np.ones((3, 3))
 
-        usemask = self.selectrestricttomask.GetValue()
-
-        self.parentarray.SelectionData.dilate_selection(nb, usemask, structure)
+        self.parentarray.SelectionData.dilate_selection(nb, self.usemask, structure)
         self.refresh_array()
 
     def OnExpandUnselectInterior(self, event):
@@ -2811,9 +2863,7 @@ class Ops_Array(wx.Frame):
         else:
             structure = np.ones((3, 3))
 
-        usemask = self.selectrestricttomask.GetValue()
-
-        self.parentarray.SelectionData.dilate_contour_selection(nb, usemask, structure)
+        self.parentarray.SelectionData.dilate_contour_selection(nb, self.usemask, structure)
         self.refresh_array()
 
     def OnUnselectInterior(self, event):
@@ -2947,7 +2997,7 @@ class Ops_Array(wx.Frame):
         # condition value
         curcondvalue = float(self.condvalue.GetValue())
 
-        self.parentarray.SelectionData.condition_select(curcond, curcondvalue)
+        self.parentarray.SelectionData.condition_select(curcond, curcondvalue, usemask=self.usemask)
 
         self.refresh_array()
 
@@ -3470,6 +3520,21 @@ class Ops_Array(wx.Frame):
         self._select_vector_inside_manager(self.active_vector)
         self.refresh_array()
 
+    def select_vector_outside_manager(self):
+        """ Select nodes outside the active vector (manager) """
+        if self.active_vector is None:
+            logging.warning(_('Please activate a vector !'))
+            return
+
+        if self.active_vector.nbvertices == 0:
+            logging.warning(_('Please add points to vector or select another !'))
+            return
+
+        logging.info(_('Select nodes outside the active polygon/vector...'))
+        self._select_vector_outside_manager(self.active_vector)
+        self.refresh_array()
+
+
     def _select_vector_inside_manager(self, vect: vector):
         """ Select nodes inside a vector or set action to add vertices to a vector by clicks"""
 
@@ -3488,6 +3553,24 @@ class Ops_Array(wx.Frame):
             firstvert = wolfvertex(0., 0.)
             self.vectmp.add_vertex(firstvert)
 
+    def _select_vector_outside_manager(self, vect: vector):
+        """ Select nodes outside a vector or set action to add vertices to a vector by clicks"""
+
+        if vect.nbvertices > 2:
+            self.parentarray.SelectionData.select_outsidepoly(vect)
+
+        elif self.mapviewer is not None:
+            if vect.nbvertices < 3:
+                logging.info(_('Please add points to vector !'))
+
+            self.mapviewer.start_action('select by vector outside', _('Please draw a polygon...'))
+            self.mapviewer.active_array = self.parentarray
+            self.mapviewer.set_label_selecteditem(self.parentarray.idx)
+            self.Active_vector(vect)
+
+            firstvert = wolfvertex(0., 0.)
+            self.vectmp.add_vertex(firstvert)
+
     def select_zone_under_manager(self):
         """ Select nodes along the active zone (manager) """
 
@@ -3597,6 +3680,9 @@ class Ops_Array(wx.Frame):
             logging.info(_('   Choose vector by clicks...'))
             logging.info(_(''))
             self.select_vector_under_tmp()
+        # elif id == 7:
+        #     logging.info(_('Node selection outside active vector (manager)'))
+        #     self.select_vector_outside_manager()
 
     def onclose(self, event:wx.MouseEvent):
         """ Hide the window """
@@ -3819,40 +3905,370 @@ class Ops_Array(wx.Frame):
         dlg.Destroy()
 
 
+ALL_SELECTED = 'all'
+
+class StorageMode(Enum):
+    """ Storage mode for selections in WolfArray """
+    LIST = 0
+    ARRAY = 1
+
 class SelectionData():
     """
     User-selected data in a WolfArray
 
     Contains two storage elements :
-        - myselection (list): Current selection which will be lost in the event of a reset
+        - myselection
         - selections( dict): Stored selection(s) to be used, for example, in a spatial interpolation operation.
                              These selections are only lost in the event of a general reset.
 
     The selected nodes are stored using their "world" spatial coordinates so that they can be easily transferred to other objects.
+
+    The "myselection" can be stored in two modes :
+        - LIST: 'all' or list of (x, y) coordinates or tuple of ('all', np.ndarray) for all nodes and excluded nodes
+        - ARRAY: np.ndarray of selected nodes (boolean array) with shape (nbx, nby) where nbx and nby are the number of nodes in the x and y directions respectively.
+        The boolean array is True if the node is selected, False if not selected.
+
+    The selection can be converted from one mode to another automatically based on the number of nodes in the array.
+    If the number of nodes exceeds a threshold (default is 100,000), the selection is stored as an ARRAY.
+    Otherwise, it is stored as a LIST.
+
+    The selection can be forced to a specific storage mode using the `force_storage_mode` method.
     """
 
-    myselection:list[tuple[float, float]]
+    # 'all' or list of (x, y) coordinates or a tuple of ('all', np.ndarray) for all nodes and excluded nodes
+    _myselection:list[tuple[float, float]] | str | tuple[str, np.ndarray]
+
     selections: dict[str:dict['select':list[tuple[float, float]], 'idgllist':int, 'color':list[float]]]
 
-    def __init__(self, parent:"WolfArray") -> None:
+    def __init__(self, parent:"WolfArray", threshold_array_mode:int = 100_000) -> None:
+        """ Initialize the SelectionData object.
+
+        :param parent: The parent WolfArray object to which this selection data belongs.
+        :param threshold_array_mode: The threshold number of nodes to switch from LIST to ARRAY storage mode.
+        """
 
         self.parent: WolfArray
         self.parent = parent
 
         self.wx_exists = wx.GetApp() is not None
 
-        self.myselection = []
+        self._myselection = []
         self.selections = {}
 
+        self._boolarray: np.ndarray | None = None # boolean array for selection - True if selected, False if not selected
+
+        self._storage_mode = StorageMode.LIST # 0: 'all' or list of (x, y) coordinates or tuple of ('all', np.ndarray) for all nodes and excluded nodes, 1 for np.ndarray of selected nodes
+
         self.update_plot_selection = False # force to update OpenGL list if True
         self.hideselection = False
         self.numlist_select = 0 # OpenGL list index
+        self.threshold_array_mode = threshold_array_mode # Default threshold for switching storage mode
+
+    def _auto_storage_mode(self):
+        """ Choose the storage mode based on the number of nodes in the array """
+
+        if self.nb > self.threshold_array_mode:
+            _storage_mode = StorageMode.ARRAY
+        else:
+            _storage_mode = StorageMode.LIST
+
+        if self._storage_mode != _storage_mode:
+            self._convert_to_storage_mode(_storage_mode)
+
+    def _convert_to_storage_mode(self, new_mode:StorageMode):
+        """ Convert the selection to the new storage mode.
+
+        :param new_mode: The new storage mode to convert to (StorageMode.LIST or StorageMode.ARRAY).
+        """
+
+        logging.info('Switching storage mode to {}'.format(new_mode))
+
+        if self._storage_mode == StorageMode.LIST:
+            # Convert from 'all' or list of (x, y) coordinates or tuple of ('all', np.ndarray) to np.ndarray
+            _bool_array = self._myselection_as_array
+
+            if self._myselection == ALL_SELECTED:
+                _bool_array[:,:] = True
+
+            elif isinstance(self._myselection, list):
+
+                if len(self._myselection) == 0:
+                    _bool_array[:,:] = False
+                else:
+                    _bool_array[:,:] = False
+                    xy = np.asarray(self._myselection)
+                    ij = self.parent.xy2ij_np(xy)
+                    _bool_array[ij[:, 0], ij[:, 1]] = True
+
+            elif isinstance(self._myselection, tuple) and len(self._myselection) == 2 and self._myselection[0] == ALL_SELECTED:
+                _bool_array[:,:] = True
+                _excluded_nodes = self._myselection[1]
+
+                if _excluded_nodes.size > 0:
+                    _excluded_nodes = self.parent.xy2ij_np(_excluded_nodes)
+                    _bool_array[_excluded_nodes[:, 0], _excluded_nodes[:, 1]] = False
+
+            self._myselection = []
+
+        elif self._storage_mode == StorageMode.ARRAY:
+
+            if self.is_all_selected():
+                self._myselection = ALL_SELECTED
+            else:
+                nb = self.nb
+                if nb == 0:
+                    self._myselection = []
+                elif nb / max(self.parent.nbnotnull, 1) > 0.5:
+                    ij_not_selected = np.argwhere(~self._myselection_as_array)
+                    xy_not_selected = self.parent.ij2xy_np(ij_not_selected)
+                    self._myselection = (ALL_SELECTED, xy_not_selected)
+                else:
+                    ij_selected = np.argwhere(self._myselection_as_array)
+                    xy_selected = self.parent.ij2xy_np(ij_selected)
+                    self._myselection = list(map(tuple, xy_selected))
+
+        self._storage_mode = new_mode
+
+    def force_storage_mode(self, new_mode:StorageMode):
+        """ Force the storage mode to the new mode.
+
+        :param new_mode: The new storage mode to force (StorageMode.LIST or StorageMode.ARRAY).
+        """
+
+        if new_mode not in StorageMode:
+            logging.error('Invalid storage mode - must be LIST or ARRAY')
+            return
+        if self._storage_mode != new_mode:
+            self._convert_to_storage_mode(new_mode)
+
+    @property
+    def myselection(self) -> list[tuple[float, float]] | str:
+        """ Current selection of nodes.
+
+        Returns:
+            - 'all' if all nodes are selected
+            - list of (x, y) coordinates if specific nodes are selected
+        """
+
+        if self._storage_mode == StorageMode.LIST:
+            if self._myselection == ALL_SELECTED:
+                return ALL_SELECTED
+            elif isinstance(self._myselection, list):
+                return self._myselection
+            elif isinstance(self._myselection, tuple) and len(self._myselection) == 2 and self._myselection[0] == ALL_SELECTED:
+
+                excluded_nodes = self._myselection[1]
+                if excluded_nodes.shape[0] == 0:
+                    return ALL_SELECTED
+                else:
+                    if self.parent.usemask:
+                        # Return all nodes except the excluded ones
+                        loc_mask = ~ self.parent.array.mask.copy()
+                    else:
+                        loc_mask = np.ones((self.parent.nbx, self.parent.nby), dtype=bool)
+
+                    ij_excluded = self.parent.xy2ij_np(excluded_nodes)
+                    loc_mask[ij_excluded[:, 0], ij_excluded[:, 1]] = False
+                    ij = np.argwhere(loc_mask)
+                    xy = self.parent.ij2xy_np(ij)
+                    return list(map(tuple, xy))  # Convert to list of tuples
+
+        elif self._storage_mode == StorageMode.ARRAY:
+            if self.is_all_selected():
+                return ALL_SELECTED
+            else:
+                nbsel = np.count_nonzero(self._myselection_as_array)
+                if nbsel == 0:
+                    return []
+                else:
+                    # Convert boolean array to list of (x, y) coordinates
+                    ij_selected = np.argwhere(self._myselection_as_array)
+                    xy_selected = self.parent.ij2xy_np(ij_selected)
+                    return list(map(tuple, xy_selected))
+
+        else:
+            logging.error('Invalid storage mode - must be LIST or ARRAY')
+            return []
+
+    @property
+    def _myselection_as_array(self) -> np.ndarray:
+        """ Current selection of nodes as a numpy array.
+
+        Returns:
+            - np.ndarray of shape (nbx, nby) where nbx and nby are the number of nodes in the x and y directions respectively.
+            - True if the node is selected, False if not selected.
+        """
+
+        if self._storage_mode == StorageMode.LIST:
+
+            if self._boolarray is not None:
+                return self._boolarray
+
+            self._boolarray = np.zeros((self.parent.nbx, self.parent.nby), dtype=bool)
+
+            if self._myselection == ALL_SELECTED:
+                if self.parent.usemask:
+                    self._boolarray[:,:] = ~self.parent.array.mask[:,:]
+                else:
+                    self._boolarray[:,:] = True
+
+            elif isinstance(self._myselection, list):
+                # Convert list of (x, y) coordinates to boolean array
+                if len(self._myselection) > 0:
+                    xy= np.asarray(self._myselection)
+                    ij = self.parent.xy2ij_np(xy)
+                    self._boolarray[ij[:, 0], ij[:, 1]] = True
+
+            elif isinstance(self._myselection, tuple) and len(self._myselection) == 2 and self._myselection[0] == ALL_SELECTED:
+
+                # tuple of ('all', np.ndarray) for all nodes and excluded nodes
+                if self.parent.usemask:
+                    self._boolarray[:,:] = ~self.parent.array.mask[:,:]
+                else:
+                    self._boolarray[:,:] = True
+
+                # Exclude nodes from the second element of the tuple
+                excluded_nodes = self.myselection[1]
+                if excluded_nodes.size > 0:
+                    excluded_ij = self.parent.xy2ij_np(excluded_nodes)
+                    self._boolarray[excluded_ij[:, 0], excluded_ij[:, 1]] = False
+
+        elif self._storage_mode == StorageMode.ARRAY:
+
+            if self._boolarray is None:
+                self._boolarray = np.zeros((self.parent.nbx, self.parent.nby), dtype=bool)
+
+        return self._boolarray
+
+    @_myselection_as_array.setter
+    def _myselection_as_array(self, value: np.ndarray):
+        """ Set the current selection of nodes as a numpy array.
+
+        :param value: numpy array of shape (nbx, nby) where nbx and nby are the number of nodes in the x and y directions respectively.
+        True if the node is selected, False if not selected.
+        """
+
+        if not isinstance(value, np.ndarray):
+            logging.error('Invalid value for myselection_as_array - must be a numpy array')
+        if value.shape != (self.parent.nbx, self.parent.nby):
+            logging.error('Invalid shape for myselection_as_array - must be ({}, {})'.format
+                          (self.parent.nbx, self.parent.nby))
+
+        if self._boolarray is None:
+            self._boolarray = value.copy()
+        else:
+            self._boolarray[:,:] = value[:,:]
+
+    @property
+    def myselection_npargwhere(self) -> np.ndarray:
+        """ Current selection of nodes as a numpy array using np.argwhere """
+        return np.argwhere(self._myselection_as_array)
+
+    @myselection.setter
+    def myselection(self, value: list[tuple[float, float]] | str | tuple[str, np.ndarray]):
+        """ Set the current selection of nodes.
+
+        :param value: 'all' to select all nodes, a list of (x, y) coordinates to select specific nodes,
+                       or a tuple of ('all', np.ndarray) for all nodes and excluded nodes.
+        """
+
+        if self._storage_mode == StorageMode.ARRAY:
+            # Convert to the new storage mode if necessary
+            if isinstance(value, list):
+                if len(value) == 0:
+                    self._myselection_as_array[:,:] = False
+                else:
+                    ij = self.parent.xy2ij_np(np.array(value))
+                    self._myselection_as_array[:,:] = False
+                    self._myselection_as_array[ij[:, 0], ij[:, 1]] = True
+
+            elif isinstance(value, str):
+
+                if value == ALL_SELECTED:
+                    if self.parent.usemask:
+                        self._myselection_as_array[:,:] = ~self.parent.array.mask[:,:]
+                    else:
+                        self._myselection_as_array[:,:] = True
+                else:
+                    logging.error('Invalid selection value - must be "all" or a list of (x, y) coordinates')
+
+            elif isinstance(value, tuple) and len(value) == 2 and value[0] == ALL_SELECTED:
+                # tuple of ('all', np.ndarray) for all nodes and excluded nodes
+                if self.parent.usemask:
+                    self._myselection_as_array[:,:] = ~self.parent.array.mask[:,:]
+                else:
+                    self._myselection_as_array[:,:] = True
+
+                excluded_nodes = value[1]
+                if excluded_nodes.size > 0:
+                    ij_excluded = self.parent.xy2ij_np(excluded_nodes)
+                    self._myselection_as_array[ij_excluded[:, 0], ij_excluded[:, 1]] = False
+
+            else:
+                logging.error('Invalid selection value - must be "all" or a list of (x, y) coordinates or a tuple of ("all", np.ndarray)')
+
+        elif self._storage_mode == StorageMode.LIST:
+
+            if isinstance(value, list):
+                if len(value) == 0:
+                    self._myselection = []
+                else:
+                    self._myselection = value
+
+            elif isinstance(value, str):
+                if value == ALL_SELECTED:
+                    self._myselection = ALL_SELECTED
+                else:
+                    logging.error('Invalid selection value - must be "all" or a list of (x, y) coordinates')
+
+            elif isinstance(value, tuple) and len(value) == 2 and value[0] == ALL_SELECTED:
+                # tuple of ('all', np.ndarray) for all nodes and excluded nodes
+                self._myselection = value
+
+            else:
+                logging.error('Invalid selection value - must be "all" or a list of (x, y) coordinates or a tuple of ("all", np.ndarray)')
+
+        self.update_nb_nodes_selection()
+
+    def is_all_selected(self) -> bool:
+        """ Check if all nodes are selected.
+
+        :return: True if all nodes are selected, False otherwise
+        """
+
+        if self._storage_mode == StorageMode.LIST:
+
+            if self.myselection == ALL_SELECTED:
+                return True
+            elif isinstance(self.myselection, list):
+                if self.parent.usemask:
+                    return len(self.myselection) == self.parent.nbnotnull
+                else :
+                    return len(self.myselection) == self.parent.nbx * self.parent.nby
+            elif isinstance(self.myselection, tuple) and len(self.myselection) == 2 and self.myselection[0] == ALL_SELECTED:
+                # tuple of ('all', np.ndarray) for all nodes and excluded nodes
+                if self.myselection[1].size == 0:
+                    return True
+            return False
+
+        elif self._storage_mode == StorageMode.ARRAY:
+            if self.nb > 0:
+                # Check if all nodes are selected in the boolean array
+                if self.parent.usemask:
+                    return np.all(self._myselection_as_array)
+                else:
+                    return np.all(self._myselection_as_array == ~self.parent.array.mask)
+            else:
+                return False
 
     def set_selection_from_list_xy(self, xylist: list[tuple[float, float]]):
-        """ Set the current selection from a list of (x, y) coordinates """
+        """ Set the current selection from a list of (x, y) coordinates.
+
+        Alias for myselection setter to set a list of (x, y) coordinates.
+        This will convert the list to the appropriate storage mode if necessary.
+        """
 
         self.myselection = xylist
-        self.update_nb_nodes_selection()
 
     @property
     def dx(self) -> float:
@@ -3874,51 +4290,60 @@ class SelectionData():
 
     @property
     def nb(self) -> int:
-        """ Number of selected nodes """
+        """ Number of selected nodes. """
 
-        if self.myselection == 'all':
-            return self.parent.nbnotnull
-        else:
-            return len(self.myselection)
+        if self._storage_mode == StorageMode.LIST:
 
-    def Unmasksel(self, resetplot:bool=True):
-        """ Unmask selection """
+            if self._myselection == ALL_SELECTED:
+                if self.parent.usemask:
+                    return self.parent.nbnotnull
+                else:
+                    return self.parent.nbx * self.parent.nby
 
-        curarray: WolfArray
-        curarray = self.parent
+            elif isinstance(self._myselection, tuple) and len(self._myselection) == 2 and self._myselection[0] == ALL_SELECTED:
+                # tuple of ('all', np.ndarray) for all nodes and excluded nodes
+                if self.parent.usemask:
+                    return self.parent.nbnotnull - self._myselection[1].shape[0]
+                else:
+                    return self.parent.nbx * self.parent.nby - self._myselection[1].shape[0]
+            else:
+                return len(self._myselection)
 
-        if self.nb == 0:
-            return
-        else:
-            destxy = self.myselection
+        elif self._storage_mode == StorageMode.ARRAY:
 
-        if len(destxy) == 0:
-            logging.error(_('No selection to unmask'))
-            return
+            return np.count_nonzero(self._myselection_as_array)
 
-        if destxy == 'all':
-            curarray.array.mask[:, :] = False
-        else:
-            destij = np.asarray([list(curarray.get_ij_from_xy(x, y)) for x, y in destxy])
+    def unmask_selection(self, resetplot:bool=True):
+        """ Unmask selection """
+
+        if self.nb == 0:
+            return
 
-            curarray.array.mask[destij[:, 0], destij[:, 1]] = False
+        self.parent.array.mask[self.myselection_npargwhere] = False
 
         if resetplot:
-            curarray.reset_plot()
+            self.parent.reset_plot()
 
     def reset(self):
         """ Reset the selection """
 
         self.myselection = []
+        self._boolarray = None  # Reset the boolean array
+        self._storage_mode = StorageMode.LIST  # Reset the storage mode to LIST
 
     def reset_all(self):
         """ Reset the selection """
 
-        self.myselection = []
+        self.reset()
         self.selections = {}
 
     def get_string(self, which:str = None, all_memories:bool= False) -> str:
-        """ Get string of the current selection or of a stored one """
+        """ Get string of the current selection or of a stored one.
+
+        :param which: id/key of the selection to get the string for. If None, get the current selection.
+        :param all_memories: If True, include all stored selections in the output string.
+        :return: String representation of the selection.
+        """
 
         if which is None:
             curlist = self.myselection
@@ -3937,7 +4362,7 @@ class SelectionData():
         if len(curlist) == 0:
             return ''
 
-        if curlist == 'all':
+        if curlist == ALL_SELECTED:
             txt += 'all\n'
             return txt
 
@@ -3956,9 +4381,13 @@ class SelectionData():
         return txt
 
     def get_script(self, which:int = None) -> str:
-        """ Get script of the current selection or of a stored one """
+        """ Get script of the current selection or of a stored one.
+
+        :param which: id/key of the selection to get the script for. If None, get the current selection.
+        :return: Script representation of the selection.
+        """
 
-        if self.myselection == 'all':
+        if self.myselection == ALL_SELECTED:
             logging.error(_('Cannot create script for "all" selection'))
             return ''
 
@@ -3998,7 +4427,14 @@ class SelectionData():
         return txt
 
     def copy_to_clipboard(self, which:int = None, typestr:Literal['string', 'script'] = 'string'):
-        """ Copy current selection to clipboard """
+        """ Copy current selection to clipboard.
+
+        -- ONLY WORKS WITH wxPython --
+
+        :param which: id/key of the selection to copy. If None, copy the current selection.
+        :param typestr: Type of data to copy to clipboard - 'string' for string representation, 'script' for script representation.
+        """
+
         if self.wx_exists:
             if wx.TheClipboard.Open():
                 wx.TheClipboard.Clear()
@@ -4010,15 +4446,22 @@ class SelectionData():
                 wx.TheClipboard.Close()
             else:
                 logging.warning(_('Cannot open the clipboard'))
+        else:
+            logging.warning(_('Clipboard is not available in this environment'))
 
     def reselect_from_memory(self, idx:list[str] = None):
         """
         Reselect a stored selection
 
-        :param idx: id/key of the selection
+        :param idx: id/key of the selection to reselect. If None, show a dialog to choose from available selections.
         """
 
         if idx is None:
+            if not self.wx_exists:
+                logging.error(_('Cannot reselect from memory - no wxPython available'))
+                logging.error(_('Please use the method reselect_from_memory with a list of keys'))
+                return
+
             keys = list(self.selections.keys())
 
             keys = [cur for cur in keys if len(self.selections[cur]['select']) > 0]
@@ -4041,11 +4484,12 @@ class SelectionData():
 
         for curidx in idx:
             if curidx in self.selections:
-                self.myselection += self.selections[curidx]['select']
+                self.add_nodes_to_selection(self.selections[curidx]['select'])
+                # self.myselection += self.selections[curidx]['select']
             else:
                 logging.error(_('Selection {} does not exist').format(idx))
 
-            self.update_nb_nodes_selection()
+            # self.update_nb_nodes_selection()
             self.parent.reset_plot()
 
     def move_selectionto(self, idx:str, color:list[float], resetplot:bool=True):
@@ -4054,6 +4498,7 @@ class SelectionData():
 
         :param idx: id/key of the selection
         :param color: color of the selection - list of 4 integers between 0 and 255
+        :param resetplot: if True, reset the plot after moving the selection
         """
 
         assert len(color) == 4, "color must be a list of 4 integers between 0 and 255"
@@ -4068,7 +4513,7 @@ class SelectionData():
         curdict['color'] = color
 
         self.myselection = []   # reset current selection
-        self.update_nb_nodes_selection()
+        # self.update_nb_nodes_selection()
 
         if resetplot:
             self.parent.reset_plot()
@@ -4083,7 +4528,7 @@ class SelectionData():
         if len(self.selections) > 0:
             # plot stored selections
             for cur in self.selections.values():
-                if cur['select'] != 'all':
+                if cur['select'] != ALL_SELECTED:
                     self.update_plot_selection = update_select
                     col = cur['color']
                     cur['idgllist'] = self._plot_selection(cur['select'],
@@ -4092,9 +4537,9 @@ class SelectionData():
                                                            cur['idgllist'])
 
 
-        if self.myselection != 'all':
+        if self._myselection != ALL_SELECTED and not isinstance(self._myselection, tuple):
             # plot current selection in RED if not 'all'
-            if len(self.myselection) > 0:
+            if self.nb > 0:
                 self.update_plot_selection = update_select
                 self.numlist_select = self._plot_selection(self.myselection,
                                                            (1., 0., 0.),
@@ -4163,8 +4608,8 @@ class SelectionData():
         """
         Add one coordinate to the selection
 
-        :param x: x coordinate
-        :param y: y coordinate
+        :param x: x coordinate - float
+        :param y: y coordinate - float
         :param verif: if True, the coordinates are checked to avoid duplicates
         """
 
@@ -4179,48 +4624,79 @@ class SelectionData():
         else:
             return -1 # useful for MB
 
-    def add_nodes_to_selection(self, xy:list[float], verif:bool=True):
+        self.update_nb_nodes_selection()
+
+    def add_nodes_to_selection(self, xy:list[float] | np.ndarray, verif:bool=True):
         """
-        Add multiple coordinates to the selection
+        Add multiple coordinates to the selection.
 
-        :param xy: list of coordinates
+        :param xy: list of coordinates or numpy array of shape (nb_nodes, 2) where nb_nodes is the number of nodes
+                   or a numpy array of shape (nbx, nby) where nbx and nby are the number of nodes in the x and y directions respectively.
+                   If a numpy array of shape (nbx, nby) is provided, it is assumed to be a boolean array where True indicates a selected node.
         :param verif: if True, the coordinates are checked to avoid duplicates
         """
 
         # 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)
+        if isinstance(xy, np.ndarray):
+            self._add_nodes_to_selection_np(xy, verif)
+        else:
+            ij = [self.parent.get_ij_from_xy(x, y) for x, y in xy]
+            self._add_nodes_to_selectionij(ij, verif)
 
     def _add_node_to_selectionij(self, i:int, j:int, verif=True):
         """
-        Add one ij coordinate to the selection
+        Add one ij coordinate to the selection.
 
         :param i: i coordinate
         :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):
-            self.myselection = []
-
-        if verif:
-            try:
-                ret = self.myselection.index((x1, y1))
-            except:
-                ret = -1
-            if ret >= 0:
-                self.myselection.pop(ret)
+        if self._storage_mode == StorageMode.ARRAY:
 
-                return 0
+            if verif:
+                self._boolarray[i, j] = not self._boolarray[i, j]
             else:
-                self.myselection.append((x1, y1))
-                return 0
-        else:
-            self.myselection.append((x1, y1))
-            return 0
+                self._boolarray[i, j] = True
+
+        elif self._storage_mode == StorageMode.LIST:
+            x1, y1 = self.parent.get_xy_from_ij(i, j)
+
+            if self._myselection == ALL_SELECTED:
+                # If all nodes are selected, we need to exclude the current node
+                self._myselection = (ALL_SELECTED, np.array([[x1, y1]]))  # Exclude the current node
+            elif isinstance(self._myselection, tuple) and len(self._myselection) == 2 and self._myselection[0] == ALL_SELECTED:
+                # check is the current node is in the excluded nodes
+                excluded_nodes = self._myselection[1].tolist()
+                if (x1, y1) in excluded_nodes:
+                    # If the current node is in the excluded nodes, we remove it from the excluded nodes
+                    ret = excluded_nodes.index((x1, y1))
+                    excluded_nodes.pop(ret)
+                    if len(excluded_nodes) == 0:
+                        self._myselection = ALL_SELECTED  # All nodes are selected again
+                    else:
+                        self._myselection = (ALL_SELECTED, np.array(excluded_nodes))
+                else:
+                    # The node is included in the selection, we add it to the excluded nodes
+                    excluded_nodes.append((x1, y1))
+                    self._myselection = (ALL_SELECTED, np.array(excluded_nodes))
+            else:
+                if verif:
+                    try:
+                        ret = self._myselection.index((x1, y1))
+                    except:
+                        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):
         """
@@ -4230,94 +4706,171 @@ class SelectionData():
         :param verif: if True, the coordinates are checked to avoid duplicates
         """
 
-        if isinstance(self.myselection, str):
-            self.myselection = []
-
-
         if len(ij)==0:
             logging.info(_('Nothing to do in add_nodes_to_selectionij !'))
             return
 
-        nbini = len(self.myselection)
+        nbini = self.nb
 
-        xy = [self.parent.get_xy_from_ij(i, j) for i, j in ij]
+        ij = np.asarray(ij)
 
-        self.myselection += xy
-
-        if nbini != 0:
+        if self._storage_mode == StorageMode.ARRAY:
             if verif:
-                # trouve les éléments uniques dans la liste de tuples (--> axis=0) et retourne également le comptage
-                selunique, counts = np.unique(self.myselection, return_counts=True, axis=0)
+                self._boolarray[ij[:, 0], ij[:, 1]] = np.logical_xor(self._boolarray[ij[:, 0], ij[:, 1]], True)
+            else:
+                self._boolarray[ij[:, 0], ij[:, 1]] = True
+
+        elif self._storage_mode == StorageMode.LIST:
+
+            xy = self.parent.ij2xy_np(ij)
 
+            if self._myselection == ALL_SELECTED:
+                # If all nodes are selected, we need to exclude the current nodes
+                self._myselection = (ALL_SELECTED, xy)  # Exclude the current nodes
+
+            elif isinstance(self._myselection, tuple) and len(self._myselection) == 2 and self._myselection[0] == ALL_SELECTED:
+                # check if the current nodes are in the excluded nodes
+                excluded_nodes = self._myselection[1]
+                # extend the excluded nodes with the new ones
+                excluded_nodes = np.vstack((excluded_nodes, xy))
+
+                # Find the duplicates in the excluded nodes
+                selunique, counts = np.unique(excluded_nodes, return_counts=True, axis=0)
                 # les éléments énumérés plus d'une fois doivent être enlevés
-                # on trie par ordre décroissant
                 locsort = sorted(zip(counts.tolist(), selunique.tolist()), reverse=True)
                 counts = [x[0] for x in locsort]
                 sel = [tuple(x[1]) for x in locsort]
-
                 # on recherche le premier 1
                 if 1 in counts:
                     idx = counts.index(1)
                     # on ne conserve que la portion de liste utile
-                    self.myselection = sel[idx:]
+                    self._myselection = (ALL_SELECTED, np.array(sel[idx:]))
+                else:
+                    self._myselection = ALL_SELECTED  # All nodes are selected again
+            else:
+                # Add the new nodes to the selection
+
+                if nbini != 0:
+                    self._myselection += xy.tolist()
+
+                    if verif:
+                        # trouve les éléments uniques dans la liste de tuples (--> axis=0) et retourne également le comptage
+                        selunique, counts = np.unique(self._myselection, return_counts=True, axis=0)
+
+                        # les éléments énumérés plus d'une fois doivent être enlevés
+                        # on trie par ordre décroissant
+                        locsort = sorted(zip(counts.tolist(), selunique.tolist()), reverse=True)
+                        counts = [x[0] for x in locsort]
+                        sel = [tuple(x[1]) for x in locsort]
+
+                        # on recherche le premier 1
+                        if 1 in counts:
+                            idx = counts.index(1)
+                            # on ne conserve que la portion de liste utile
+                            self._myselection = sel[idx:]
+                        else:
+                            self._myselection = []
+                    else:
+                        self._myselection = np.unique(self.myselection, axis=0).tolist()
+                else:
+                    self._myselection = xy.tolist()
+
+        self.update_nb_nodes_selection()
+
+    def _add_nodes_to_selection_np(self, ij:np.ndarray, verif:bool=True):
+        """ Add multiple coordinates to the selection from a numpy array
+
+        :param ij: numpy array of coordinates - same shape as the parent array (nbx, nby) or (nb_nodes, 2)
+        :param verif: if True, the coordinates are checked to avoid duplicates
+        """
+
+        assert ij.shape == (self.parent.nbx, self.parent.nby) or ij.shape[1]==2, _('Invalid shape for ij - must be ({}, {})'.format(self.parent.nbx, self.parent.nby))
+
+        dtype = ij.dtype
+        if dtype not in [np.bool, np.int32, np.int64]:
+            assert ij.shape[1] == 2, _('Invalid shape for ij - must be ({}, {}) or (nb_nodes, 2)'.format(self.parent.nbx, self.parent.nby))
+            ij = self.parent.xy2ij_np(ij)
+
+        if self._storage_mode == StorageMode.ARRAY:
+            if verif:
+                if ij.shape[1] == 2:
+                    # using xy from np.where
+                    self._myselection_as_array[ij[:,0], ij[:,1]] = np.logical_xor(self._myselection_as_array[ij[:, 0], ij[:, 1]], True)
+                else:
+                    self._myselection_as_array[:,:] = np.logical_xor(self._myselection_as_array, ij)
+            else:
+                if ij.shape[1] == 2:
+                    # using xy from np.where
+                    self._myselection_as_array[ij[:,0], ij[:,1]] = True
                 else:
-                    self.myselection = []
+                    self._myselection_as_array[ij] = True
+
+        elif self._storage_mode == StorageMode.LIST:
+            if ij.shape[1] == 2:
+                # using xy from np.where
+                self._add_nodes_to_selectionij(ij, verif)
             else:
-                self.myselection = np.unique(self.myselection, axis=0)
+                # Convert the numpy array to a list of tuples
+                ij = np.argwhere(ij)
+                self._add_nodes_to_selectionij(ij, verif)
 
     def select_insidepoly(self, myvect: vector):
-        """ Select nodes inside a polygon """
+        """ Select nodes inside a polygon.
 
-        nbini = len(self.myselection)
+        :param myvect: vector defining the polygon
+        """
 
-        myvect.find_minmax()
-        mypoints, _tmpij = self.parent.get_xy_infootprint_vect(myvect)
-        path = mpltPath.Path(myvect.asnparray())
-        inside = path.contains_points(mypoints)
+        nbini = self.nb
 
-        self.hideselection=False
-        if self.parent.myops is not None:
-            if self.parent.myops.selectrestricttomask.IsChecked():
-                self.hideselection=True
+        self.hideselection = self.parent.usemask
 
-        self.add_nodes_to_selection(mypoints[np.where(inside)], verif=nbini != 0)
+        inside = self.parent.get_ij_inside_polygon(myvect, usemask=self.hideselection)
 
-        if self.parent.myops is not None:
-            if len(self.myselection) > 0:
-                if self.parent.myops.selectrestricttomask.IsChecked():
-                    self.condition_select('Mask',0)
+        if inside.shape[0] == 0:
+            logging.info(_('No nodes inside the polygon'))
+            return
+        else:
+            if inside.shape[0] > self.threshold_array_mode:
+                self.force_storage_mode(StorageMode.ARRAY)
+
+            self._add_nodes_to_selectionij(inside, verif= nbini != 0)
 
         self.hideselection=False
-        self.update_nb_nodes_selection()
 
     def select_underpoly(self, myvect: vector):
-        """ Select nodes along a polyline """
+        """ Select nodes along a polyline
+
+        :param myvect: vector defining the polyline
+        """
 
-        nbini = len(self.myselection)
+        nbini = self.nb
 
         myvect.find_minmax()
         mypoints = self.parent.get_ij_under_polyline(myvect)
 
+        if self.parent.usemask:
+            # If the parent uses a mask, we need to check if the points are not masked
+            mypoints = mypoints[~self.parent.array.mask[mypoints[:, 0], mypoints[:, 1]]]
+
         if len(mypoints) == 0:
             logging.info(_('No nodes under the polyline'))
             return
 
-        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_selection()
+        self.add_nodes_to_selection(mypoints, verif = nbini != 0)
 
     def dilate_selection(self, nb_iterations:int, use_mask:bool = True, structure:np.ndarray = None):
-        """ Extend the selection """
+        """ Extend the selection.
+
+        :param nb_iterations: Number of iterations to dilate the selection
+        :param use_mask: If True, use the mask of the parent array to limit the dilation
+        :param structure: Structuring element for dilation, default is a cross shape (nodes directly adjacent in the x or y direction)
+        """
 
-        if self.myselection == 'all':
+        if self.is_all_selected():
             logging.info(_('Cannot extend selection when all nodes are selected'))
             return
 
-        if len(self.myselection) == 0:
+        if self.nb == 0:
             logging.info(_('No nodes selected'))
             return
 
@@ -4331,34 +4884,27 @@ class SelectionData():
 
         from scipy import ndimage
 
-        xy = self.myselection
-        ij = [self.parent.get_ij_from_xy(x, y) for x, y in xy]
-
-        selected = np.zeros(self.parent.array.shape, dtype=bool)
-        for i, j in ij:
-            selected[i, j] = True
-
-        selected = ndimage.binary_dilation(selected,
+        self._myselection_as_array[:,:] = ndimage.binary_dilation(self._myselection_as_array,
                                            iterations=nb_iterations,
                                            mask=~self.parent.array.mask if use_mask else None,
                                            structure=structure)
 
-        ij = np.argwhere(selected)
-        ij = np.vstack([ij[:, 0], ij[:, 1]]).T
-        xy = self.parent.ij2xy_np(ij)
-
-        self.myselection = [(cur[0], cur[1]) for cur in xy]
-
+        self._storage_mode = StorageMode.ARRAY  # Ensure we are in ARRAY mode
         self.update_nb_nodes_selection()
 
     def erode_selection(self, nb_iterations:int, use_mask:bool = True, structure:np.ndarray = None):
-        """ Reduce the selection """
+        """ Reduce the selection.
+
+        :param nb_iterations: Number of iterations to erode the selection
+        :param use_mask: If True, use the mask of the parent array to limit the erosion
+        :param structure: Structuring element for erosion, default is a cross shape (nodes directly adjacent in the x or y direction)
+        """
 
-        if self.myselection == 'all':
+        if self.is_all_selected():
             logging.info(_('Cannot reduce selection when all nodes are selected'))
             return
 
-        if len(self.myselection) == 0:
+        if self.nb == 0:
             logging.info(_('No nodes selected'))
             return
 
@@ -4372,53 +4918,54 @@ class SelectionData():
 
         from scipy import ndimage
 
-        xy = self.myselection
-        ij = [self.parent.get_ij_from_xy(x, y) for x, y in xy]
-
-        selected = np.zeros(self.parent.array.shape, dtype=bool)
-
-        for i, j in ij:
-            selected[i, j] = True
-
-        selected = ndimage.binary_erosion(selected,
+        self._myselection_as_array[:,:] = ndimage.binary_erosion(self._myselection_as_array,
                                             iterations=nb_iterations,
                                             mask=~self.parent.array.mask if use_mask else None,
                                             structure=structure)
 
-        ij = np.argwhere(selected)
-        ij = np.vstack([ij[:, 0], ij[:, 1]]).T
-        xy = self.parent.ij2xy_np(ij)
-
-        self.myselection = [(cur[0], cur[1]) for cur in xy]
-
+        self._storage_mode = StorageMode.ARRAY  # Ensure we are in ARRAY mode
         self.update_nb_nodes_selection()
 
     def dilate_contour_selection(self, nbiter:int= 1, use_mask:bool = True, structure:np.ndarray = np.ones((3,3))):
-        """ Dilate the contour of the selection """
+        """ Dilate the contour of the selection.
+
+        :param nbiter: Number of iterations to dilate the selection
+        :param use_mask: If True, use the mask of the parent array to limit the dilation
+        :param structure: Structuring element for dilation, default is a 3x3 square
+        """
 
         if self.nb > 0:
-            oldsel = self.myselection.copy()
+            oldsel = self._myselection_as_array.copy()
             self.dilate_selection(nbiter, use_mask, structure)
-            newsel = self.myselection.copy()
-            self.myselection = [cur for cur in newsel if cur not in oldsel]
+            # We keep only the new nodes that were not in the old selection
+            self._myselection_as_array[:,:] = np.logical_and(self._myselection_as_array, ~oldsel)
+            self._storage_mode = StorageMode.ARRAY  # Ensure we are in ARRAY mode
             self.update_nb_nodes_selection()
         else:
             logging.info('No selection to expand/dilate')
 
     def erode_contour_selection(self):
-        """ Erode the contour of the selection """
+        """ Erode the contour of the selection.
+
+        :param nbiter: Number of iterations to erode the selection
+        :param use_mask: If True, use the mask of the parent array to limit the erosion
+        :param structure: Structuring element for erosion, default is a 3x3 square
+        """
 
         if self.nb > 0:
-            oldselect = self.myselection.copy()
+            oldselect = self._myselection_as_array.copy()
             self.erode_selection(1)
-            newselect = self.myselection.copy()
-            self.myselection = [cur for cur in oldselect if cur not in newselect]
+            self._myselection_as_array[:,:] = np.logical_and(self._myselection_as_array, oldselect)
+            self._storage_mode = StorageMode.ARRAY  # Ensure we are in ARRAY mode
             self.update_nb_nodes_selection()
         else:
             logging.info('No selection to contract/erode')
 
     def save_selection(self, filename:str=None):
-        """ Save the selection to a file """
+        """ Save the selection to a file.
+
+        :param filename: Name of the file to save the selection to. If None, a dialog will be shown to choose the file.
+        """
 
         if filename is None:
             with wx.FileDialog(None, 'Save selection', wildcard='Text files (*.txt)|*.txt',
@@ -4431,7 +4978,10 @@ class SelectionData():
             f.write(self.get_string(all_memories=True))
 
     def load_selection(self, filename:str=None):
-        """ Load a selection from a file """
+        """ Load a selection from a file.
+
+        :param filename: Name of the file to load the selection from. If None, a dialog will be shown to choose the file.
+        """
 
         if filename is None:
             with wx.FileDialog(None, 'Load selection', wildcard='Text files (*.txt)|*.txt',
@@ -4488,13 +5038,35 @@ class SelectionData():
 
         self.parent.reset_plot()
 
-    def update_nb_nodes_selection(self):
-        """ Update the number of selected nodes """
+    def update_nb_nodes_selection(self, autostoragemode:bool=True) -> tuple[int, float, float, float, float]:
+        """ Update the number of selected nodes.
 
-        if self.myselection=='all':
-            nb = self.parent.nbnotnull
-        else:
-            nb = len(self.myselection)
+        :param autostoragemode: If True, automatically switch to ARRAY mode if the number of selected nodes exceeds the threshold.
+        :return: Tuple containing the number of selected nodes, and the bounds of the selection (xmin, xmax, ymin, ymax).
+        """
+
+        if autostoragemode:
+            self._auto_storage_mode()
+
+        if self._storage_mode == StorageMode.ARRAY:
+            nb = np.count_nonzero(self._myselection_as_array)
+        elif self._storage_mode == StorageMode.LIST:
+            if self.is_all_selected():
+                if self.parent.usemask:
+                    nb = self.parent.nbnotnull
+                else:
+                    nb = self.parent.nbx * self.parent.nby
+            elif isinstance(self._myselection, tuple) and len(self._myselection) == 2 and self._myselection[0] == ALL_SELECTED:
+                # tuple of ('all', np.ndarray) for all nodes and excluded nodes
+
+                if self.parent.usemask:
+                    nb = self.parent.nbnotnull
+                else:
+                    nb = self.parent.nbx * self.parent.nby
+
+                nb -= len(self._myselection[1])
+            else:
+                nb = len(self._myselection)
 
         self.update_plot_selection = True
         if self.wx_exists:
@@ -4515,13 +5087,24 @@ class SelectionData():
                 self.update_plot_selection = True
 
         if nb>0:
-            if self.myselection=='all':
+            if self.is_all_selected():
                 [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])
+                if self._storage_mode == StorageMode.ARRAY:
+                    # Get the bounds of the selection from the boolean array
+                    sel = np.argwhere(self._myselection_as_array)
+                    xmin = np.min(sel[:, 0])
+                    ymin = np.min(sel[:, 1])
+                    xmax = np.max(sel[:, 0])
+                    ymax = np.max(sel[:, 1])
+                    xmin, ymin = self.parent.get_xy_from_ij(xmin, ymin)
+                    xmax, ymax = self.parent.get_xy_from_ij(xmax, ymax)
+
+                elif self._storage_mode == StorageMode.LIST:
+                    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.
@@ -4532,6 +5115,7 @@ class SelectionData():
 
             self.parent.myops.nbselect.SetLabelText(str(nb))
             self.parent.myops.nbselect2.SetLabelText(str(nb))
+
             if nb>0:
 
                 self.parent.myops.minx.SetLabelText('{:.3f}'.format(xmin))
@@ -4541,9 +5125,17 @@ class SelectionData():
 
         return nb, xmin, xmax, ymin, ymax
 
-    def condition_select(self, cond, condval, condval2=0, usemask=False):
+    def condition_select(self, cond:str | int, condval, condval2 = 0, usemask:bool = False):
+        """ Select nodes based on a condition.
+
+        :param cond: condition to apply (0: '<', 1: '<=', 2: '==', 3: '>=', 4: '>', 5: 'NaN', 6: '>=<=', 7: '><', 8: '<>')
+        :param condval: value to compare with
+        :param condval2: second value to compare with (for ranges)
+        :param usemask: whether to use the mask or not
+        """
+
         array = self.parent.array
-        nbini = len(self.myselection)
+        nbini = self.nb
 
         if array.dtype == np.float32:
             condval = np.float32(condval)
@@ -4606,8 +5198,14 @@ class SelectionData():
                     return
             else:
                 try:
-                    sel = np.asarray(self.myselection)
-                    ijall = np.asarray(self.parent.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
+                    if self.nb > self.threshold_array_mode:
+                        # If the selection is large, we use the boolean array
+                        ijall = np.argwhere(self._myselection_as_array)
+                    else:
+                        # Otherwise, we use the selection list
+                        sel = np.asarray(self.myselection)
+                        ijall = self.parent.xy2ij_np(sel)
+
                     if cond == 0 or cond=='<':
                         # <
                         ij = np.argwhere((array[ijall[:, 0], ijall[:, 1]] < condval) & (mask[ijall[:, 0], ijall[:, 1]]))
@@ -4684,8 +5282,11 @@ class SelectionData():
                     return
             else:
                 try:
-                    sel = np.asarray(self.myselection)
-                    ijall = np.asarray(self.parent.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
+                    if self.nb > self.threshold_array_mode:
+                        ijall = np.argwhere(self._myselection_as_array)
+                    else:
+                        sel = np.asarray(self.myselection)
+                        ijall = self.parent.xy2ij_np(sel)
 
                     if cond == 0 or cond=='<':
                         # <
@@ -4727,9 +5328,16 @@ class SelectionData():
                     logging.error(_('Error in condition_select ! -- Please report this bug, specifying the context'))
                     return
 
-        self.update_nb_nodes_selection()
+        # self.update_nb_nodes_selection()
 
-    def treat_select(self, op, cond, opval, condval):
+    def treat_select(self, op:int, cond:int, opval, condval):
+        """ Apply an operation on the selected nodes based on a condition.
+
+        :param op: operation to apply (0: '+', 1: '-', 2: '*', 3: '/', 4: 'replace')
+        :param cond: condition to apply (0: '<', 1: '<=', 2: '==', 3: '>=', 4: '>', 5: 'NaN')
+        :param opval: value to apply the operation with
+        :param condval: value to compare with
+        """
         # operationChoices = [ u"+", u"-", u"*", u"/", u"replace'" ]
         # conditionChoices = [ u"<", u"<=", u"=", u">=", u">",u"isNaN" ]
         def test(val, cond, condval):
@@ -4770,7 +5378,7 @@ class SelectionData():
             logging.error(_('Unknown dtype in treat_select !'))
             return
 
-        if self.myselection == 'all':
+        if self.myselection == ALL_SELECTED:
             if op == 0:
                 if cond == 0:
                     # <
@@ -4933,7 +5541,15 @@ class SelectionData():
 
         self.parent.reset_plot()
 
-    def mask_condition(self, op, cond, opval, condval):
+    def mask_condition(self, op:int, cond:int, opval, condval):
+        """ Mask nodes based on a condition.
+
+        :param op: operation to apply (0: '+', 1: '-', 2: '*', 3: '/', 4: 'replace')
+        :param cond: condition to apply (0: '<', 1: '<=', 2: '==', 3: '>=', 4: '>', 5: 'NaN')
+        :param opval: value to apply the operation with
+        :param condval: value to compare with
+        """
+
         # operationChoices = [ u"+", u"-", u"*", u"/", u"replace'" ]
         # conditionChoices = [ u"<", u"<=", u"=", u">=", u">",u"isNaN" ]
         def test(val, cond, condval):
@@ -4974,7 +5590,7 @@ class SelectionData():
             logging.error(_('Unknown dtype in treat_select !'))
             return
 
-        if self.myselection == 'all':
+        if self.myselection == ALL_SELECTED:
             if cond == 0:
                 # <
                 ind = np.argwhere(np.logical_and(array < condval, np.logical_not(array.mask)))
@@ -4997,35 +5613,42 @@ class SelectionData():
             array.mask[ind[:, 0], ind[:, 1]] = True
 
         else:
-            ij = [self.parent.get_ij_from_xy(cur[0], cur[1]) for cur in self.myselection]
+            npself = np.asarray(self.myselection)
+            ij = self.parent.xy2ij_np(npself)
+            array.mask[ij[:, 0], ij[:, 1]] = test(array.data[ij[:, 0], ij[:, 1]], cond, condval)
+
+            # ij = [self.parent.get_ij_from_xy(cur[0], cur[1]) for cur in self.myselection]
 
-            for i, j in ij:
-                if test(array.data[i, j], cond, condval):
-                    array.mask[i, j] = True
+            # for i, j in ij:
+            #     if test(array.data[i, j], cond, condval):
+            #         array.mask[i, j] = True
 
         self.parent.nbnotnull = array.count()
         self.parent.updatepalette()
         self.parent.delete_lists()
 
-    def get_values_sel(self):
+    def get_values_sel(self) -> np.ndarray:
+        """ Get the values of the selected nodes.
 
-        if self.myselection == 'all':
+        :return: numpy array of values of the selected nodes, or -99999 if all nodes are selected.
+        """
+
+        if self.myselection == ALL_SELECTED:
             return -99999
         else:
             sel = np.asarray(self.myselection)
             if len(sel) == 1:
-                ijall = np.asarray(self.parent.get_ij_from_xy(sel[0, 0], sel[0, 1])).transpose()
+                ijall = self.parent.xy2ij_np(sel)
                 z = self.parent.array[ijall[0], ijall[1]]
             else:
-                ijall = np.asarray(self.parent.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
+                ijall = self.parent.xy2ij_np(sel)
                 z = self.parent.array[ijall[:, 0], ijall[:, 1]].flatten()
 
         return z
 
-    def _get_header(self):
+    def _get_header(self) -> header_wolf | None:
         """ Header corresponding to the selection """
 
-        array = self.parent
         sel = np.asarray(self.myselection)
 
         myhead = header_wolf()
@@ -5050,13 +5673,17 @@ class SelectionData():
 
         return myhead
 
-    def get_newarray(self):
-        """ Create a new array from the selection """
+    def get_newarray(self) -> "WolfArray":
+        """ Create a new array from the selection.
+
+        :return: a new WolfArray object containing the selected nodes, or None if the selection is empty. Null values are set to -99999.
+        If all nodes are selected, returns a WolfArray molded from the parent.
+        """
 
         if self.nb == 0:
             return None
 
-        if self.myselection == 'all':
+        if self.myselection == ALL_SELECTED:
             return WolfArray(mold=self.parent)
 
         newarray = WolfArray()
@@ -5069,10 +5696,12 @@ class SelectionData():
 
         sel = np.asarray(self.myselection)
         if len(sel) == 1:
-            ijall = np.asarray(self.parent.get_ij_from_xy(sel[0, 0], sel[0, 1])).transpose()
+            # ijall = np.asarray(self.parent.get_ij_from_xy(sel[0, 0], sel[0, 1])).transpose()
+            ijall = self.parent.xy2ij_np(sel)
             z = self.parent.array[ijall[0], ijall[1]]
         else:
             ijall = np.asarray(self.parent.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
+            ijall = self.parent.xy2ij_np(sel)
             z = self.parent.array[ijall[:, 0], ijall[:, 1]].flatten()
 
         newarray.array[:, :] = -99999.
@@ -5083,10 +5712,12 @@ class SelectionData():
         return newarray
 
     def select_all(self):
-        """ Select all nodes """
+        """ Select all nodes.
 
-        self.myselection = 'all'
-        self.update_nb_nodes_selection()
+        It will set the selection to ALL_SELECTED, which is a special value indicating that all nodes are selected.
+        """
+
+        self.myselection = ALL_SELECTED
 
     def interp2Dpolygons(self, working_zone:zone,
                          method:Literal["nearest", "linear", "cubic"] = None,
@@ -5095,6 +5726,10 @@ class SelectionData():
         """
         Interpolation sous tous les polygones d'une zone
         cf parent.interp2Dpolygon
+
+        Useful for WX GUI, where the method is chosen by the user.
+        From script, you can call this method directly from the parent array
+        with the desired method and keep parameters.
         """
 
         if method is None:
@@ -5120,6 +5755,10 @@ class SelectionData():
         """
         Interpolation sous un polygone
         cf parent.interp2Dpolygon
+
+        Useful for WX GUI, where the method is chosen by the user.
+        From script, you can call this method directly from the parent array
+        with the desired method and keep parameters.
         """
 
         if method is None:
@@ -5142,6 +5781,10 @@ class SelectionData():
         """
         Interpolation sous toutes les polylignes de la zone
         cf parent.interp2Dpolyline
+
+        Useful for WX GUI, where the method is chosen by the user.
+        From script, you can call this method directly from the parent array
+        with the desired method and keep parameters.
         """
 
         self.parent.interpolate_on_polylines(working_zone)
@@ -5153,6 +5796,10 @@ class SelectionData():
         """
         Interpolation sous la polyligne active
         cf parent.interp2Dpolyline
+
+        Useful for WX GUI, where the method is chosen by the user.
+        From script, you can call this method directly from the parent array
+        with the desired method and keep parameters.
         """
 
         self.parent.interpolate_on_polyline(working_vector)
@@ -5160,14 +5807,31 @@ class SelectionData():
         if resetplot:
             self.parent.reset_plot()
 
-
     def copy(self, source:"SelectionData"):
+        """ Copy the selection data from another SelectionData object.
+
+        :param source: another SelectionData object to copy from.
+        """
+
+        if source._storage_mode == StorageMode.ARRAY:
+            self._storage_mode = StorageMode.ARRAY
+            self._myselection_as_array = source._myselection_as_array.copy()
 
-        self.myselection = source.myselection.copy()
+        elif source._storage_mode == StorageMode.LIST:
+            self._storage_mode = StorageMode.LIST
+            self._myselection = source._myselection.copy()
 
     def volumesurface(self, show=True):
         """
-        Evaluation of stage-storage-surface relation
+        Evaluation of stage-storage-surface relation from "volume_estimation" routine of the WolfArray.
+
+        If the selection is empty, it will use the whole array.
+        If the selection is ALL_SELECTED, it will use the whole array.
+        If the selection is not empty, it will use the selected nodes only -- see "get_newarray" routine.
+
+        If the parent array is linked to a MapViewer, it will apply the same operation to all linked active arrays.
+
+        :param show: if True, the figure will be shown.
         """
 
         if self.parent.get_mapviewer() is not None:
@@ -5176,38 +5840,36 @@ class SelectionData():
 
             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
-                    fig, axs = myarray.volume_estimation()
-
-                    myarray = array2
-                    fig, axs = myarray.volume_estimation(axs)
+                # If linked arrays, we copy the selection data to all linked arrays
+                arrays = [cur.active_array for cur in mapviewer.linkedList]
+                for cur in arrays:
+                    if cur is not self.parent:
+                        cur.SelectionData.copy(self.parent.SelectionData)
+
+                if self.nb == 0 or self.myselection == ALL_SELECTED:
+                    for cur in arrays:
+                        fig, axs = cur.volume_estimation()
+                        if show:
+                            fig.show()
                 else:
-                    myarray = array1.mngselection.get_newarray()
-                    fig, axs = myarray.volume_estimation()
-
-                    myarray = array2.mngselection.get_newarray()
-                    fig, axs = myarray.volume_estimation(axs)
+                    for cur in arrays:
+                        myarray = cur.SelectionData.get_newarray()
+                        fig, axs = myarray.volume_estimation()
+                        if show:
+                            fig.show()
             else:
-                if len(self.parent.mngselection.myselection) == 0 or self.parent.mngselection.myselection == 'all':
+                if len(self.parent.SelectionData.myselection) == 0 or self.parent.SelectionData.myselection == ALL_SELECTED:
                     myarray = self.parent
                 else:
-                    myarray = self.parent.mngselection.get_newarray()
-                    myarray.SelectionData.selections = self.parent.mngselection.selections.copy()
+                    myarray = self.parent.SelectionData.get_newarray()
+                    myarray.SelectionData.selections = self.parent.SelectionData.selections.copy()
 
                 fig, axs = myarray.volume_estimation()
+
+                if show:
+                    fig.show()
         else:
-            if self.nb == 0 or self.myselection == 'all':
+            if self.nb == 0 or self.myselection == ALL_SELECTED:
                 myarray = self.parent
             else:
                 myarray = self.get_newarray()
@@ -5215,11 +5877,16 @@ class SelectionData():
 
             fig, axs = myarray.volume_estimation()
 
-        if show:
-            fig.show()
+            if show:
+                fig.show()
 
 class SelectionDataMB(SelectionData):
-    """ Extension of SelectionData to manage multiple blocks """
+    """ Extension of SelectionData to manage multiple blocks.
+
+    All routines are not implemented yet, as they depend on the specificities of the blocks.
+
+    For the rest, it is mainly a simple wrapper around the SelectionData of each block.
+    """
 
     def __init__(self, parent:"WolfArrayMB"):
         SelectionData.__init__(self, parent)
@@ -5231,10 +5898,10 @@ class SelectionDataMB(SelectionData):
 
         return np.sum([cur.SelectionData.nb for cur in self.parent.active_blocks])
 
-    def Unmasksel(self):
+    def unmask_selection(self):
 
         for curblock in self.parent.active_blocks:
-            curblock.SelectionData.Unmasksel(resetplot=False)
+            curblock.SelectionData.unmask_selection(resetplot=False)
 
         self.parent.reset_plot()
 
@@ -5280,7 +5947,7 @@ class SelectionDataMB(SelectionData):
         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):
+    def add_nodes_to_selection(self, xy:list[float] | np.ndarray, verif:bool=True):
         """ Add nodes to the selection """
 
         for curblock in self.parent.active_blocks:
@@ -5686,6 +6353,14 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
+    @property
+    def usemask(self):
+        """ Check if we want to use the mask in the operations """
+        if self.myops is not None:
+            return self.myops.usemask
+        else:
+            return False
+
     def __getstate__(self):
         """ Récupération de l'état de l'objet pour la sérialisation """
         state = self.__dict__.copy()
@@ -5800,8 +6475,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         """ Get the centers of the cells """
 
         if usenap:
-            ij = np.where(self.array.mask==False,)
-            xy = self.get_xy_from_ij_array(np.vstack((ij[0], ij[1])).T).copy().flatten()
+            ij = np.argwhere(self.array.mask==False,)
+            xy = self.get_xy_from_ij_array(ij).copy().flatten()
         else:
             ij = np.meshgrid(np.arange(self.nbx), np.arange(self.nby))
             ij = np.asarray([ij[0].flatten(), ij[1].flatten()]).T
@@ -6182,7 +6857,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             logging.info(_('No selection -- no filtering'))
             return
 
-        if self.SelectionData.myselection == 'all':
+        if self.SelectionData.myselection == ALL_SELECTED:
             logging.info(_('All nodes selected -- no filtering'))
             return
 
@@ -6282,7 +6957,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
             vals = self.array[ij[:,0], ij[:,1]]
 
-        elif self.SelectionData.nb == 0 or self.SelectionData.myselection == 'all':
+        elif self.SelectionData.nb == 0 or self.SelectionData.myselection == ALL_SELECTED:
             logging.info(_('No selection -- statistics on the whole array'))
             vals = self.array[~self.array.mask].ravel().data	# all values
 
@@ -7150,7 +7825,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
         """
 
-        if self.mngselection.myselection == [] or self.mngselection.myselection == 'all':
+        if self.mngselection.myselection == [] or self.mngselection.myselection == ALL_SELECTED:
 
             decalx = self.origx + self.translx
             decaly = self.origy + self.transly
@@ -7210,7 +7885,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
             try:
                 if self.mngselection is not None:
-                    if self.mngselection.myselection != [] and self.mngselection.myselection != 'all':
+                    if self.mngselection.myselection != [] and self.mngselection.myselection != ALL_SELECTED:
                         # interpolation only in the selected cells
 
                         # Convert coordinates to indices
@@ -7268,7 +7943,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                             self.array.data[ij[:, 0], ij[:, 1]] = newvalues
 
-                    elif self.mngselection.myselection == 'all' and (grid_x is None and grid_y is None):
+                    elif self.mngselection.myselection == ALL_SELECTED and (grid_x is None and grid_y is None):
                         # interpolation in all the cells
 
                         # Creating a grid for all cells
@@ -7918,6 +8593,248 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return fig, axs
 
+    def surface_volume_estimation_from_elevation(self, axs:plt.Axes= None,
+                           desired_zmin:float = None, desired_zmax:float = None,
+                           nb:int = 100,
+                           method:Literal['all below', 'largest area', 'selected'] = 'largest area',
+                           selected_cells:list[tuple[float, float]] = None,
+                           dirout:str | Path = None,
+                           invert_z:bool = False,
+                           array_to_integrate:"WolfArray" = None
+                           ):
+        """ Estimation of the surface and volume from an elevation array.
+
+        :param axs: Axes to plot the results
+        :param desired_zmin: Minimum elevation to consider
+        :param desired_zmax: Maximum elevation to consider
+        :param nb: Number of elevation steps
+        :param method: Method to use for the estimation ('all below', 'largest area', 'selected')
+        :param selected_cells: List of kernel cells (if method is 'selected') -- Consider only the areas containing these cells
+        :param dirout: Directory to save the results
+        :return: Figure and Axes with the results
+        :rtype: tuple[plt.Figure, plt.Axes]
+        """
+
+        assert method in ['all below', 'largest area', 'selected'], _('Method must be one of "all below", "largest area", or "selected"')
+        if array_to_integrate is not None:
+            assert isinstance(array_to_integrate, WolfArray), _('array_to_integrate must be a WolfArray instance')
+            assert array_to_integrate.nbx == self.nbx and array_to_integrate.nby == self.nby, _('array_to_integrate must have the same dimensions as the current WolfArray')
+
+        vect = self.array[np.logical_not(self.array.mask)].flatten()
+        zmin = np.amin(vect)
+        zmax = np.amax(vect)
+
+        if desired_zmin is not None:
+            zmin = desired_zmin
+
+        if desired_zmax is not None:
+            zmax = desired_zmax
+
+        deltaz = (zmax - zmin) / nb
+
+        curz = zmin
+        labeled_areas = []
+        stockage = []
+        z = []
+
+        if method == 'all below':
+            labeled = False
+        else:
+            labeled = True
+            if method == 'largest area':
+                use_memory = False
+            else:
+                xy_key = np.asarray(selected_cells, dtype=np.float64)
+                if xy_key is None:
+                    logging.error(_('Empty selection'))
+                    return
+
+                if len(xy_key) == 0:
+                    logging.error(_('Empty selection'))
+                    return
+
+                ij_key = self.xy2ij_np(xy_key)
+
+                use_memory = True
+
+        extensionmax = WolfArray(mold=self)
+        extensionmax.array[:, :] = 0.
+
+        if labeled:
+            for i in tqdm(range(nb + 1)):
+                z.append(curz)
+
+                # Compute difference between the array and the current elevation
+                if i == 0:
+                    diff = self.array - (curz + 1.e-3)
+                else:
+                    diff = self.array - curz
+
+                # Keep only the negative values
+                diff[diff > 0] = 0.
+                diff.data[diff.mask] = 0.
+
+                if np.count_nonzero(diff < 0.) > 1:
+                    # More than one cell below the elevation
+
+                    # Labeling of the cells below the elevation
+                    labeled_array, num_features = label(diff.data)
+                    # Applying the same mask as the original array
+                    labeled_array = ma.asarray(labeled_array)
+                    labeled_array.mask = self.array.mask
+
+                    if use_memory:
+                        # Use only the labeled areas containing the cells stored in selected_cells
+                        labeled_areas = []
+                        for curij in ij_key:
+                            labeled_areas.append(labeled_array[curij[0], curij[1]])
+
+                        # Remove masked value
+                        labeled_areas = [x for x in labeled_areas if x is not ma.masked]
+                        # Remove duplicates
+                        labeled_areas = list(set(labeled_areas))
+
+                        for curarea in labeled_areas:
+                            if curarea == 0:
+                                volume = 0.
+                                surface = 0.
+                                continue
+
+                            # Search
+                            mask = labeled_array == curarea
+                            area = np.argwhere(mask)
+
+                            if array_to_integrate is None:
+                                volume = -self.dx * self.dy * np.ma.sum(diff[area])
+                            else:
+                                volume = self.dx * self.dy * np.ma.sum(array_to_integrate.array[area[:,0], area[:,1]])
+
+                            surface = self.dx * self.dy * area.shape[0]
+                            extensionmax.array[np.logical_and(mask, extensionmax.array == 0.)] = float(i + 1)
+
+                    else:
+                        labeled_areas = list(sum_labels(np.ones(labeled_array.shape, dtype=np.int32), labeled_array, range(1, num_features+1)))
+                        labeled_areas = [[x, y] for x, y in zip(labeled_areas, range(1, num_features+1))]
+                        labeled_areas.sort(key=lambda x: x[0], reverse=True)
+                        jmax = labeled_areas[0][1]
+                        nbmax = labeled_areas[0][0]
+
+                        if array_to_integrate is None:
+                            volume = -self.dx * self.dy * np.ma.sum(diff[labeled_array == jmax])
+                        else:
+                            volume = self.dx * self.dy * np.ma.sum(array_to_integrate.array[labeled_array == jmax])
+
+                        surface = self.dx * self.dy * nbmax
+                        extensionmax.array[np.logical_and(labeled_array == jmax, extensionmax.array == 0.)] = float(i + 1)
+                else:
+                    # Only one cell below the elevation
+                    if array_to_integrate is None:
+                        volume = -self.dx * self.dy * np.ma.sum(diff)
+                    else:
+                        volume = self.dx * self.dy * np.ma.sum(array_to_integrate.array[diff < 0.])
+
+                    surface = self.dx * self.dy * np.count_nonzero(diff<0.)
+                    extensionmax.array[np.logical_and(diff[:,:]<0., extensionmax.array[:, :] == 0.)] = float(i + 1)
+
+                stockage.append([abs(volume), abs(surface)])
+                curz += deltaz
+
+        else:
+            for i in tqdm(range(nb + 1)):
+                z.append(curz)
+
+                if i == 0:
+                    diff = self.array - (curz + 1.e-3)
+                else:
+                    diff = self.array - curz
+
+                diff[diff > 0] = 0.
+                diff.data[diff.mask] = 0.
+
+                if array_to_integrate is None:
+                    volume  = -self.dx * self.dy * np.ma.sum(diff)
+                    surface = self.dx * self.dy * np.count_nonzero(diff<0.)
+                    stockage.append([abs(volume), abs(surface)])
+                else:
+                    ij = np.argwhere(diff < 0.)
+                    volume  = self.dx * self.dy * np.ma.sum(array_to_integrate.array[ij[:,0], ij[:,1]])
+                    surface = self.dx * self.dy * ij.shape[0]
+                    stockage.append([volume, abs(surface)])
+
+                curz += deltaz
+
+                extensionmax.array[np.logical_and(diff[:,:]<0., extensionmax.array[:, :] == 0.)] = float(i + 1)
+
+        if dirout is None:
+            dirout = Path(self.filename).parent / 'surface_volume'
+
+        if isinstance(dirout, str):
+            dirout = Path(dirout)
+        if not dirout.exists():
+            dirout.mkdir(parents=True, exist_ok=True)
+
+        extensionmax.filename = str(dirout / 'surface_volume_extension.tif')
+        extensionmax.write_all()
+
+        if axs is None:
+            fig, axs = plt.subplots(1, 2, tight_layout=True)
+        else:
+            fig = axs[0].get_figure()
+
+        if invert_z:
+            z = [abs(zmin - x) for x in z]
+            labelx = _("Water depth [m]")
+        else:
+            labelx = _("Elevation [m]")
+
+        axs[0].plot(z, [x[0] for x in stockage])
+        axs[0].scatter(z, [x[0] for x in stockage])
+        axs[0].set_xlabel(labelx, size=10)
+        axs[0].set_ylabel(_("Volume [$m^3$]"), size=10)
+        axs[1].step(z, [x[1] for x in stockage], where='post')
+        axs[1].scatter(z, [x[1] for x in stockage])
+        axs[1].set_xlabel(labelx, size=10)
+        axs[1].set_ylabel(_("Surface [$m^2$]"), size=10)
+        fig.suptitle(_("Retention capacity"), fontsize=12)
+
+        fig.savefig(dirout / 'surface_volume.png', dpi=300)
+
+        fn = dirout / 'surface_volume_hvs.txt'
+        with open(fn, 'w') as f:
+            f.write('H [m]\tZ [m DNG]\tVolume [$m^3$]\tSurface [$m^2$]\n')
+            for curz, (curv, curs) in zip(z, stockage):
+                f.write('{}\t{}\t{}\t{}\n'.format(curz - zmin, curz, curv, curs))
+
+        return fig, axs
+
+    def surface_volume_estimation_from_waterdepth(self, axs:plt.Axes=None,
+                                                  desired_zmin:float = None, desired_zmax:float = None,
+                                                  nb:int = 100,
+                                                  method:Literal['all below', 'largest area', 'selected'] = 'largest',
+                                                  selected_cells:list[tuple[float, float]] = None,
+                                                  dirout:str | Path = None):
+        """ Estimation of the surface and volume from a water depth array.
+        :param axs: Axes to plot the results
+        :param desired_zmin: Minimum water depth to consider
+        :param desired_zmax: Maximum water depth to consider
+        :param nb: Number of water depth steps
+        :param method: Method to use for the estimation ('all below', 'largest area', 'selected')
+        :param selected_cells: List of kernel cells (if method is 'selected') -- Consider only the areas containing these cells
+        :param dirout: Directory to save the results
+        :return: Figure and Axes with the results
+        :rtype: tuple[plt.Figure, plt.Axes]
+        """
+
+        neg_array = WolfArray(mold=self)
+        neg_array.array[:,:] = -self.array
+        return neg_array.surface_volume_estimation_from_elevation(desired_zmin=-desired_zmax if desired_zmax is not None else None,
+                                                                  desired_zmax=-desired_zmin if desired_zmin is not None else None,
+                                                                  nb=nb, method=method,
+                                                                  selected_cells=selected_cells,
+                                                                  dirout=dirout if dirout is not None else Path(self.filename).parent / 'surface_volume',
+                                                                  axs=axs, invert_z=True)
+
+
     def paste_all(self, fromarray:"WolfArray", mask_after:bool=True):
         """ Paste all the values from another WolfArray """
 
@@ -7972,14 +8889,17 @@ class WolfArray(Element_To_Draw, header_wolf):
         z   = np.asarray(z)
 
         if len(sel) == 1:
-            ijall = np.asarray(self.get_ij_from_xy(sel[0, 0], sel[0, 1])).transpose()
-            i = ijall[0]
-            j = ijall[1]
+            ijall = self.xy2ij_np(sel)
 
-            if i > 0 and i < self.nbx and j > 0 and j < self.nby:
+            i, j = ijall[0, 0], ijall[0, 1]
+            if i < 0 or i >= self.nbx or j < 0 or j >= self.nby:
+                logging.error(_('Selected point is out of bounds'))
+                return
+            else:
                 self.array[i, j] = z
         else:
-            ijall = np.asarray(self.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
+            # ijall = np.asarray(self.get_ij_from_xy(sel[:, 0], sel[:, 1])).transpose()
+            ijall = self.xy2ij_np(sel)
 
             useful = np.where((ijall[:, 0] >= 0) & (ijall[:, 0] < self.nbx) & (ijall[:, 1] >= 0) & (ijall[:, 1] < self.nby))
 
@@ -8056,7 +8976,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                     ij = [self.get_ij_from_xy(cur[0], cur[1]) for cur in curlist]
                     z = [self.array.data[curij[0], curij[1]] for curij in ij]
 
-                    if cursel == 'all':
+                    if cursel == ALL_SELECTED:
                         xall = np.linspace(self.origx + self.dx / 2., self.origx + (float(self.nbx) - .5) * self.dx,
                                         self.nbx)
                         yall = np.linspace(self.origy + self.dy / 2., self.origy + (float(self.nby) - .5) * self.dy,
@@ -8549,12 +9469,16 @@ class WolfArray(Element_To_Draw, header_wolf):
         # trouve les indices dans le polygone
         for myvect in myvects:
             myij = self.get_ij_inside_polygon(myvect, usemask=False, eps=eps, method=method)
-            # masquage des mailles contenues
-            self.array.mask[myij[:,0],myij[:,1]] = True
 
-            if set_nullvalue:
-                # annulation des valeurs en dehors du polygone
-                self.array.data[myij[:,0],myij[:,1]] = self.nullvalue
+            if myij.shape[0] == 0:
+                logging.warning(_("No indices found in the polygon {}").format(myvect.myname))
+            else:
+                # masquage des mailles contenues
+                self.array.mask[myij[:,0],myij[:,1]] = True
+
+                if set_nullvalue:
+                    # annulation des valeurs en dehors du polygone
+                    self.array.data[myij[:,0],myij[:,1]] = self.nullvalue
 
         self.count()
 
@@ -9242,6 +10166,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         if newpath is not None:
             self.filename = newpath
 
+        self.filename = str(self.filename)
+
         if self.filename.endswith('.tif') or self.filename.endswith('.tiff'):
             self.export_geotif(EPSG=EPSG)
         elif self.filename.endswith('.npy'):
@@ -11830,6 +12756,8 @@ class WolfArrayMB(WolfArray):
         """
         Adds a properly configured block this multiblock.
 
+        Do not forget to call "set_header_from_added_blocks" after adding all blocks.
+
         :param arr: The block to add.
         :param force_idx: If True, the index/key will be set on `arr`. If False, the index/key must already be set on `arr`.
         """