wolfhece 2.2.16__py3-none-any.whl → 2.2.18__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):
         """
@@ -6124,17 +6235,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 +6917,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 +6931,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 +6962,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 +6975,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 +7040,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 +7126,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 +7137,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 +7146,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 +7155,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 +7164,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 +7177,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 +7240,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 +7273,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 +7336,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 +7365,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 +7446,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
@@ -7699,7 +8016,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                                         self.nby)
                         cursel = [(x, y) for x in xall for y in yall]
 
-                    z = griddata(curlist, z, cursel, fill_value=np.NaN)
+                    z = griddata(curlist, z, cursel, fill_value=np.nan)
 
                     for cur, curz in zip(cursel, z):
                         if not np.isnan(curz):
@@ -8558,7 +8875,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):
@@ -10068,7 +10385,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                         figsize:tuple=None,
                         Walonmap:bool=False,
                         cat:str='IMAGERIE/ORTHO_2022_ETE',
-                        first_mask_data:bool=True):
+                        first_mask_data:bool=True,
+                        with_legend:bool=False):
         """
         Plot the array - Matplotlib version
 
@@ -10117,6 +10435,10 @@ class WolfArray(Element_To_Draw, header_wolf):
             - `'IMAGERIE/ORTHO_2023_ETE'`
             - `'IMAGERIE/ORTHO_LAST'`
         :type cat: str, optional (Default value = `'IMAGERIE/ORTHO_2022_ETE'`)
+        :param first_mask_data: If True, applies the mask to the data before plotting. Default is True.
+        :type first_mask_data: bool, optional (Default value = True)
+        :param with_legend: If True, adds a color legend to the plot. Default is False.
+        :type with_legend: bool, optional (Default value = False)
         :return: If `getdata_im` is False, returns (fig, ax), where `fig` is the Matplotlib figure and `ax` is the axis. If `getdata_im` is True, returns (fig, ax, im), where `im` is the image object created by `imshow`.
         :rtype: tuple
         """
@@ -10146,6 +10468,11 @@ class WolfArray(Element_To_Draw, header_wolf):
                 logging.error(_('Error while fetching the map image from WalOnMap'))
                 logging.error(e)
 
+        if vmin is None and vmax is not None:
+            vmin = self.mypal.values[0]
+        elif vmax is None and vmin is not None:
+            vmax = self.mypal.values[-1]
+
         if (vmin is None) and (vmax is None):
             # im = ax.imshow(self.array.transpose(), origin='lower', cmap=self.mypal,
             #         extent=(self.origx, self.origx + self.dx * self.nbx, self.origy, self.origy + self.dy * self.nby))
@@ -10160,6 +10487,21 @@ class WolfArray(Element_To_Draw, header_wolf):
                                    self.origy + self.dy * self.nby),
                             alpha=np.select([self.array.mask.T, ~self.array.mask.T],
                                             [np.zeros(self.shape).T, np.ones(self.shape).T]))
+
+            if with_legend:
+                # add a legend in a new axis
+                ax_leg = fig.add_axes([0.92, 0.12, 0.04, 0.8])
+                from matplotlib.colorbar import ColorbarBase
+                from matplotlib import colors
+                cbar = ColorbarBase(ax_leg, cmap=self.mypal.cmap, norm=self.mypal.norm, orientation='vertical')
+                cbar.set_ticks(self.mypal.values)
+                cbar.set_ticklabels(self.mypal.values)
+                cbar.ax.tick_params(labelsize=8)
+                cbar.ax.yaxis.set_label_position('left')
+                cbar.ax.yaxis.set_ticks_position('right')
+                cbar.ax.yaxis.set_tick_params(width=0.5, size=2, direction='in', color='black')
+
+
         else:
             im = ax.imshow(self.array.transpose(),
                            origin='lower',
@@ -10171,7 +10513,27 @@ class WolfArray(Element_To_Draw, header_wolf):
                            vmin=vmin, vmax=vmax,
                            alpha=np.select([self.array.mask.T, ~self.array.mask.T],
                                            [np.zeros(self.shape).T, np.ones(self.shape).T])                           )
+
+
+            if with_legend:
+                # add a legend in a new axis
+                ax_leg = fig.add_axes([0.92, 0.12, 0.04, 0.8])
+                from matplotlib.colorbar import ColorbarBase
+                from matplotlib import colors
+                from matplotlib.colors import Normalize
+                cbar = ColorbarBase(ax_leg, cmap=self.mypal.cmap, norm= Normalize(vmin, vmax), orientation='vertical')
+                vals = list(np.linspace(vmin, vmax, self.mypal.nb, endpoint=True))
+                # limit to 2 decimal places
+                vals = [round(val, 2) for val in vals]
+                cbar.set_ticks(vals)
+                cbar.set_ticklabels(vals)
+                cbar.ax.tick_params(labelsize=8)
+                cbar.ax.yaxis.set_label_position('left')
+                cbar.ax.yaxis.set_ticks_position('right')
+                cbar.ax.yaxis.set_tick_params(width=0.5, size=2, direction='in', color='black')
+
         ax.set_aspect('equal')
+        fig.tight_layout()
 
         if getdata_im:
             return fig, ax, im
@@ -11169,7 +11531,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
 
@@ -11182,12 +11546,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):
         """
@@ -11437,7 +11803,7 @@ class WolfArrayMB(WolfArray):
         :param j: j index
         :param which_block: block index 1-based
         """
-        h = np.NaN
+        h = np.nan
         if which_block == 0:
             logging.warning("Block index is probably 0-based. It should be 1-based.")
             return h
@@ -11458,7 +11824,7 @@ class WolfArrayMB(WolfArray):
         Read the value at world coordinate (x,y). if `abs` is
         given, then the translation is is taken into account.
 
-        If no block covers the coordinate, then np.NaN is returned
+        If no block covers the coordinate, then np.nan is returned
         If several blocks cover the given coordinate then the first
         match is returned (and thus, the others are ignored).
 
@@ -11466,10 +11832,10 @@ class WolfArrayMB(WolfArray):
         :param y: y coordinate
         :param abs: if True, then the translation is taken into account
 
-        :return: the value at (x,y) or np.NaN if no block covers the coordinate
+        :return: the value at (x,y) or np.nan if no block covers the coordinate
         """
 
-        h = np.NaN
+        h = np.nan
         for curblock in self.myblocks.values():
             curblock: WolfArray
             nbx = curblock.nbx
@@ -12101,7 +12467,8 @@ class WolfArrayMB(WolfArray):
                         figsize:tuple=None,
                         Walonmap:bool=False,
                         cat:str='IMAGERIE/ORTHO_2022_ETE',
-                        first_mask_data:bool=True):
+                        first_mask_data:bool=True,
+                        with_legend:bool=False):
         """
         Plot the multi-block (MB) array - Matplotlib version
 
@@ -12153,6 +12520,10 @@ class WolfArrayMB(WolfArray):
             - `'IMAGERIE/ORTHO_2023_ETE'`
             - `'IMAGERIE/ORTHO_LAST'`
         :type cat: str, optional (Default value = `'IMAGERIE/ORTHO_2022_ETE'`)
+        :param first_mask_data: If True, applies the mask to the data before plotting. Default is True.
+        :type first_mask_data: bool, optional (Default value = True)
+        :param with_legend: If True, adds a color legend to the plot. Default is False.
+        :type with_legend: bool, optional (Default value = False)
         :return: If `getdata_im` is False, returns (fig, ax), where `fig` is the Matplotlib figure and `ax` is the axis. If `getdata_im` is True, returns (fig, ax, im), where `im` is the image object created by `imshow`.
         :rtype: tuple
         """
@@ -12167,7 +12538,8 @@ class WolfArrayMB(WolfArray):
                                             figsize=figsize,
                                             Walonmap=Walonmap,
                                             cat=cat,
-                                            first_mask_data=first_mask_data)
+                                            first_mask_data=first_mask_data,
+                                            with_legend=with_legend)
 
 
 class WolfArrayMNAP(WolfArrayMB):