wolfhece 2.2.17__py3-none-any.whl → 2.2.20__py3-none-any.whl

wolfhece/wolf_array.py

@@ -2097,7 +2097,19 @@ class Ops_Array(wx.Frame):
 
         self.labelling = wx.Button(self.tools, wx.ID_ANY, _("Labelling"), wx.DefaultPosition,wx.DefaultSize, 0)
 
+        stats_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        stats_sizer2 = wx.BoxSizer(wx.HORIZONTAL)
+
         self.statistics = wx.Button(self.tools, wx.ID_ANY, _("Statistics"), wx.DefaultPosition,wx.DefaultSize, 0)
+        self.plot_stats = wx.Button(self.tools, wx.ID_ANY, _("Plot statistics\nCurrent zoom"), wx.DefaultPosition,wx.DefaultSize, 0)
+        self.plot_stats_zone = wx.Button(self.tools, wx.ID_ANY, _("Plot statistics\nCurrent zone"), wx.DefaultPosition,wx.DefaultSize, 0)
+        self.plot_stats_vector = wx.Button(self.tools, wx.ID_ANY, _("Plot statistics\nCurrent vector"), wx.DefaultPosition,wx.DefaultSize, 0)
+
+        stats_sizer.Add(self.statistics, 1, wx.EXPAND)
+        stats_sizer.Add(self.plot_stats, 1, wx.EXPAND)
+
+        stats_sizer2.Add(self.plot_stats_zone, 1, wx.EXPAND)
+        stats_sizer2.Add(self.plot_stats_vector, 1, wx.EXPAND)
 
         self.clean = wx.Button(self.tools, wx.ID_ANY, _("Clean"), wx.DefaultPosition,wx.DefaultSize, 0)
 
@@ -2117,7 +2129,8 @@ class Ops_Array(wx.Frame):
         Toolssizer.Add(self.labelling, 1, wx.EXPAND)
         Toolssizer.Add(self.clean, 1, wx.EXPAND)
         Toolssizer.Add(self.extract_selection, 1, wx.EXPAND)
-        Toolssizer.Add(self.statistics, 1, wx.EXPAND)
+        Toolssizer.Add(stats_sizer, 1, wx.EXPAND)
+        Toolssizer.Add(stats_sizer2, 1, wx.EXPAND)
         Toolssizer.Add(cont_sizer, 1, wx.EXPAND)
 
         self.ApplyTools.SetToolTip(_("Apply Nullvalue into memory/object"))
@@ -2127,6 +2140,7 @@ class Ops_Array(wx.Frame):
         self.clean.SetToolTip(_("Clean the array\n\nRemove small isolated patches of data"))
         self.extract_selection.SetToolTip(_("Extract the current selection"))
         self.statistics.SetToolTip(_("Compute statistics on the array\n\nResults are displayed in a dialog box"))
+        self.plot_stats.SetToolTip(_("Plot statistics on the array\n\nResults are displayed in a separate figure"))
 
         self.tools.SetSizer(Toolssizer)
         self.tools.Layout()
@@ -2500,6 +2514,9 @@ class Ops_Array(wx.Frame):
         self.clean.Bind(wx.EVT_BUTTON, self.OnClean)
         self.labelling.Bind(wx.EVT_BUTTON, self.OnLabelling)
         self.statistics.Bind(wx.EVT_BUTTON, self.OnStatistics)
+        self.plot_stats.Bind(wx.EVT_BUTTON, self.OnPlotStatistics)
+        self.plot_stats_zone.Bind(wx.EVT_BUTTON, self.OnPlotStatisticsZone)
+        self.plot_stats_vector.Bind(wx.EVT_BUTTON, self.OnPlotStatisticsVector)
         self.extract_selection.Bind(wx.EVT_BUTTON, self.OnExtractSelection)
         self._contour_int.Bind(wx.EVT_BUTTON, self.OnContourInt)
         self._contour_list.Bind(wx.EVT_BUTTON, self.OnContourList)
@@ -3008,6 +3025,86 @@ class Ops_Array(wx.Frame):
 
         ret_frame.Show()
 
+    def OnPlotStatistics(self, event:wx.MouseEvent):
+        """ Plot statistics on the current zoom"""
+
+        from .analyze_poly import Array_analysis_onepolygon
+
+        logging.info(_('Plotting statistics on the current zoom'))
+        if self.parentarray.nbnotnull > 50_000:
+            logging.info(_('Quite large array - please wait a bit...'))
+
+        analyzer = Array_analysis_onepolygon(self.parentarray, self.mapviewer.get_bounds_as_polygon())
+
+        try:
+            analyzer.plot_values(engine = 'plotly')
+        except:
+            logging.error(_('Error in plotly engine - Try seaborn engine'))
+            logging.info(_('If you have not installed plotly, please install it with "pip install plotly"'))
+            try:
+                analyzer.plot_values(engine = 'seaborn')
+            except:
+                logging.error('Error in seaborn engine')
+
+        logging.info(_('Done !'))
+
+    def OnPlotStatisticsZone(self, event:wx.MouseEvent):
+        """ Plot statistics on the current zone """
+
+        if self.mapviewer is not None:
+            if self.mapviewer.active_zone is not None:
+                from .analyze_poly import Array_analysis_polygons
+
+                logging.info(_('Plotting statistics on the current zone'))
+
+                analyzer = Array_analysis_polygons(self.parentarray, self.mapviewer.active_zone)
+                try:
+                    analyzer.plot_values(engine = 'plotly')
+                except:
+                    logging.error(_('Error in plotly engine - Try seaborn engine'))
+                    logging.info(_('If you have not installed plotly, please install it with "pip install plotly"'))
+                    try:
+                        analyzer.plot_values(engine = 'seaborn')
+                    except:
+                        logging.error('Error in seaborn engine')
+
+                logging.info(_('Done !'))
+
+            else:
+                logging.error(_('No active zone to plot statistics'))
+                logging.info(_('Please select a zone to plot statistics'))
+        else:
+            logging.error(_('No active mapviewer to plot statistics'))
+
+    def OnPlotStatisticsVector(self, event:wx.MouseEvent):
+        """ Plot statistics on the current vector """
+
+        if self.mapviewer is not None:
+            if self.mapviewer.active_vector is not None:
+                from .analyze_poly import Array_analysis_onepolygon
+
+                logging.info(_('Plotting statistics on the current vector'))
+
+                # Get the active vector
+                analyzer = Array_analysis_onepolygon(self.parentarray, self.mapviewer.active_vector)
+                try:
+                    analyzer.plot_values(engine = 'plotly')
+                except:
+                    logging.error(_('Error in plotly engine - Try seaborn engine'))
+                    logging.info(_('If you have not installed plotly, please install it with "pip install plotly"'))
+                    try:
+                        analyzer.plot_values(engine = 'seaborn')
+                    except:
+                        logging.error('Error in seaborn engine')
+
+                logging.info(_('Done !'))
+
+            else:
+                logging.error(_('No active vector to plot statistics'))
+                logging.info(_('Please select a vector to plot statistics'))
+        else:
+            logging.error(_('No active mapviewer to plot statistics'))
+
     def OnExtractSelection(self, event:wx.MouseEvent):
         """ Extract the current selection """
 
@@ -4953,7 +5050,10 @@ class SelectionData():
         self.myselection = 'all'
         self.update_nb_nodes_selection()
 
-    def interp2Dpolygons(self, working_zone:zone, method:Literal["nearest", "linear", "cubic"] = None, resetplot:bool = True):
+    def interp2Dpolygons(self, working_zone:zone,
+                         method:Literal["nearest", "linear", "cubic"] = None,
+                         resetplot:bool = True,
+                         keep:Literal['all', 'below', 'above'] = 'all'):
         """
         Interpolation sous tous les polygones d'une zone
         cf parent.interp2Dpolygon
@@ -4970,12 +5070,15 @@ class SelectionData():
             method = dlg.GetStringSelection()
             dlg.Destroy()
 
-        self.parent.interpolate_on_polygons(working_zone, method)
+        self.parent.interpolate_on_polygons(working_zone, method, keep)
 
         if resetplot:
             self.parent.reset_plot()
 
-    def interp2Dpolygon(self, working_vector:vector, method:Literal["nearest", "linear", "cubic"] = None, resetplot:bool = True):
+    def interp2Dpolygon(self, working_vector:vector,
+                        method:Literal["nearest", "linear", "cubic"] = None,
+                        resetplot:bool = True,
+                        keep:Literal['all', 'below', 'above'] = 'all'):
         """
         Interpolation sous un polygone
         cf parent.interp2Dpolygon
@@ -4992,7 +5095,7 @@ class SelectionData():
             method = dlg.GetStringSelection()
             dlg.Destroy()
 
-        self.parent.interpolate_on_polygon(working_vector, method)
+        self.parent.interpolate_on_polygon(working_vector, method, keep)
 
         if resetplot:
             self.parent.reset_plot()
@@ -5232,7 +5335,10 @@ class SelectionDataMB(SelectionData):
 
         logging.error(_('Not yet implemented for Multi-Blocks'))
 
-    def interp2Dpolygons(self, working_zone:zone, method:Literal["nearest", "linear", "cubic"] = None):
+    def interp2Dpolygons(self, working_zone:zone,
+                         method:Literal["nearest", "linear", "cubic"] = None,
+                         resetplot:bool = True,
+                         keep:Literal['all', 'below', 'above'] = 'all'):
         """
         Interpolation sous tous les polygones d'une zone
         cf parent.interp2Dpolygon
@@ -5249,11 +5355,15 @@ class SelectionDataMB(SelectionData):
             method = dlg.GetStringSelection()
             dlg.Destroy()
 
-        self.parent.interpolate_on_polygons(working_zone, method)
+        self.parent.interpolate_on_polygons(working_zone, method, keep)
 
-        self.parent.reset_plot()
+        if resetplot:
+            self.parent.reset_plot()
 
-    def interp2Dpolygon(self, working_vector:vector, method:Literal["nearest", "linear", "cubic"] = None):
+    def interp2Dpolygon(self, working_vector:vector,
+                        method:Literal["nearest", "linear", "cubic"] = None,
+                        resetplot:bool = True,
+                        keep:Literal['all', 'below', 'above'] = 'all'):
         """
         Interpolation sous un polygone
         cf parent.interp2Dpolygon
@@ -5270,9 +5380,10 @@ class SelectionDataMB(SelectionData):
             method = dlg.GetStringSelection()
             dlg.Destroy()
 
-        self.parent.interpolate_on_polygon(working_vector, method)
+        self.parent.interpolate_on_polygon(working_vector, method, keep)
 
-        self.parent.reset_plot()
+        if resetplot:
+            self.parent.reset_plot()
 
     def interp2Dpolylines(self, working_zone:zone, resetplot:bool = True):
         """
@@ -5529,6 +5640,24 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
+    def __getstate__(self):
+        """ Récupération de l'état de l'objet pour la sérialisation """
+        state = self.__dict__.copy()
+
+        # Remove the OpenGL reference to avoid bad references
+        if 'mygrid' in state:
+            state['mygrid'] = {}
+            """ If not empty, the OpenGL list is not properly serialized.
+            During "delete_lists" routine, tghe OpenGL can produce an error.
+            """
+        if 'shaded' in state:
+            state['shaded'] = None  # Avoid serializing the shaded WolfArray
+        return state
+
+    def __setstate__(self, state):
+        """ Récupération de l'état de l'objet pour la désérialisation """
+        self.__dict__.update(state)
+
     def set_opacity(self, alpha:float):
         """ Set the transparency of the array """
 
@@ -6124,17 +6253,17 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if inside_polygon is not None:
             ij = self.get_ij_inside_polygon(inside_polygon)
-            vals = self.array[ij]
+            vals = self.array[ij[:,0], ij[:,1]]
         elif self.SelectionData.nb == 0 or self.SelectionData.myselection == 'all':
             logging.info(_('No selection -- statistics on the whole array'))
-            vals = self.array[~self.array.mask]	# all values
+            vals = self.array[~self.array.mask].ravel().data	# all values
         else:
             vals = self.SelectionData.get_values_sel()
 
-        mean = np.mean(vals)
-        std = np.std(vals)
-        median = np.median(vals)
-        sum = np.sum(vals)
+        mean = np.ma.mean(vals)
+        std = np.ma.std(vals)
+        median = np.ma.median(vals)
+        sum = np.ma.sum(vals)
         vol = sum * self.dx * self.dy
 
         return {_('Mean'): mean, _('Std'): std, _('Median'): median, _('Sum'): sum, _('Volume'): vol, _('Values'): vals}
@@ -6806,7 +6935,9 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         plt.show()
 
-    def interpolate_on_polygon(self, working_vector: vector, method:Literal["nearest", "linear", "cubic"]="linear"):
+    def interpolate_on_polygon(self, working_vector: vector,
+                               method:Literal["nearest", "linear", "cubic"]="linear",
+                               keep:Literal['all', 'below', 'above'] = 'all'):
         """
         Interpolation sous un polygone
 
@@ -6818,6 +6949,14 @@ class WolfArray(Element_To_Draw, header_wolf):
         depuis les vertices 3D du polygone
         """
 
+        if keep not in ['all', 'below', 'above']:
+            logging.error(_('keep must be "all", "below" or "above"'))
+            raise ValueError
+
+        if method not in ['nearest', 'linear', 'cubic']:
+            logging.error(_('method must be "nearest", "linear" or "cubic"'))
+            raise ValueError
+
         if self.mngselection is None:
             destxy = self.get_xy_inside_polygon(working_vector)
             if len(destxy)==0:
@@ -6841,6 +6980,9 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 destxy = self.SelectionData.myselection
 
+                # if isinstance(destxy, list):
+                #     destxy = np.asarray(destxy)
+
             if len(destxy)==0:
                 logging.debug(_('No points to interpolate'))
                 return
@@ -6851,7 +6993,13 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         newvalues = griddata(xyz[:, :2], xyz[:, 2], destxy, method=method, fill_value=-99999.)
 
-        locmask = np.where(newvalues != -99999.)
+        if keep == 'all':
+            locmask = np.where(newvalues != -99999.)
+        elif keep == 'below':
+            locmask = np.where((newvalues != -99999.) & (newvalues < self.array.data[destij[:, 0], destij[:, 1]]))
+        elif keep == 'above':
+            locmask = np.where((newvalues != -99999.) & (newvalues > self.array.data[destij[:, 0], destij[:, 1]]))
+
         self.array.data[destij[locmask][:, 0], destij[locmask][:, 1]] = newvalues[locmask]
 
     def rasterize_vector_valuebyid(self, working_vector: vector, id,
@@ -6910,14 +7058,16 @@ class WolfArray(Element_To_Draw, header_wolf):
         for curzone in working_zones.myzones:
             self.rasterize_zone_valuebyid(curzone, id, method)
 
-    def interpolate_on_polygons(self, working_zone:zone, method:Literal["nearest", "linear", "cubic"]="linear"):
+    def interpolate_on_polygons(self, working_zone:zone,
+                                method:Literal["nearest", "linear", "cubic"]="linear",
+                                keep:Literal['all', 'below', 'above'] = 'all'):
         """
         Interpolation sous plusieurs polygones d'une même zone
 
         """
 
         for curvec in working_zone.myvectors:
-            self.interpolate_on_polygon(curvec, method)
+            self.interpolate_on_polygon(curvec, method, keep)
 
     def interpolate_on_polyline(self, working_vector:vector, usemask=True):
         """
@@ -6994,7 +7144,9 @@ class WolfArray(Element_To_Draw, header_wolf):
 
     def interpolate_on_triangulation(self, coords, triangles,
                                      grid_x=None, grid_y = None,
-                                     mask_tri=None, interp_method:Literal['matplotlib','scipy'] = 'matplotlib'):
+                                     mask_tri=None,
+                                     interp_method:Literal['matplotlib','scipy'] = 'matplotlib',
+                                     keep:Literal['all', 'below', 'above'] = 'all'):
         """
         Interpolation sur une triangulation.
 
@@ -7003,7 +7155,8 @@ class WolfArray(Element_To_Draw, header_wolf):
           - dans les mailles contenues dans la triangulation sinon
 
         Matplotlib is used by default, but Scipy(griddata) can be used as well. If Matplotlib crashes, try with Scipy.
-        Matplotlib is more strict on the quality of the triangulation.
+
+        **Matplotlib is more strict on the quality of the triangulation.**
 
         :param coords: numpy.array of vertices - shape (n,3)
         :param triangles: numpy.array of triangles - shape (m,3)
@@ -7011,6 +7164,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param grid_y: numpy.array of y values where the interpolation will be done -- if None, the grid is created from the array
         :param mask_tri: numpy.array of mask for the triangles
         :param interp_method: method for the interpolation -- 'matplotlib' or 'scipy'
+        :param keep: 'all' to keep all values, 'below' to keep only values below the current array, 'above' to keep only values above the current array
 
         For matplotlib algo, see : https://matplotlib.org/stable/gallery/images_contours_and_fields/triinterp_demo.html
         For scipy algo, see : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
@@ -7019,6 +7173,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
 
         if interp_method =='matplotlib':
+            # FIXME : This part could be optimized, I think
 
             import matplotlib.tri as mtri
 
@@ -7027,6 +7182,9 @@ class WolfArray(Element_To_Draw, header_wolf):
             try:
                 if self.mngselection is not None:
                     if self.mngselection.myselection != [] and self.mngselection.myselection != 'all':
+                        # interpolation only in the selected cells
+
+                        # Convert coordinates to indices
                         ij = np.asarray([self.get_ij_from_xy(x, y) for x, y in self.mngselection.myselection])
 
                         try:
@@ -7037,17 +7195,60 @@ class WolfArray(Element_To_Draw, header_wolf):
                             interplin = mtri.LinearTriInterpolator(triang, coords[:,2])            # Interpolation et récupération dans le numpy.array de l'objet Wolf
                         except:
                             raise Warning(_('Bad triangulation - try with another method like Scipy'))
+
                         newvalues = np.ma.masked_array([interplin(x, y) for x, y in self.mngselection.myselection])
 
-                        ij = ij[np.where(~newvalues.mask)]
-                        self.array.data[ij[:, 0], ij[:, 1]] = newvalues.data[np.where(~newvalues.mask)]
+                        if newvalues.mask.shape!=():
+                            # We have a mask
+
+                            nonmasked_values = np.where(~newvalues.mask)
+                            ij = ij[nonmasked_values]
+                            newvalues = newvalues[nonmasked_values]
+
+                            if keep == 'below':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues > self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[np.where(~newvalues.mask)]
+                                newvalues = newvalues[nonmasked_values]
+
+                            elif keep == 'above':
+                                newvalues = np.ma.masked_array(newvalues[nonmasked_values], mask=(newvalues[nonmasked_values] < self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[np.where(~newvalues.mask)]
+                                newvalues = newvalues[nonmasked_values]
+
+                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues
+                        else:
+                            # No mask --> boolean
+
+                            if keep == 'below':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues > self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[np.where(~newvalues.mask)]
+                                newvalues = newvalues[nonmasked_values]
+
+                            elif keep == 'above':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues < self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[np.where(~newvalues.mask)]
+                                newvalues = newvalues[nonmasked_values]
+
+                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues
 
                     elif self.mngselection.myselection == 'all' and (grid_x is None and grid_y is None):
+                        # interpolation in all the cells
+
+                        # Creating a grid for all cells
                         decalx = self.origx + self.translx
                         decaly = self.origy + self.transly
                         x = np.arange(self.dx / 2. + decalx, float(self.nbx) * self.dx + self.dx / 2 + decalx, self.dx)
                         y = np.arange(self.dy / 2. + decaly, float(self.nby) * self.dy + self.dy / 2 + decaly, self.dy)
                         grid_x, grid_y = np.meshgrid(x, y, indexing='ij')
+                        grid_ij = self.xy2ij_np(np.concatenate([grid_x.ravel()[:, np.newaxis], grid_y.ravel()[:, np.newaxis]], axis=1))
 
                         try:
                             # Opérateur d'interpolation linéaire
@@ -7057,11 +7258,32 @@ class WolfArray(Element_To_Draw, header_wolf):
                             interplin = mtri.LinearTriInterpolator(triang, coords[:,2])
                         except:
                             raise Warning(_('Bad triangulation - try with another method like Scipy'))
+
                         # Interpolation et récupération dans le numpy.array de l'objet Wolf
-                        newvalues = interplin(grid_x,grid_y).astype(np.float32)
-                        self.array.data[~newvalues.mask] = newvalues[~newvalues.mask]
+                        newvalues = interplin(grid_x,grid_y)
+
+                        nonmasked_values = np.where(~newvalues.mask)
+                        ij = grid_ij[nonmasked_values]
+                        newvalues = newvalues[nonmasked_values]
+
+                        if keep == 'below':
+                            newvalues = np.ma.masked_array(newvalues, mask=(newvalues > self.array.data[grid_ij[:, 0], grid_ij[:, 1]]))
+
+                            nonmasked_values = np.where(~newvalues.mask)
+                            ij = grid_ij[nonmasked_values]
+                            newvalues = newvalues[nonmasked_values]
+
+                        elif keep == 'above':
+                            newvalues = np.ma.masked_array(newvalues, mask=(newvalues < self.array.data[grid_ij[:, 0], grid_ij[:, 1]]))
+
+                            nonmasked_values = np.where(~newvalues.mask)
+                            ij = grid_ij[nonmasked_values]
+                            newvalues = newvalues[nonmasked_values]
+
+                        self.array.data[ij[:, 0], ij[:, 1]] = newvalues
+
                     elif (grid_x is not None and grid_y is not None):
-                        ij = np.asarray([self.get_ij_from_xy(x, y) for x, y in zip(grid_x.flatten(),grid_y.flatten())])
+                        # Working on an imposed grid
 
                         # Opérateur d'interpolation linéaire
                         try:
@@ -7069,16 +7291,56 @@ class WolfArray(Element_To_Draw, header_wolf):
                             if mask_tri is not None:
                                 triang.set_mask(mask_tri)
                             interplin = mtri.LinearTriInterpolator(triang, coords[:,2])            # Interpolation et récupération dans le numpy.array de l'objet Wolf
-                            newvalues = np.ma.masked_array([interplin(x, y) for x, y in zip(grid_x.flatten(),grid_y.flatten())])
+                            newvalues = np.ma.masked_array([interplin(x, y) for x, y in zip(grid_x.ravel(),grid_y.ravel())])
                         except:
                             raise Warning(_('Bad triangulation - try with another method like Scipy'))
 
+                        # newvalues is a vector of values
+
+                        # ij is a vector of indices
+                        ij = np.asarray([self.get_ij_from_xy(x, y) for x, y in zip(grid_x.ravel(),grid_y.ravel())])
+
                         if newvalues.mask.shape!=():
-                            ij = ij[np.where(~newvalues.mask)]
-                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues.data[np.where(~newvalues.mask)]
+
+                            nonmasked_values = np.where(~newvalues.mask)
+                            ij = ij[nonmasked_values]
+                            newvalues = newvalues[nonmasked_values]
+
+                            if keep == 'below':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues > self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[nonmasked_values]
+                                newvalues = newvalues[nonmasked_values]
+
+                            elif keep == 'above':
+
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues < self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[nonmasked_values]
+                                newvalues = newvalues[nonmasked_values]
+
+                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues
                         else:
-                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues.data
+
+                            if keep == 'below':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues > self.array.data[ij[:, 0], ij[:, 1]]))
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[nonmasked_values]
+                                newvalues = newvalues[nonmasked_values]
+                            elif keep == 'above':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues < self.array.data[ij[:, 0], ij[:, 1]]))
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[nonmasked_values]
+                                newvalues = newvalues[nonmasked_values]
+
+                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues
+
                     else:
+                        # Working on the whole array
+
+                        # Creating a grid for all cells
                         decalx = self.origx + self.translx
                         decaly = self.origy + self.transly
                         x = np.arange(self.dx / 2. + decalx, float(self.nbx) * self.dx + self.dx / 2 + decalx, self.dx)
@@ -7092,12 +7354,25 @@ class WolfArray(Element_To_Draw, header_wolf):
                                 triang.set_mask(mask_tri)
                             interplin = mtri.LinearTriInterpolator(triang, coords[:,2])
                             # Interpolation et récupération dans le numpy.array de l'objet Wolf
+
+                            # newvalues is an array
                             newvalues = interplin(grid_x,grid_y).astype(np.float32)
-                            self.array.data[~newvalues.mask] = newvalues[~newvalues.mask]
+
+                            assert newvalues.shape == (self.nbx, self.nby), _('Bad shape for newvalues')
+
+                            if keep == 'below':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues > self.array.data))
+                            elif keep == 'above':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues < self.array.data))
+
+                            nonmasked_values = np.where(~newvalues.mask)
+
+                            self.array.data[nonmasked_values] = newvalues[nonmasked_values]
                         except:
                             raise Warning(_('Bad triangulation - try with another method like Scipy'))
                 else:
                     if grid_x is None and grid_y is None:
+
                         decalx = self.origx + self.translx
                         decaly = self.origy + self.transly
                         x = np.arange(self.dx / 2. + decalx, float(self.nbx) * self.dx + self.dx / 2 + decalx, self.dx)
@@ -7108,22 +7383,80 @@ class WolfArray(Element_To_Draw, header_wolf):
                         triang = mtri.Triangulation(coords[:,0],coords[:,1],triangles)
                         interplin = mtri.LinearTriInterpolator(triang, coords[:,2])
                         # Interpolation et récupération dans le numpy.array de l'objet Wolf
-                        newvalues = np.ma.masked_array([interplin(x, y) for x, y in zip(grid_x.flatten(),grid_y.flatten())])
+                        newvalues = np.ma.masked_array([interplin(x, y) for x, y in zip(grid_x.ravel(), grid_y.ravel())])
                         # newvalues = interplin(grid_x,grid_y).astype(np.float32)
-                        self.array.data[~newvalues.mask] = newvalues[~newvalues.mask]
+
+                        nonmasked_values = np.where(~newvalues.mask)
+                        grid_x = grid_x.ravel()[nonmasked_values]
+                        grid_y = grid_y.ravel()[nonmasked_values]
+                        newvalues = newvalues[nonmasked_values]
+
+                        # make a shape (n, 2) from grid_x and grid_y
+                        grid_x = grid_x[:, np.newaxis]
+                        grid_y = grid_y[:, np.newaxis]
+                        # concatenate grid_x and grid_y
+                        grid_ij = self.xy2ij_np(np.concatenate([grid_x, grid_y], axis=1))
+
+                        if keep == 'below':
+                            newvalues = np.ma.masked_array(newvalues, mask=(newvalues > self.array.data[grid_ij[:,0], grid_ij[:,1]]))
+
+                            nonmasked_values = np.where(~newvalues.mask)
+                            grid_ij = grid_ij[nonmasked_values]
+                            newvalues = newvalues[nonmasked_values]
+
+                        elif keep == 'above':
+                            newvalues = np.ma.masked_array(newvalues, mask=(newvalues < self.array.data[grid_ij[:,0], grid_ij[:,1]]))
+
+                            nonmasked_values = np.where(~newvalues.mask)
+                            grid_ij = grid_ij[nonmasked_values]
+                            newvalues = newvalues[nonmasked_values]
+
+                        self.array.data[grid_ij[:,0], grid_ij[:,1]] = newvalues
+
                     else:
-                        ij = np.asarray([self.get_ij_from_xy(x, y) for x, y in zip(grid_x.flatten(),grid_y.flatten())])
+                        ij = np.asarray([self.get_ij_from_xy(x, y) for x, y in zip(grid_x.ravel(),grid_y.ravel())])
 
                         # Opérateur d'interpolation linéaire
                         triang = mtri.Triangulation(coords[:,0],coords[:,1],triangles)
                         interplin = mtri.LinearTriInterpolator(triang, coords[:,2])            # Interpolation et récupération dans le numpy.array de l'objet Wolf
-                        newvalues = np.ma.masked_array([interplin(x, y) for x, y in zip(grid_x.flatten(),grid_y.flatten())])
+                        newvalues = np.ma.masked_array([interplin(x, y) for x, y in zip(grid_x.ravel(), grid_y.ravel())])
 
                         if newvalues.mask.shape!=():
-                            ij = ij[np.where(~newvalues.mask)]
-                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues.data[np.where(~newvalues.mask)]
+                            nonmasked_values = np.where(~newvalues.mask)
+                            ij = ij[nonmasked_values]
+                            newvalues = newvalues[nonmasked_values]
+
+                            if keep == 'below':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues > self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[nonmasked_values]
+                                newvalues = newvalues[nonmasked_values]
+
+                            elif keep == 'above':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues < self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[nonmasked_values]
+                                newvalues = newvalues[nonmasked_values]
+
+                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues
                         else:
-                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues.data
+                            if keep == 'below':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues > self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[nonmasked_values]
+                                newvalues = newvalues[nonmasked_values]
+
+                            elif keep == 'above':
+                                newvalues = np.ma.masked_array(newvalues, mask=(newvalues < self.array.data[ij[:, 0], ij[:, 1]]))
+
+                                nonmasked_values = np.where(~newvalues.mask)
+                                ij = ij[nonmasked_values]
+                                newvalues = newvalues[nonmasked_values]
+
+                            self.array.data[ij[:, 0], ij[:, 1]] = newvalues
 
                 #on force les valeurs masquées à nullvalue afin que l'interpolation n'applique pas ses effets dans cette zone
                 self.array.data[self.array.mask]= self.nullvalue
@@ -7131,13 +7464,15 @@ class WolfArray(Element_To_Draw, header_wolf):
                 use_scipy=True
 
         if interp_method != 'matplotlib' or use_scipy:
+            # We need to convert the triangle to a vector to call the interpolation
+
             for curtri in triangles:
                 curvec = vector(is2D=False)
                 for curpt in curtri:
-                    curvec.add_vertex(wolfvertex(coords[curpt,0],coords[curpt,1], coords[curpt,2]))
+                    curvec.add_vertex(wolfvertex(coords[curpt,0], coords[curpt,1], coords[curpt,2]))
                 curvec.close_force()
 
-                self.interpolate_on_polygon(curvec, "linear")
+                self.interpolate_on_polygon(curvec, "linear", keep)
 
         self.reset_plot()
         return
@@ -8558,7 +8893,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param step_factor: step factor for the discretization of myvect (<1 for thinner, >1 for coarser)
         """
 
-        if step_factor>=1.0:
+        if step_factor>1.0:
             logging.warning("Step_factor greater than 1.0 may lead to lots of missing (i,j) even if faster")
         else:
             def mod_fix(x, y, tol=1e-10):
@@ -10054,7 +10389,12 @@ class WolfArray(Element_To_Draw, header_wolf):
             nbx = curlist['nbx']
             nby = curlist['nby']
             first = curlist['firstlist']
-            glDeleteLists(first, nbx * nby)
+
+            try:
+                glDeleteLists(first, nbx * nby)
+            except Exception as e:
+                logging.error(_('OpenGL error in WolfArray.delete_lists -- Please report this case with the data file and the context in which the error occured'))
+                logging.error(e)
 
             logging.debug(str(first)+'  '+str(nbx * nby))
 
@@ -11214,7 +11554,9 @@ class WolfArrayMB(WolfArray):
 
         self.reset_plot()
 
-    def interpolate_on_polygon(self, working_vector: vector, method:Literal["nearest", "linear", "cubic"]="linear"):
+    def interpolate_on_polygon(self, working_vector: vector,
+                               method:Literal["nearest", "linear", "cubic"]="linear",
+                               keep:Literal['all', 'below', 'above'] = 'all'):
         """
         Interpolation sous un polygone
 
@@ -11227,12 +11569,14 @@ class WolfArrayMB(WolfArray):
         """
 
         for curblock in self.myblocks.values():
-            curblock.interpolate_on_polygon(working_vector, method)
+            curblock.interpolate_on_polygon(working_vector, method, keep)
 
-    def interpolate_on_polygons(self, working_zone: zone, method:Literal["nearest", "linear", "cubic"]="linear"):
+    def interpolate_on_polygons(self, working_zone: zone,
+                                method:Literal["nearest", "linear", "cubic"]="linear",
+                                keep:Literal['all', 'below', 'above'] = 'all'):
 
         for curvector in working_zone.myvectors:
-            self.interpolate_on_polygon(curvector, method)
+            self.interpolate_on_polygon(curvector, method, keep)
 
     def interpolate_on_polyline(self, working_vector:vector, usemask=True):
         """