wolfhece 2.1.50__py3-none-any.whl → 2.1.56__py3-none-any.whl

wolfhece/wolf_array.py

@@ -40,7 +40,7 @@ import wx
 from scipy.interpolate import interp2d, griddata
 from scipy.ndimage import laplace, label, sum_labels
 import pygltflib
-from shapely.geometry import Point, LineString, MultiLineString
+from shapely.geometry import Point, LineString, MultiLineString, Polygon, MultiPolygon, MultiPoint
 from shapely.ops import linemerge, substring, polygonize_full
 from os.path import dirname,basename,join
 import logging
@@ -95,6 +95,39 @@ WOLF_ARRAY_MB = [WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_MNAP_IN
 
 VERSION_RGB = 2
 
+from numba import jit
+
+@jit(nopython=True)
+def custom_gradient(array: np.ndarray):
+    """ Calculate the gradient manually """
+    grad_x = np.zeros_like(array)
+    grad_y = np.zeros_like(array)
+
+    for i in range(1, array.shape[0] - 1):
+        for j in range(1, array.shape[1] - 1):
+            grad_x[i, j] = (array[i + 1, j] - array[i - 1, j]) / 2.0
+            grad_y[i, j] = (array[i, j + 1] - array[i, j - 1]) / 2.0
+
+    return grad_x, grad_y
+
+@jit(nopython=True)
+def hillshade(array:np.ndarray, azimuth:float, angle_altitude:float) -> np.ndarray:
+    """ Create a hillshade array """
+
+    azimuth = 360.0 - azimuth
+
+    x, y = custom_gradient(array)
+    slope = np.pi / 2. - np.arctan(np.sqrt(x * x + y * y))
+    aspect = np.arctan2(-x, y)
+    azimuthrad = azimuth * np.pi / 180.
+    altituderad = angle_altitude * np.pi / 180.
+
+    shaded = np.sin(altituderad) * np.sin(slope) + np.cos(altituderad) * \
+             np.cos(slope) * np.cos((azimuthrad - np.pi / 2.) - aspect)
+    shaded += 1.
+    shaded *= .5
+
+    return shaded.astype(np.float32)
 class Rebin_Ops(Enum):
     MIN = 0
     MEAN = 1
@@ -1104,7 +1137,7 @@ class header_wolf():
 
             return newvector
 
-    def get_xy_infootprint_vect(self, myvect: vector, eps:float = 0.) -> tuple[np.ndarray,np.ndarray]:
+    def get_xy_infootprint_vect(self, myvect: vector | Polygon, eps:float = 0.) -> tuple[np.ndarray,np.ndarray]:
         """
         Return the coordinates of the cells in the footprint of a vector
 
@@ -1121,7 +1154,7 @@ class header_wolf():
 
         return mypts,myptsij
 
-    def get_ij_infootprint_vect(self, myvect: vector, eps:float = 0.) -> np.ndarray:
+    def get_ij_infootprint_vect(self, myvect: vector | Polygon, eps:float = 0.) -> np.ndarray:
         """
         Return the indices of the cells in the footprint of a vector
 
@@ -1129,8 +1162,16 @@ class header_wolf():
         :return : numpy array of indices
         """
 
-        i1, j1 = self.get_ij_from_xy(myvect.xmin+eps, myvect.ymin+eps)
-        i2, j2 = self.get_ij_from_xy(myvect.xmax-eps, myvect.ymax-eps)
+        if isinstance(myvect, Polygon):
+            xmin, ymin, xmax, ymax = myvect.bounds
+        elif isinstance(myvect, vector):
+            xmin, ymin, xmax, ymax = myvect.xmin, myvect.ymin, myvect.xmax, myvect.ymax
+        else:
+            logging.error(_('The object must be a vector or a Polygon'))
+            return np.array([])
+
+        i1, j1 = self.get_ij_from_xy(xmin+eps, ymin+eps)
+        i2, j2 = self.get_ij_from_xy(xmax-eps, ymax-eps)
 
         i1 = max(i1,0) # FIXME Why ??? How could i,j be negative ? --> because this fucntion can be called with a vector that is not in the array (e.g. a vector defined by clicks in the UI)
         j1 = max(j1,0)
@@ -1379,6 +1420,11 @@ class Ops_Array(wx.Frame):
         if self.wx_exists:
             self.set_GUI()
 
+    @property
+    def idx(self):
+        """ Return the idx of the parentarray """
+        return self.parentarray.idx
+
     def get_mapviewer(self):
         """ Retourne l'instance WolfMapViewer """
         return self.mapviewer
@@ -1488,7 +1534,7 @@ class Ops_Array(wx.Frame):
 
         self.palimage = wx.Button(self.Palette, wx.ID_ANY, _("Create image"), wx.DefaultPosition, wx.DefaultSize, 0)
         self.palimage.SetToolTip(_('Generate colormap image (horizontal, vertical or both) and save to disk'))
-        self.paldistribute = wx.Button(self.Palette, wx.ID_ANY, _("Distribute"), wx.DefaultPosition, wx.DefaultSize, 0)
+        self.paldistribute = wx.Button(self.Palette, wx.ID_ANY, _("Evenly spaced"), wx.DefaultPosition, wx.DefaultSize, 0)
         self.paldistribute.SetToolTip(_('Set colormap values based on minimum+maximum or minimum+step'))
         if self.parentarray.mypal.automatic:
             self.palauto.SetValue(1)
@@ -2397,6 +2443,7 @@ class Ops_Array(wx.Frame):
         if self.mapviewer is not None:
             self.mapviewer.start_action('select node by node', _('Please click on the desired nodes...'))
             self.mapviewer.active_array = self.parentarray
+            self.mapviewer.set_label_selecteditem(self.parentarray.idx)
 
     def select_zone_inside_manager(self):
         """
@@ -2439,6 +2486,7 @@ class Ops_Array(wx.Frame):
 
             self.mapviewer.start_action('select by vector inside', _('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.)
@@ -2477,6 +2525,7 @@ class Ops_Array(wx.Frame):
 
             self.mapviewer.start_action('select by vector along', _('Please draw a polyline...'))
             self.mapviewer.active_array = self.parentarray
+            self.mapviewer.set_label_selecteditem(self.parentarray.idx)
             self.Active_vector(vect)
 
             firstvert = wolfvertex(0., 0.)
@@ -2492,6 +2541,7 @@ class Ops_Array(wx.Frame):
             self.vectmp.reset()
             self.Active_vector(self.vectmp)
             self.mapviewer.active_array = self.parentarray
+            self.mapviewer.set_label_selecteditem(self.parentarray.idx)
 
             firstvert = wolfvertex(0., 0.)
             self.vectmp.add_vertex(firstvert)
@@ -2506,6 +2556,7 @@ class Ops_Array(wx.Frame):
             self.vectmp.reset()
             self.Active_vector(self.vectmp)
             self.mapviewer.active_array = self.parentarray
+            self.mapviewer.set_label_selecteditem(self.parentarray.idx)
 
             firstvert = wolfvertex(0., 0.)
             self.vectmp.add_vertex(firstvert)
@@ -2648,7 +2699,8 @@ class Ops_Array(wx.Frame):
         myarray.mypal.export_image()
 
     def Onpaldistribute(self, event:wx.MouseEvent):
-        """ Distribute values in palette """
+        """ Evenly spaced values in palette """
+
         myarray: WolfArray
         myarray = self.parentarray
         myarray.mypal.distribute_values()
@@ -2698,9 +2750,13 @@ class Ops_Array(wx.Frame):
                 curarray.shading = True
 
             alpha = float(self.palalphahillshade.GetValue()) / 100.
-            if curarray.shaded.alpha != alpha:
-                curarray.shaded.alpha = alpha
-                curarray.shading = True
+
+            if curarray.shaded is None:
+                logging.error('No shaded array')
+            else:
+                if curarray.shaded.alpha != alpha:
+                    curarray.shaded.alpha = alpha
+                    curarray.shading = True
 
         if dellists:
             self.refresh_array()
@@ -4410,6 +4466,25 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
+    def set_opacity(self, alpha:float):
+        """ Set the transparency of the array """
+
+        if alpha <0.:
+            alpha = 0.
+
+        if alpha > 1.:
+            alpha = 1.
+
+        self.alpha = alpha
+
+        if self.myops is not None:
+            self.myops.palalpha.SetValue(0)
+            self.myops.palalphaslider.SetValue(int(alpha*100))
+
+        self.reset_plot()
+
+        return self.alpha
+
     @property
     def memory_usage(self):
         """
@@ -4552,6 +4627,10 @@ class WolfArray(Element_To_Draw, header_wolf):
         """ Affichage des propriétés de la matrice dans une fenêtre wxPython """
         if self.wx_exists and self.myops is not None:
             self.myops.SetTitle(_('Operations on array: ') + self.idx)
+
+            if self.mapviewer is not None:
+                self.myops.SetIcon(self.mapviewer.GetIcon())
+
             self.myops.Show()
 
             self.myops.Center()
@@ -4566,7 +4645,6 @@ class WolfArray(Element_To_Draw, header_wolf):
     @property
     def nullvalue(self) -> float:
         """ Return the null value """
-
         return self._nullvalue
 
     @nullvalue.setter
@@ -4575,6 +4653,16 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self._nullvalue = value
 
+    @property
+    def nodata(self) -> float:
+        """ alias for nullvalue """
+        return self._nullvalue
+
+    @nodata.setter
+    def nodata(self, value:float):
+        """ alias for nullvalue """
+        self._nullvalue = value
+
     @property
     def SelectionData(self) -> SelectionData:
         """ Return the data of the selection """
@@ -5757,23 +5845,14 @@ class WolfArray(Element_To_Draw, header_wolf):
         return mytri, znull
 
     def hillshade(self, azimuth:float, angle_altitude:float):
-        """ Create a hillshade array """
+        """ Create a hillshade array  -- see "hillshade" function accelerated by JIT"""
 
-        azimuth = 360.0 - azimuth
-
-        x, y = np.gradient(self.array)
-        slope = np.pi / 2. - np.arctan(np.sqrt(x * x + y * y))
-        aspect = np.arctan2(-x, y)
-        azimuthrad = azimuth * np.pi / 180.
-        altituderad = angle_altitude * np.pi / 180.
-
-        shaded = np.sin(altituderad) * np.sin(slope) + np.cos(altituderad) * np.cos(slope) * np.cos(
-            (azimuthrad - np.pi / 2.) - aspect)
-        shaded += 1.
-        shaded *= .5
+        if self.shaded is None:
+            logging.error(_('No shaded array'))
+            return
 
         self.shaded.set_header(self.get_header())
-        self.shaded.array = shaded
+        self.shaded.array = hillshade(self.array.data, azimuth, angle_altitude)
         self.shaded.delete_lists()
 
     def get_gradient_norm(self):
@@ -6544,7 +6623,7 @@ class WolfArray(Element_To_Draw, header_wolf):
     # These functions can not be stored in header_wolf, because wa can use the mask of the array to limit the search
     # These functions are also present in WolfResults_2D, but they are not exactly the same due to the structure of the results
     # *************************************************************************************************************************
-    def get_xy_inside_polygon(self, myvect: vector, usemask:bool=True):
+    def get_xy_inside_polygon(self, myvect: vector | Polygon, usemask:bool=True):
         """
         Return the coordinates inside a polygon
 
@@ -6552,9 +6631,15 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param usemask : limit potential nodes to unmaksed nodes
         """
 
-        myvect.find_minmax()
+        if isinstance(myvect, vector):
+            # force la mise à jour des min/max
+            myvect.find_minmax()
+            # Conversion des coordonnées en numpy pour plus d'efficacité (du moins on espère)
+            myvert = myvect.asnparray()
+        elif isinstance(myvect, Polygon):
+            myvert = myvect.exterior.coords[:-1]
+
         mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect)
-        myvert = myvect.asnparray()
         path = mpltPath.Path(myvert)
         inside = path.contains_points(mypointsxy)
 
@@ -6567,6 +6652,34 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypointsxy
 
+    def get_xy_inside_polygon_shapely(self, myvect: vector | Polygon, usemask:bool=True):
+        """
+        Return the coordinates inside a polygon
+
+        :param myvect : target vector
+        :param usemask : limit potential nodes to unmaksed nodes
+        """
+
+        if isinstance(myvect, vector):
+            # force la mise à jour des min/max
+            myvect.find_minmax()
+            polygon = myvect.asshapely_pol()
+        elif isinstance(myvect, Polygon):
+            polygon = myvect
+
+        mypointsxy, mypointsij = self.get_xy_infootprint_vect(myvect)
+
+        inside = np.asarray([polygon.contains(Point(x,y)) for x,y in mypointsxy])
+
+        mypointsxy = mypointsxy[np.where(inside)]
+
+        if usemask:
+            mypointsij = mypointsij[np.where(inside)]
+            mymask = np.logical_not(self.array.mask[mypointsij[:, 0], mypointsij[:, 1]])
+            mypointsxy = mypointsxy[np.where(mymask)]
+
+        return mypointsxy
+
     def get_xy_under_polyline(self, myvect: vector, usemask:bool=True):
         """
         Return the coordinates along a polyline
@@ -6607,6 +6720,23 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mypointsij
 
+    def intersects_polygon(self, myvect: vector | Polygon, usemask:bool=True):
+        """ Return True if the array intersects the polygon
+
+        :param myvect : target vector
+        :param usemask : limit potential nodes to unmaksed nodes
+        """
+
+        return self.get_xy_inside_polygon(myvect, usemask).shape[0] > 0
+
+    def intersects_polygon_shapely(self, myvect: vector | Polygon, eps:float = 0., usemask:bool=True):
+        """ Return True if the array intersects the polygon
+
+        :param myvect : target vector
+        :param usemask : limit potential nodes to unmaksed nodes
+        """
+        return self.get_xy_inside_polygon_shapely(myvect, usemask).shape[0] > 0
+
     def get_ij_under_polyline(self, myvect: vector, usemask:bool=True):
         """
         Return the indices along a polyline
@@ -6968,6 +7098,8 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             self.array = np.kron(self.array, np.ones((int(1/factor), int(1/factor)), dtype=self.array.dtype))
 
+            self.mask_data(self.nullvalue)
+
         self.count()
 
         # rebin must not change the type of the array
@@ -7185,6 +7317,29 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             logging.warning(_('Type not supported : ')+str(self.dtype))
 
+    def fillin_from_ijz(self, ijz:np.ndarray):
+        """ Remplissage du tableau à partir d'un tableau ijz """
+
+        try:
+            i = ijz[:, 0].astype(int)
+            j = ijz[:, 1].astype(int)
+        except Exception as e:
+            logging.error(_('Error in conversion of ijz to int : ')+str(e))
+            return
+
+        if self.dtype == np.float32:
+            self.array.data[i, j] = np.float32(ijz[:, 2])
+        elif self.dtype == np.float64:
+            self.array.data[i, j] = np.float64(ijz[:, 2])
+        elif self.dtype == np.int32:
+            self.array.data[i, j] = np.int32(ijz[:, 2])
+        elif self.dtype == np.int16:
+            self.array.data[i, j] = np.int16(ijz[:, 2])
+        elif self.dtype == np.int8:
+            self.array.data[i, j] = np.int8(ijz[:, 2])
+        else:
+            logging.warning(_('Type not supported : ')+str(self.dtype))
+
     def mask_force_null(self):
         """
         Force to unmask all and mask null value
@@ -7616,20 +7771,22 @@ class WolfArray(Element_To_Draw, header_wolf):
                                      WOLF_ARRAY_FULL_INTEGER16,
                                      WOLF_ARRAY_FULL_INTEGER16_2,
                                      WOLF_ARRAY_FULL_INTEGER,
-                                     WOLF_ARRAY_FULL_DOUBLE]:
+                                     WOLF_ARRAY_FULL_DOUBLE,
+                                     WOLF_ARRAY_HILLSHAPE]:
                 # FIXME: Currently, only some types are supported in Cython/OpenGL library
                 self._tmp_float32 = self.array.astype(dtype=np.float32)
             else:
                 self._tmp_float32 = None
 
 
-        # if self.shading:
-        #     pond = (self.shaded.array-.5)*2.
-        #     pmin = (1. - self.shaded.alpha) * self.rgb
-        #     pmax = self.shaded.alpha * np.ones(self.rgb.shape) + (1. - self.shaded.alpha) * self.rgb
-        #     for i in range(4):
-        #         self.rgb[pond<0,i] = self.rgb[pond<0,i] * (1.+pond[pond<0]) - pmin[pond<0,i] * pond[pond<0]
-        #         self.rgb[pond>0,i] = self.rgb[pond>0,i] * (1.-pond[pond>0]) + pmax[pond>0,i] * pond[pond>0]
+        if VERSION_RGB==1 :
+            if self.shading:
+                pond = (self.shaded.array-.5)*2.
+                pmin = (1. - self.shaded.alpha) * self.rgb
+                pmax = self.shaded.alpha * np.ones(self.rgb.shape) + (1. - self.shaded.alpha) * self.rgb
+                for i in range(4):
+                    self.rgb[pond<0,i] = self.rgb[pond<0,i] * (1.+pond[pond<0]) - pmin[pond<0,i] * pond[pond<0]
+                    self.rgb[pond>0,i] = self.rgb[pond>0,i] * (1.-pond[pond>0]) + pmax[pond>0,i] * pond[pond>0]
 
         if VERSION_RGB==1 : self.rgb[self.array.mask] = [1., 1., 1., 0.]
 
@@ -7719,11 +7876,15 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if self.wolftype != WOLF_ARRAY_HILLSHAPE and self.shading:
             self.hillshade(self.azimuthhill, self.altitudehill)
-            self.updatepalette(0)
-            self.shaded.updatepalette(0)
+
+            if VERSION_RGB==1 :
+                self.updatepalette(0)
+                self.shaded.updatepalette(0)
+
             self.shading=False
             if self.mapviewer is not None:
-                if not self.idx + '_hillshade' in self.mapviewer.get_list_keys(self.mapviewer.ARRAYS, False) :# .added['arrays'].keys():
+                from .PyDraw import draw_type
+                if not self.idx + '_hillshade' in self.mapviewer.get_list_keys(drawing_type=draw_type.ARRAYS, checked_state= None) :# .added['arrays'].keys():
                     self.mapviewer.add_object('array', newobj=self.shaded, ToCheck=True, id=self.idx + '_hillshade')
 
         try:
@@ -7739,12 +7900,14 @@ class WolfArray(Element_To_Draw, header_wolf):
                             mylist = self.mygrid[cursize]['mylists'][i, j]
                             if mylist > 0:
                                 glCallList(self.mygrid[cursize]['mylists'][i, j])
-                    except:
-                        pass
+                    except Exception as e:
+                        logging.error(_('OpenGL error in WolfArray.plot 1 -- Please report this case with the data file and the context in which the error occured'))
+                        logging.error(e)
 
             glDisable(GL_BLEND)
-        except:
-            logging.error(_('OpenGL error in WolfArray.plot -- Please report this case with the data file and the context in which the error occured'))
+        except Exception as e:
+            logging.error(_('OpenGL error in WolfArray.plot 2 -- Please report this case with the data file and the context in which the error occured'))
+            logging.error(e)
 
         self.plotting = False
 
@@ -7793,9 +7956,7 @@ class WolfArray(Element_To_Draw, header_wolf):
     def fillonecellgrid(self, curscale, loci, locj, force=False):
         """ Fill one cell of the plotted grid """
 
-
-
-        cursize = curscale  # 2**curscale
+        cursize = curscale
 
         if not cursize in self.mygrid.keys():
             return
@@ -7875,22 +8036,28 @@ class WolfArray(Element_To_Draw, header_wolf):
                             elif self.nbnotnull > 0:
                                 wolfogl.addmeall_double_pal(self.array, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart,
                                                 jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst))
-                        elif self.wolftype != WOLF_ARRAY_FULL_SINGLE:
+                        elif self.wolftype not in [WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_HILLSHAPE]:
                             if self.nbnotnull != self.nbx * self.nby:
                                 if self.nbnotnull > 0:
                                     wolfogl.addme_pal(self._tmp_float32, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart,
-                                                jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst))
+                                                jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst), -1.)
                             elif self.nbnotnull > 0:
                                 wolfogl.addmeall_pal(self._tmp_float32, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart,
-                                                jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst))
+                                                jend, istart, iend, cursize, self.nullvalue, self.alpha, int(self.mypal.interval_cst), -1.)
                         else:
+                            clr_float = self.mypal.colorsflt.copy()
+                            clr_float[:,3] = self.alpha
+                            if '_hillshade' in self.idx:
+                                clr_float[1,3] = 0.
+
                             if self.nbnotnull != self.nbx * self.nby:
                                 if self.nbnotnull > 0:
-                                    wolfogl.addme_pal(self.array, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart, jend, istart, iend, cursize,
-                                                self.nullvalue, self.alpha, int(self.mypal.interval_cst))
+
+                                    wolfogl.addme_pal(self.array, clr_float, self.mypal.values, ox, oy, dx, dy, jstart, jend, istart, iend, cursize,
+                                                self.nullvalue, self.alpha, int(self.mypal.interval_cst), -1.)
                             elif self.nbnotnull > 0:
-                                wolfogl.addmeall_pal(self.array, self.mypal.colorsflt, self.mypal.values, ox, oy, dx, dy, jstart, jend, istart, iend, cursize,
-                                                self.nullvalue, self.alpha, int(self.mypal.interval_cst))
+                                wolfogl.addmeall_pal(self.array, clr_float, self.mypal.values, ox, oy, dx, dy, jstart, jend, istart, iend, cursize,
+                                                self.nullvalue, self.alpha, int(self.mypal.interval_cst), -1.)
 
                 except Exception as e:
                     logging.error(repr(e))

wolfhece/wolfresults_2D.py

@@ -243,8 +243,13 @@ class Props_Res_2D(wx.Frame):
 
         self._cm_save = wx.Button(self._panel_colormap, wx.ID_ANY, _("Save to file"), wx.DefaultPosition, wx.DefaultSize, 0)
         self._cm_save.SetToolTip(_('Save colormap on .pal file'))
+
         self._cm_load = wx.Button(self._panel_colormap, wx.ID_ANY, _("Load from file"), wx.DefaultPosition, wx.DefaultSize, 0)
         self._cm_load.SetToolTip(_('Load colormap from .pal file'))
+
+        self._cm_default_pal = wx.Button(self._panel_colormap, wx.ID_ANY, _("Load precomputed"), wx.DefaultPosition, wx.DefaultSize, 0)
+        self._cm_default_pal.SetToolTip(_('Load a default colormap available in the software'))
+
         self._cm_toimage = wx.Button(self._panel_colormap, wx.ID_ANY, _("Create image"), wx.DefaultPosition, wx.DefaultSize, 0)
         self._cm_toimage.SetToolTip(_('Generate colormap image (horizontal, vertical or both) and save to disk'))
         self._cm_distribute = wx.Button(self._panel_colormap, wx.ID_ANY, _("Distribute"), wx.DefaultPosition, wx.DefaultSize, 0)
@@ -296,7 +301,14 @@ class Props_Res_2D(wx.Frame):
 
         self._panel_colormap.sizer.Add(self._cm_choose_color, 1, wx.EXPAND)
         self._panel_colormap.sizer.Add(self._cm_apply, 1, wx.EXPAND)
-        self._panel_colormap.sizer.Add(self._cm_load, 1, wx.EXPAND)
+
+        sizer_loadpal = wx.BoxSizer(wx.HORIZONTAL)
+
+        self._panel_colormap.sizer.Add(sizer_loadpal, 1, wx.EXPAND)
+
+        sizer_loadpal.Add(self._cm_load, 1, wx.EXPAND)
+        sizer_loadpal.Add(self._cm_default_pal, 1, wx.EXPAND)
+
         self._panel_colormap.sizer.Add(self._cm_save, 1, wx.EXPAND)
         self._panel_colormap.sizer.Add(self._cm_toimage, 1, wx.EXPAND)
         self._panel_colormap.sizer.Add(self._cm_distribute, 1 , wx.EXPAND)
@@ -636,7 +648,10 @@ class Props_Res_2D(wx.Frame):
         self._Apply_Tools.Bind(wx.EVT_BUTTON, self.OnApplyTools)
         self._cm_apply.Bind(wx.EVT_BUTTON, self.Onupdatepal)
         self._cm_save.Bind(wx.EVT_BUTTON, self.Onsavepal)
+
         self._cm_load.Bind(wx.EVT_BUTTON, self.Onloadpal)
+        self._cm_default_pal.Bind(wx.EVT_BUTTON, self.Onloaddefaultpal)
+
         self._cm_toimage.Bind(wx.EVT_BUTTON, self.Onpalimage)
         self._cm_distribute.Bind(wx.EVT_BUTTON, self.Onpaldistribute)
         self._cm_choose_color.Bind(wx.EVT_BUTTON, self.OnClickColorPal)
@@ -712,7 +727,7 @@ class Props_Res_2D(wx.Frame):
         # Fill the grid
         self._parent.mypal.fillgrid(self._cm_grid)
 
-    def Onsavepal(self, event):
+    def Onsavepal(self, event:wx.MouseEvent):
         """ Save the colormap to a file """
 
         self._parent.mypal.savefile()
@@ -728,6 +743,38 @@ class Props_Res_2D(wx.Frame):
         self._parent.set_currentview()
         self.update_palette()
 
+    def Onloaddefaultpal(self, event:wx.MouseEvent):
+        """ Load default palette """
+
+        import glob
+        from pathlib import Path
+
+        # list of all .pal file in model directory
+
+        dirpal = Path(__file__).parent / 'models'
+
+        listpal = glob.glob(str(dirpal) + '/*.pal')
+
+        if len(listpal) == 0:
+            logging.info('No default palette found')
+            return
+
+        listpal = [Path(i).name for i in listpal]
+
+        dlg = wx.SingleChoiceDialog(None, 'Choose the default palette', 'Default palette', listpal)
+        ret = dlg.ShowModal()
+
+        if ret == wx.ID_CANCEL:
+            dlg.Destroy()
+
+        self._parent.mypal.readfile(str(dirpal / dlg.GetStringSelection()))
+
+        self._parent.mypal.automatic = False
+        self._cm_auto.SetValue(0)
+        self.update_palette()
+
+        self._parent.set_currentview()
+
     def Onpalimage(self, event):
         """ Export the colormap to an image """
 
@@ -1722,6 +1769,18 @@ class OneWolfResult:
 
         self.mngselection = SelectionData(self._current)
 
+    def set_opacity(self, alpha:float):
+        """ Set the transparency of the array """
+
+        if alpha <0.:
+            alpha = 0.
+
+        if alpha > 1.:
+            alpha = 1.
+
+        self.alpha = alpha
+
+        return self.alpha
 
     @property
     def min_field_size(self):
@@ -2185,6 +2244,16 @@ class Wolfresults_2D(Element_To_Draw):
         self.myops = None
         self._active_blocks = 0
 
+
+    def set_opacity(self, alpha:float):
+        """ Set the transparency of the array """
+
+        self.alpha = alpha
+
+        self.reset_plot()
+
+        return self.alpha
+
     @property
     def SelectionData(self) -> SelectionDataMB:
         """ Return the data of the selection """
@@ -2352,6 +2421,13 @@ class Wolfresults_2D(Element_To_Draw):
 
     @alpha.setter
     def alpha(self, value:float):
+
+        if value <0.:
+            value = 0.
+
+        if value > 1.:
+            value = 1.
+
         for i in range(self.nb_blocks):
             self[i].alpha = value
 
@@ -4137,6 +4213,7 @@ class Wolfresults_2D(Element_To_Draw):
 
     def reset_plot(self,whichpal=0):
         """Reset du dessin"""
+
         self.delete_lists()
         self.get_working_array()
         self.updatepalette(whichpal)