wolfhece 2.1.38__py3-none-any.whl → 2.1.39__py3-none-any.whl

wolfhece/PyPalette.py

@@ -16,7 +16,7 @@ import numpy as np
 import numpy.ma as ma
 from bisect import bisect_left
 import matplotlib.pyplot as plt
-from matplotlib.colors import LinearSegmentedColormap,Normalize
+from matplotlib.colors import LinearSegmentedColormap, Normalize
 from collections import OrderedDict
 import typing
 import io
@@ -26,53 +26,54 @@ from .PyTranslate import _
 from .CpGrid import CpGrid
 from .PyVertex import getRGBfromI, getIfromRGB
 
-class wolfpalette(wx.Frame,LinearSegmentedColormap):
+
+class wolfpalette(wx.Frame, LinearSegmentedColormap):
     """
     Palette de couleurs basée sur l'objet "LinearSegmentedColormap" de Matplotlib (Colormap objects based on lookup tables using linear segments)
     """
-    filename:str
-    nb:int
-    colors:np.array
-    colorsflt:np.array
-    colorsuint8:np.array
+    filename: str
+    nb: int
+    colors: np.array
+    colorsflt: np.array
+    colorsuint8: np.array
 
-    def __init__(self, parent=None, title=_('Colormap'),w=100,h=500,nseg=1024):
+    def __init__(self, parent=None, title=_('Colormap'), w=100, h=500, nseg=1024):
 
-        self.filename=''
+        self.filename = ''
         self.nb = 0
         self.values = None
-        self.colormin = np.array([1.,1.,1.,1.])
-        self.colormax = np.array([0,0,0,1.])
-        self.nseg=nseg
+        self.colormin = np.array([1., 1., 1., 1.])
+        self.colormax = np.array([0, 0, 0, 1.])
+        self.nseg = nseg
         self.automatic = True
         self.interval_cst = False
 
         self.wx_exists = wx.App.Get() is not None
 
-        #Appel à l'initialisation d'un frame général
-        if(self.wx_exists):
-            wx.Frame.__init__(self, parent, title=title, size=(w,h),style=wx.DEFAULT_FRAME_STYLE)
+        # Appel à l'initialisation d'un frame général
+        if (self.wx_exists):
+            wx.Frame.__init__(self, parent, title=title, size=(w, h), style=wx.DEFAULT_FRAME_STYLE)
 
-        LinearSegmentedColormap.__init__(self,'wolf',{},nseg)
+        LinearSegmentedColormap.__init__(self, 'wolf', {}, nseg)
         self.set_bounds()
 
     @property
     def colormin_uint8(self):
         return self.colormin.astype(np.uint8)*255
-    
+
     @property
     def colormax_uint8(self):
         return self.colormax.astype(np.uint8)*255
 
     def get_colors_f32(self):
 
-        colors = self.colorsflt[:,:3].astype(np.float32)
+        colors = self.colorsflt[:, :3].astype(np.float32)
 
         return colors
-    
+
     def get_colors_uint8(self):
-            
-        colors = self.colorsflt[:,:3].astype(np.uint8) * 255
+
+        colors = self.colorsflt[:, :3].astype(np.uint8) * 255
 
         return colors
 
@@ -80,66 +81,71 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         self.set_under(tuple(self.colormin))
         self.set_over(tuple(self.colormax))
 
-    def get_rgba(self, x:np.ndarray):
+    def get_rgba(self, x: np.ndarray):
         """Récupération de la couleur en fonction de la valeur x"""
 
-        dval=self.values[-1]-self.values[0]
-        if dval==0.:
-            dval=1.
+        dval = self.values[-1]-self.values[0]
+        if dval == 0.:
+            dval = 1.
         xloc = (x-self.values[0])/dval
 
         if self.interval_cst:
-            rgba = np.ones((xloc.shape[0],xloc.shape[1],4), dtype=np.uint8)
+            rgba = np.ones((xloc.shape[0], xloc.shape[1], 4), dtype=np.uint8)
 
-            ij = np.where(xloc<0.)
-            rgba[ij[0],ij[1]] = self.colormin_uint8
-            ij = np.where(xloc>=1.)
-            rgba[ij[0],ij[1]] = self.colormax_uint8
+            ij = np.where(xloc < 0.)
+            rgba[ij[0], ij[1]] = self.colormin_uint8
+            ij = np.where(xloc >= 1.)
+            rgba[ij[0], ij[1]] = self.colormax_uint8
 
             for i in range(self.nb-1):
                 val1 = (self.values[i]-self.values[0])/dval
                 val2 = (self.values[i+1]-self.values[0])/dval
                 # c1   = self.colorsflt[i]
-                c1   = self.colorsuint8[i]
-                ij = np.where((xloc>=val1) & (xloc<val2))
-                rgba[ij[0],ij[1]] = c1
+                c1 = self.colorsuint8[i]
+                ij = np.where((xloc >= val1) & (xloc < val2))
+                rgba[ij[0], ij[1]] = c1
 
             return rgba
         else:
             return self(xloc, bytes=True)
 
-    def export_palette_matplotlib(self,name):
+    def export_palette_matplotlib(self, name):
         cmaps = OrderedDict()
         cmaps['Perceptually Uniform Sequential'] = ['viridis', 'plasma', 'inferno', 'magma', 'cividis']
 
-        cmaps['Sequential'] = ['Greys', 'Purples', 'Blues', 'Greens', 'Oranges', 'Reds','YlOrBr', 'YlOrRd', 'OrRd', 'PuRd', 'RdPu', 'BuPu','GnBu', 'PuBu', 'YlGnBu','PuBuGn', 'BuGn', 'YlGn']
-        cmaps['Sequential (2)'] = ['binary', 'gist_yarg', 'gist_gray', 'gray', 'bone', 'pink','spring', 'summer', 'autumn', 'winter', 'cool', 'Wistia','hot', 'afmhot', 'gist_heat', 'copper']
-        cmaps['Diverging'] = ['PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdGy', 'RdBu','RdYlBu', 'RdYlGn', 'Spectral', 'coolwarm', 'bwr', 'seismic']
+        cmaps['Sequential'] = ['Greys', 'Purples', 'Blues', 'Greens', 'Oranges', 'Reds', 'YlOrBr',
+                               'YlOrRd', 'OrRd', 'PuRd', 'RdPu', 'BuPu', 'GnBu', 'PuBu', 'YlGnBu', 'PuBuGn', 'BuGn', 'YlGn']
+        cmaps['Sequential (2)'] = ['binary', 'gist_yarg', 'gist_gray', 'gray', 'bone', 'pink', 'spring',
+                                   'summer', 'autumn', 'winter', 'cool', 'Wistia', 'hot', 'afmhot', 'gist_heat', 'copper']
+        cmaps['Diverging'] = ['PiYG', 'PRGn', 'BrBG', 'PuOr', 'RdGy', 'RdBu',
+                              'RdYlBu', 'RdYlGn', 'Spectral', 'coolwarm', 'bwr', 'seismic']
         cmaps['Cyclic'] = ['twilight', 'twilight_shifted', 'hsv']
-        cmaps['Qualitative'] = ['Pastel1', 'Pastel2', 'Paired', 'Accent','Dark2', 'Set1', 'Set2', 'Set3','tab10', 'tab20', 'tab20b', 'tab20c']
-        cmaps['Miscellaneous'] = ['flag', 'prism', 'ocean', 'gist_earth', 'terrain', 'gist_stern','gnuplot', 'gnuplot2', 'CMRmap', 'cubehelix', 'brg','gist_rainbow', 'rainbow', 'jet', 'nipy_spectral', 'gist_ncar']
+        cmaps['Qualitative'] = ['Pastel1', 'Pastel2', 'Paired', 'Accent',
+                                'Dark2', 'Set1', 'Set2', 'Set3', 'tab10', 'tab20', 'tab20b', 'tab20c']
+        cmaps['Miscellaneous'] = ['flag', 'prism', 'ocean', 'gist_earth', 'terrain', 'gist_stern', 'gnuplot',
+                                  'gnuplot2', 'CMRmap', 'cubehelix', 'brg', 'gist_rainbow', 'rainbow', 'jet', 'nipy_spectral', 'gist_ncar']
 
         for cmap_category, cmap_list in cmaps.items():
-            if(name in cmaps[cmap_category]):
-                self=plt.get_cmap(name)
-                self.nb=len(self._segmentdata['blue'])
-                self.values = np.linspace(0.,1.,self.nb)
-                self.colorsflt = np.zeros((self.nb,4) , dtype=float)
+            if (name in cmaps[cmap_category]):
+                self = plt.get_cmap(name)
+                self.nb = len(self._segmentdata['blue'])
+                self.values = np.linspace(0., 1., self.nb, dtype=np.float64)
+                self.colorsflt = np.zeros((self.nb, 4), dtype=np.float64)
                 for i in range(self.nb):
-                    self.colorsflt[i,0]=self._segmentdata['red'][i][2]
-                    self.colorsflt[i,1]=self._segmentdata['green'][i][2]
-                    self.colorsflt[i,2]=self._segmentdata['blue'][i][2]
-                    self.colorsflt[i,3]=self._segmentdata['alpha'][i][2]
-                test=1
+                    self.colorsflt[i, 0] = self._segmentdata['red'][i][2]
+                    self.colorsflt[i, 1] = self._segmentdata['green'][i][2]
+                    self.colorsflt[i, 2] = self._segmentdata['blue'][i][2]
+                    self.colorsflt[i, 3] = self._segmentdata['alpha'][i][2]
+                test = 1
                 break
             else:
-                test=1
+                test = 1
 
-        return self.nb,self.values,self._segmentdata,self.colorsflt
+        return self.nb, self.values, self._segmentdata, self.colorsflt
+
+    def distribute_values(self, minval: float = -99999, maxval: float = -99999, step=0, wx_permitted=True):
+        """ Distribution des valeurs de la palette
 
-    def distribute_values(self, minval:float=-99999, maxval:float=-99999, step=0, wx_permitted=True):
-        """ Distribution des valeurs de la palette 
-        
         :param minval: valeur minimale
         :param maxval: valeur maximale
         :param step: pas de distribution
@@ -149,31 +155,32 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         """
 
         if self.wx_exists and wx_permitted:
-            if minval==-99999:
-                dlg = wx.TextEntryDialog(None, _('Minimum value'), value = str(self.values[0]))
+            if minval == -99999:
+                dlg = wx.TextEntryDialog(None, _('Minimum value'), value=str(self.values[0]))
                 ret = dlg.ShowModal()
                 self.values[0] = dlg.GetValue()
                 dlg.Destroy()
             else:
                 self.values[0] = minval
 
-            if maxval==-99999 and step==0:
+            if maxval == -99999 and step == 0:
 
-                dlg = wx.MessageDialog(None, _('Would you like to set the incremental step value ?'),style= wx.YES_NO|wx.YES_DEFAULT)
+                dlg = wx.MessageDialog(None, _('Would you like to set the incremental step value ?'),
+                                       style=wx.YES_NO | wx.YES_DEFAULT)
                 ret = dlg.ShowModal()
                 dlg.Destroy
                 if ret == wx.ID_YES:
-                    dlg = wx.TextEntryDialog(None, _('Step value'), value = '1')
+                    dlg = wx.TextEntryDialog(None, _('Step value'), value='1')
                     ret = dlg.ShowModal()
                     step = float(dlg.GetValue())
                     dlg.Destroy()
                 else:
-                    dlg = wx.TextEntryDialog(None, _('Maximum value'), value = str(self.values[-1]))
+                    dlg = wx.TextEntryDialog(None, _('Maximum value'), value=str(self.values[-1]))
                     ret = dlg.ShowModal()
                     self.values[-1] = float(dlg.GetValue())
                     dlg.Destroy()
-            
-            elif maxval!=-99999:
+
+            elif maxval != -99999:
                 self.values[-1] = maxval
         else:
             if minval != -99999:
@@ -181,34 +188,35 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
             if maxval != -99999:
                 self.values[-1] = maxval
 
-        if step==0:
-            self.values = np.linspace(self.values[0], self.values[-1], num=self.nb, endpoint=True)[0:self.nb]
+        if step == 0:
+            self.values = np.linspace(self.values[0], self.values[-1], num=self.nb,
+                                      endpoint=True, dtype=np.float64)[0:self.nb]
         else:
-            self.values = np.arange(self.values[0], self.values[0]+(self.nb)*step, step)[0:self.nb]
+            self.values = np.arange(self.values[0], self.values[0]+(self.nb)*step, step, dtype=np.float64)[0:self.nb]
 
         self.fill_segmentdata()
 
-    def export_image(self,fn='',h_or_v:typing.Literal['h','v',''] ='', figax = None):
+    def export_image(self, fn='', h_or_v: typing.Literal['h', 'v', ''] = '', figax=None):
         """
         Export image from colormap
 
         :param : fn : filepath or io.BytesIO()
         :param : h_or_v : configuration to save 'h' = horizontal, 'v' = vertical, '' = both
         """
-        if fn=='':
-            file=wx.FileDialog(None,"Choose .pal file", wildcard="png (*.png)|*.png|all (*.*)|*.*",style=wx.FD_SAVE)
+        if fn == '':
+            file = wx.FileDialog(None, "Choose .pal file", wildcard="png (*.png)|*.png|all (*.*)|*.*", style=wx.FD_SAVE)
             if file.ShowModal() == wx.ID_CANCEL:
                 return
             else:
-                #récupération du nom de fichier avec chemin d'accès
-                fn =file.GetPath()
+                # récupération du nom de fichier avec chemin d'accès
+                fn = file.GetPath()
 
-        if h_or_v=='v':
+        if h_or_v == 'v':
             if figax is None:
-                fig,ax=plt.subplots(1,1)
+                fig, ax = plt.subplots(1, 1)
             else:
-                fig,ax = figax
-            plt.colorbar(ScalarMappable(Normalize(self.values[0],self.values[-1]),cmap=self),
+                fig, ax = figax
+            plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
                          cax=ax,
                          orientation='vertical',
                          extend='both',
@@ -218,29 +226,29 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
                          format='%.3f')
             plt.tick_params(labelsize=14)
             if figax is None:
-                fig.set_size_inches((2,10))
+                fig.set_size_inches((2, 10))
                 fig.tight_layout()
 
-            if fn!='' and fn is not None:
+            if fn != '' and fn is not None:
                 plt.savefig(fn, format='png')
             # plt.savefig(fn,bbox_inches='tight', format='png')
-        elif h_or_v=='h':
+        elif h_or_v == 'h':
             if figax is None:
-                fig,ax=plt.subplots(1,1)
+                fig, ax = plt.subplots(1, 1)
             else:
-                fig,ax = figax
-            plt.colorbar(ScalarMappable(Normalize(self.values[0],self.values[-1]),cmap=self),
+                fig, ax = figax
+            plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
                          cax=ax,
                          orientation='horizontal',
                          extend='both',
                          spacing='proportional',
                          ticks=self.values,
                          format='%.3f')
-            plt.tick_params(labelsize=14,rotation=45)
+            plt.tick_params(labelsize=14, rotation=45)
             if figax is None:
-                fig.set_size_inches((2,10))
+                fig.set_size_inches((2, 10))
                 fig.tight_layout()
-            if fn!='' and fn is not None:
+            if fn != '' and fn is not None:
                 plt.savefig(fn, format='png')
             # plt.savefig(fn,bbox_inches='tight', format='png')
         else:
@@ -249,10 +257,10 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
                 return
 
             if figax is None:
-                fig,ax=plt.subplots(1,1)
+                fig, ax = plt.subplots(1, 1)
             else:
-                fig,ax = figax
-            plt.colorbar(ScalarMappable(Normalize(self.values[0],self.values[-1]),cmap=self),
+                fig, ax = figax
+            plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
                          cax=ax,
                          orientation='vertical',
                          extend='both',
@@ -260,117 +268,117 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
                          ticks=self.values,
                          format='%.3f')
             plt.tick_params(labelsize=14)
-            fig.set_size_inches((2,10))
+            fig.set_size_inches((2, 10))
             fig.tight_layout()
-            if fn!='' and fn is not None:
+            if fn != '' and fn is not None:
                 plt.savefig(fn[:-4]+'_v.png', format='png')
 
             if figax is None:
-                fig,ax=plt.subplots(1,1)
+                fig, ax = plt.subplots(1, 1)
             else:
-                fig,ax = figax
+                fig, ax = figax
 
-            plt.colorbar(ScalarMappable(Normalize(self.values[0],self.values[-1]),cmap=self),
+            plt.colorbar(ScalarMappable(Normalize(self.values[0], self.values[-1]), cmap=self),
                          cax=ax,
                          orientation='horizontal',
                          extend='both',
                          spacing='proportional',
                          ticks=self.values,
                          format='%.3f')
-            plt.tick_params(labelsize=14,rotation=45)
-            fig.set_size_inches((10,2))
+            plt.tick_params(labelsize=14, rotation=45)
+            fig.set_size_inches((10, 2))
             fig.tight_layout()
-            if fn!='' and fn is not None:
+            if fn != '' and fn is not None:
                 plt.savefig(fn[:-4]+'_h.png', format='png')
 
-        return fig,ax
+        return fig, ax
 
-    def plot(self,fig:Figure,ax:plt.Axes):
+    def plot(self, fig: Figure, ax: plt.Axes):
         gradient = np.linspace(0, 1, 256)
         gradient = np.vstack((gradient, gradient))
         ax.imshow(gradient, aspect='auto', cmap=self)
         ax.set_yticklabels([])
 
-        pos=[]
-        txt=[]
+        pos = []
+        txt = []
 
-        dval=(self.values[-1]-self.values[0])
-        if dval==0.:
-            dval=1.
+        dval = (self.values[-1]-self.values[0])
+        if dval == 0.:
+            dval = 1.
 
         for curval in self.values:
             pos.append((curval-self.values[0])/dval*256.)
             txt.append("{0:.3f}".format(curval))
 
         ax.set_xticks(pos)
-        ax.set_xticklabels(txt,rotation=30,fontsize=6)
+        ax.set_xticklabels(txt, rotation=30, fontsize=6)
 
-    def fillgrid(self,gridto:CpGrid):
-        gridto.SetColLabelValue(0,'Value')
-        gridto.SetColLabelValue(1,'R')
-        gridto.SetColLabelValue(2,'G')
-        gridto.SetColLabelValue(3,'B')
+    def fillgrid(self, gridto: CpGrid):
+        gridto.SetColLabelValue(0, 'Value')
+        gridto.SetColLabelValue(1, 'R')
+        gridto.SetColLabelValue(2, 'G')
+        gridto.SetColLabelValue(3, 'B')
 
-        nb=gridto.GetNumberRows()
-        if len(self.values)-nb>0:
+        nb = gridto.GetNumberRows()
+        if len(self.values)-nb > 0:
             gridto.AppendRows(len(self.values)-nb)
 
-        k=0
-        for curv,rgba in zip(self.values,self.colors):
-            gridto.SetCellValue(k,0,str(curv))
-            gridto.SetCellValue(k,1,str(rgba[0]))
-            gridto.SetCellValue(k,2,str(rgba[1]))
-            gridto.SetCellValue(k,3,str(rgba[2]))
-            k+=1
+        k = 0
+        for curv, rgba in zip(self.values, self.colors):
+            gridto.SetCellValue(k, 0, str(curv))
+            gridto.SetCellValue(k, 1, str(rgba[0]))
+            gridto.SetCellValue(k, 2, str(rgba[1]))
+            gridto.SetCellValue(k, 3, str(rgba[2]))
+            k += 1
 
         nb = gridto.GetNumberRows()
-        while k<nb:
-            gridto.SetCellValue(k,0,'')
-            gridto.SetCellValue(k,1,'')
-            gridto.SetCellValue(k,2,'')
-            gridto.SetCellValue(k,3,'')
-            k+=1
+        while k < nb:
+            gridto.SetCellValue(k, 0, '')
+            gridto.SetCellValue(k, 1, '')
+            gridto.SetCellValue(k, 2, '')
+            gridto.SetCellValue(k, 3, '')
+            k += 1
 
-    def updatefromgrid(self,gridfrom:CpGrid):
-        nbl=gridfrom.GetNumberRows()
+    def updatefromgrid(self, gridfrom: CpGrid):
+        nbl = gridfrom.GetNumberRows()
 
         for i in range(nbl):
-            if gridfrom.GetCellValue(i,0) =='':
-                nbl=i-1
+            if gridfrom.GetCellValue(i, 0) == '':
+                nbl = i-1
                 break
 
         if i < self.nb:
             self.nb = i
-            self.values=self.values[0:i]
-            self.colors=self.colors[0:i,:]
+            self.values = self.values[0:i]
+            self.colors = self.colors[0:i, :]
         else:
             self.nb = i
             oldvalues = self.values
             oldcolors = self.colors
-            self.values = np.zeros(self.nb , dtype=float)
-            self.colors = np.zeros((self.nb,4) , dtype=int)
+            self.values = np.zeros(self.nb, dtype=np.float64)
+            self.colors = np.zeros((self.nb, 4), dtype=int)
             self.values[0:len(oldvalues)] = oldvalues
-            self.colors[0:len(oldcolors),:] = oldcolors
+            self.colors[0:len(oldcolors), :] = oldcolors
 
         update = False
 
         for k in range(self.nb):
 
-            update = update or self.values[k]!=float(gridfrom.GetCellValue(k,0))
-            update = update or self.colors[k,0]!=float(gridfrom.GetCellValue(k,1))
-            update = update or self.colors[k,1]!=float(gridfrom.GetCellValue(k,2))
-            update = update or self.colors[k,2]!=float(gridfrom.GetCellValue(k,3))
+            update = update or self.values[k] != float(gridfrom.GetCellValue(k, 0))
+            update = update or self.colors[k, 0] != float(gridfrom.GetCellValue(k, 1))
+            update = update or self.colors[k, 1] != float(gridfrom.GetCellValue(k, 2))
+            update = update or self.colors[k, 2] != float(gridfrom.GetCellValue(k, 3))
 
-            self.values[k]=float(gridfrom.GetCellValue(k,0))
-            self.colors[k,0]=int(gridfrom.GetCellValue(k,1))
-            self.colors[k,1]=int(gridfrom.GetCellValue(k,2))
-            self.colors[k,2]=int(gridfrom.GetCellValue(k,3))
+            self.values[k] = float(gridfrom.GetCellValue(k, 0))
+            self.colors[k, 0] = int(gridfrom.GetCellValue(k, 1))
+            self.colors[k, 1] = int(gridfrom.GetCellValue(k, 2))
+            self.colors[k, 2] = int(gridfrom.GetCellValue(k, 3))
 
         self.fill_segmentdata()
 
         return update
 
-    def updatefrompalette(self,srcpal):
+    def updatefrompalette(self, srcpal):
         """
         Mise à jour de la palette sur base d'une autre
 
@@ -378,131 +386,137 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         """
 
         for k in range(len(srcpal.values)):
-            self.values[k]=srcpal.values[k]
+            self.values[k] = srcpal.values[k]
 
         self.fill_segmentdata()
 
-    def lookupcolor(self,x):
-        if x < self.values[0]:  return wx.Colour(self.colormin)
-        if x > self.values[-1]: return wx.Colour(self.colormax)
+    def lookupcolor(self, x):
+        if x < self.values[0]:
+            return wx.Colour(self.colormin)
+        if x > self.values[-1]:
+            return wx.Colour(self.colormax)
 
         i = bisect_left(self.values, x)
         k = (x - self.values[i-1])/(self.values[i] - self.values[i-1])
 
-        r=int(k*(float(self.colors[i,0]-self.colors[i-1,0]))) + self.colors[i-1,0]
-        g=int(k*(float(self.colors[i,1]-self.colors[i-1,1]))) + self.colors[i-1,1]
-        b=int(k*(float(self.colors[i,2]-self.colors[i-1,2]))) + self.colors[i-1,2]
-        a=int(k*(float(self.colors[i,3]-self.colors[i-1,3]))) + self.colors[i-1,3]
+        r = int(k*(float(self.colors[i, 0]-self.colors[i-1, 0]))) + self.colors[i-1, 0]
+        g = int(k*(float(self.colors[i, 1]-self.colors[i-1, 1]))) + self.colors[i-1, 1]
+        b = int(k*(float(self.colors[i, 2]-self.colors[i-1, 2]))) + self.colors[i-1, 2]
+        a = int(k*(float(self.colors[i, 3]-self.colors[i-1, 3]))) + self.colors[i-1, 3]
 
-        y = wx.Colour(r,g,b,a)
+        y = wx.Colour(r, g, b, a)
 
         return y
 
-    def lookupcolorflt(self,x):
-        if x < self.values[0]:  return wx.Colour(self.colormin)
-        if x > self.values[-1]: return wx.Colour(self.colormax)
+    def lookupcolorflt(self, x):
+        if x < self.values[0]:
+            return wx.Colour(self.colormin)
+        if x > self.values[-1]:
+            return wx.Colour(self.colormax)
 
         i = bisect_left(self.values, x)
         k = (x - self.values[i-1])/(self.values[i] - self.values[i-1])
 
-        r=k*(self.colorsflt[i,0]-self.colorsflt[i-1,0]) + self.colorsflt[i-1,0]
-        g=k*(self.colorsflt[i,1]-self.colorsflt[i-1,1]) + self.colorsflt[i-1,1]
-        b=k*(self.colorsflt[i,2]-self.colorsflt[i-1,2]) + self.colorsflt[i-1,2]
-        a=k*(self.colorsflt[i,3]-self.colorsflt[i-1,3]) + self.colorsflt[i-1,3]
+        r = k*(self.colorsflt[i, 0]-self.colorsflt[i-1, 0]) + self.colorsflt[i-1, 0]
+        g = k*(self.colorsflt[i, 1]-self.colorsflt[i-1, 1]) + self.colorsflt[i-1, 1]
+        b = k*(self.colorsflt[i, 2]-self.colorsflt[i-1, 2]) + self.colorsflt[i-1, 2]
+        a = k*(self.colorsflt[i, 3]-self.colorsflt[i-1, 3]) + self.colorsflt[i-1, 3]
 
-        y=[r,g,b,a]
+        y = [r, g, b, a]
         return y
 
-    def lookupcolorrgb(self,x):
-        if x < self.values[0]:  return wx.Colour(self.colormin)
-        if x > self.values[-1]: return wx.Colour(self.colormax)
+    def lookupcolorrgb(self, x):
+        if x < self.values[0]:
+            return wx.Colour(self.colormin)
+        if x > self.values[-1]:
+            return wx.Colour(self.colormax)
 
         i = bisect_left(self.values, x)
         k = (x - self.values[i-1])/(self.values[i] - self.values[i-1])
 
-        r=int(k*(float(self.colors[i,0]-self.colors[i-1,0]))) + self.colors[i-1,0]
-        g=int(k*(float(self.colors[i,1]-self.colors[i-1,1]))) + self.colors[i-1,1]
-        b=int(k*(float(self.colors[i,2]-self.colors[i-1,2]))) + self.colors[i-1,2]
-        a=int(k*(float(self.colors[i,3]-self.colors[i-1,3]))) + self.colors[i-1,3]
+        r = int(k*(float(self.colors[i, 0]-self.colors[i-1, 0]))) + self.colors[i-1, 0]
+        g = int(k*(float(self.colors[i, 1]-self.colors[i-1, 1]))) + self.colors[i-1, 1]
+        b = int(k*(float(self.colors[i, 2]-self.colors[i-1, 2]))) + self.colors[i-1, 2]
+        a = int(k*(float(self.colors[i, 3]-self.colors[i-1, 3]))) + self.colors[i-1, 3]
 
-        return r,g,b,a
+        return r, g, b, a
 
     def default16(self):
         """Palette 16 coulrurs par défaut dans WOLF"""
 
-        self.nb=16
-        self.values = np.linspace(0.,1.,16)
-        self.colors = np.zeros((self.nb,4) , dtype=int)
-        self.colorsflt = np.zeros((self.nb,4) , dtype=float)
-
-        self.colors[0,:] = [128,255,255,255]
-        self.colors[1,:] = [89,172,255,255]
-        self.colors[2,:] = [72,72,255,255]
-        self.colors[3,:] = [0,0,255,255]
-        self.colors[4,:] = [0,128,0,255]
-        self.colors[5,:] = [0,221,55,255]
-        self.colors[6,:] = [128,255,128,255]
-        self.colors[7,:] = [255,255,0,255]
-        self.colors[8,:] = [255,128,0,255]
-        self.colors[9,:] = [235,174,63,255]
-        self.colors[10,:] = [255,0,0,255]
-        self.colors[11,:] = [209,71,12,255]
-        self.colors[12,:] = [128,0,0,255]
-        self.colors[13,:] = [185,0,0,255]
-        self.colors[14,:] = [111,111,111,255]
-        self.colors[15,:] = [192,192,192,255]
+        self.nb = 16
+        self.values = np.linspace(0., 1., 16, dtype=np.float64)
+        self.colors = np.zeros((self.nb, 4), dtype=int)
+        self.colorsflt = np.zeros((self.nb, 4), dtype=np.float64)
+
+        self.colors[0, :] = [128, 255, 255, 255]
+        self.colors[1, :] = [89, 172, 255, 255]
+        self.colors[2, :] = [72, 72, 255, 255]
+        self.colors[3, :] = [0, 0, 255, 255]
+        self.colors[4, :] = [0, 128, 0, 255]
+        self.colors[5, :] = [0, 221, 55, 255]
+        self.colors[6, :] = [128, 255, 128, 255]
+        self.colors[7, :] = [255, 255, 0, 255]
+        self.colors[8, :] = [255, 128, 0, 255]
+        self.colors[9, :] = [235, 174, 63, 255]
+        self.colors[10, :] = [255, 0, 0, 255]
+        self.colors[11, :] = [209, 71, 12, 255]
+        self.colors[12, :] = [128, 0, 0, 255]
+        self.colors[13, :] = [185, 0, 0, 255]
+        self.colors[14, :] = [111, 111, 111, 255]
+        self.colors[15, :] = [192, 192, 192, 255]
 
         self.fill_segmentdata()
 
     def set_values_colors(self,
-                          values:typing.Union[list[float], np.ndarray],
-                          colors:typing.Union[list[tuple[int]], np.ndarray]):
+                          values: typing.Union[list[float], np.ndarray],
+                          colors: typing.Union[list[tuple[int]], np.ndarray]):
         """ Mise à jour des valeurs et couleurs de la palette """
 
         assert len(values) == len(colors), "Length of values and colors must be the same"
         assert len(values) > 1, "At least 2 values are required"
-        assert len(colors[0]) in [3,4], "Colors must be in RGB or RGBA format"
+        assert len(colors[0]) in [3, 4], "Colors must be in RGB or RGBA format"
 
         self.nb = len(values)
-        self.values = np.asarray(values)
+        self.values = np.asarray(values, dtype=np.float64)
 
-        self.colors = np.zeros((self.nb,4) , dtype=int)
-        self.colorsflt = np.zeros((self.nb,4) , dtype=float)
+        self.colors = np.zeros((self.nb, 4), dtype=int)
+        self.colorsflt = np.zeros((self.nb, 4), dtype=np.float64)
 
         if isinstance(colors, list):
             if len(colors[0]) == 3:
                 for curcol in range(self.nb):
-                    self.colors[curcol,0] = colors[curcol][0]
-                    self.colors[curcol,1] = colors[curcol][1]
-                    self.colors[curcol,2] = colors[curcol][2]
-                    self.colors[curcol,3] = 255
+                    self.colors[curcol, 0] = colors[curcol][0]
+                    self.colors[curcol, 1] = colors[curcol][1]
+                    self.colors[curcol, 2] = colors[curcol][2]
+                    self.colors[curcol, 3] = 255
             elif len(colors[0]) == 4:
                 for curcol in range(self.nb):
-                    self.colors[curcol,0] = colors[curcol][0]
-                    self.colors[curcol,1] = colors[curcol][1]
-                    self.colors[curcol,2] = colors[curcol][2]
-                    self.colors[curcol,3] = colors[curcol][3]
+                    self.colors[curcol, 0] = colors[curcol][0]
+                    self.colors[curcol, 1] = colors[curcol][1]
+                    self.colors[curcol, 2] = colors[curcol][2]
+                    self.colors[curcol, 3] = colors[curcol][3]
         elif isinstance(colors, np.ndarray):
             if colors.shape[1] == 3:
                 for curcol in range(self.nb):
-                    self.colors[curcol,0] = colors[curcol,0]
-                    self.colors[curcol,1] = colors[curcol,1]
-                    self.colors[curcol,2] = colors[curcol,2]
-                    self.colors[curcol,3] = 255
+                    self.colors[curcol, 0] = colors[curcol, 0]
+                    self.colors[curcol, 1] = colors[curcol, 1]
+                    self.colors[curcol, 2] = colors[curcol, 2]
+                    self.colors[curcol, 3] = 255
             elif colors.shape[1] == 4:
                 for curcol in range(self.nb):
-                    self.colors[curcol,0] = colors[curcol,0]
-                    self.colors[curcol,1] = colors[curcol,1]
-                    self.colors[curcol,2] = colors[curcol,2]
-                    self.colors[curcol,3] = colors[curcol,3]
-        
+                    self.colors[curcol, 0] = colors[curcol, 0]
+                    self.colors[curcol, 1] = colors[curcol, 1]
+                    self.colors[curcol, 2] = colors[curcol, 2]
+                    self.colors[curcol, 3] = colors[curcol, 3]
+
         self.fill_segmentdata()
 
     def defaultgray(self):
         """Palette grise par défaut dans WOLF"""
-        self.nb=2
-        self.values = np.asarray([0.,1.])
-        self.colors = np.asarray([[0,0,0,255],[255,255,255,255]],dtype=np.int32)
+        self.nb = 2
+        self.values = np.asarray([0., 1.], dtype=np.float64)
+        self.colors = np.asarray([[0, 0, 0, 255], [255, 255, 255, 255]], dtype=np.int32)
 
         self.fill_segmentdata()
 
@@ -512,89 +526,89 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         self.colorsflt = self.colors.astype(float)/255.
         self.colorsuint8 = self.colors.astype(np.uint8)
 
-        dval=self.values[-1]-self.values[0]
+        dval = self.values[-1]-self.values[0]
 
         normval = np.ones([len(self.values)])
 
-        if dval>0.:
+        if dval > 0.:
             normval = (self.values-self.values[0])/(self.values[-1]-self.values[0])
 
-        normval[0]=0.
-        normval[-1]=1.
-        segmentdata = {"red": np.column_stack([normval, self.colorsflt[:,0], self.colorsflt[:,0]]),
-                             "green": np.column_stack([normval, self.colorsflt[:,1], self.colorsflt[:,1]]),
-                             "blue": np.column_stack([normval, self.colorsflt[:,2], self.colorsflt[:,2]]),
-                             "alpha": np.column_stack([normval, self.colorsflt[:,3], self.colorsflt[:,3]])}
+        normval[0] = 0.
+        normval[-1] = 1.
+        segmentdata = {"red": np.column_stack([normval, self.colorsflt[:, 0], self.colorsflt[:, 0]]),
+                       "green": np.column_stack([normval, self.colorsflt[:, 1], self.colorsflt[:, 1]]),
+                       "blue": np.column_stack([normval, self.colorsflt[:, 2], self.colorsflt[:, 2]]),
+                       "alpha": np.column_stack([normval, self.colorsflt[:, 3], self.colorsflt[:, 3]])}
 
-        LinearSegmentedColormap.__init__(self,'wolf',segmentdata,self.nseg)
+        LinearSegmentedColormap.__init__(self, 'wolf', segmentdata, self.nseg)
 
-    def readfile(self,*args):
+    def readfile(self, *args):
         """Lecture de la palette sur base d'un fichier WOLF .pal"""
-        if len(args)>0:
-            #s'il y a un argument on le prend tel quel
+        if len(args) > 0:
+            # s'il y a un argument on le prend tel quel
             self.filename = str(args[0])
         else:
             if self.wx_exists:
-                #ouverture d'une boîte de dialogue
-                file=wx.FileDialog(None,"Choose .pal file", wildcard="pal (*.pal)|*.pal|all (*.*)|*.*")
+                # ouverture d'une boîte de dialogue
+                file = wx.FileDialog(None, "Choose .pal file", wildcard="pal (*.pal)|*.pal|all (*.*)|*.*")
                 if file.ShowModal() == wx.ID_CANCEL:
                     file.Destroy()
                     return
                 else:
-                    #récuparétaion du nom de fichier avec chemin d'accès
-                    self.filename =file.GetPath()
+                    # récuparétaion du nom de fichier avec chemin d'accès
+                    self.filename = file.GetPath()
                     file.Destroy()
             else:
                 return
 
-        #lecture du contenu
+        # lecture du contenu
         with open(self.filename, 'r') as myfile:
-            #split des lignes --> récupération des infos sans '\n' en fin de ligne
+            # split des lignes --> récupération des infos sans '\n' en fin de ligne
             #  différent de .readlines() qui lui ne supprime pas les '\n'
             mypallines = myfile.read().splitlines()
             myfile.close()
 
             self.nb = int(mypallines[0])
-            self.values = np.zeros(self.nb , dtype=float)
-            self.colors = np.zeros((self.nb,4) , dtype=int)
+            self.values = np.zeros(self.nb, dtype=np.float64)
+            self.colors = np.zeros((self.nb, 4), dtype=int)
 
             for i in range(self.nb):
                 self.values[i] = mypallines[i*4+1]
-                self.colors[i,0] = mypallines[i*4+2]
-                self.colors[i,1] = mypallines[i*4+3]
-                self.colors[i,2] = mypallines[i*4+4]
-                self.colors[i,3] = 255
+                self.colors[i, 0] = mypallines[i*4+2]
+                self.colors[i, 1] = mypallines[i*4+3]
+                self.colors[i, 2] = mypallines[i*4+4]
+                self.colors[i, 3] = 255
 
         self.fill_segmentdata()
 
-    def savefile(self,*args):
+    def savefile(self, *args):
         """Lecture de la palette sur base d'un fichier WOLF .pal"""
-        if len(args)>0:
-            #s'il y a un argument on le prend tel quel
+        if len(args) > 0:
+            # s'il y a un argument on le prend tel quel
             fn = str(args[0])
         else:
-            #ouverture d'une boîte de dialogue
-            file=wx.FileDialog(None,"Choose .pal file", wildcard="pal (*.pal)|*.pal|all (*.*)|*.*",style=wx.FD_SAVE)
+            # ouverture d'une boîte de dialogue
+            file = wx.FileDialog(None, "Choose .pal file", wildcard="pal (*.pal)|*.pal|all (*.*)|*.*", style=wx.FD_SAVE)
             if file.ShowModal() == wx.ID_CANCEL:
                 return
             else:
-                #récuparétaion du nom de fichier avec chemin d'accès
-                fn =file.GetPath()
+                # récuparétaion du nom de fichier avec chemin d'accès
+                fn = file.GetPath()
 
-        self.filename=fn
+        self.filename = fn
 
-        #lecture du contenu
+        # lecture du contenu
         with open(self.filename, 'w') as myfile:
-            #split des lignes --> récupération des infos sans '\n' en fin de ligne
+            # split des lignes --> récupération des infos sans '\n' en fin de ligne
             #  différent de .readlines() qui lui ne supprime pas les '\n'
             myfile.write(str(self.nb)+'\n')
             for i in range(self.nb):
                 myfile.write(str(self.values[i])+'\n')
-                myfile.write(str(self.colors[i,0])+'\n')
-                myfile.write(str(self.colors[i,1])+'\n')
-                myfile.write(str(self.colors[i,2])+'\n')
+                myfile.write(str(self.colors[i, 0])+'\n')
+                myfile.write(str(self.colors[i, 1])+'\n')
+                myfile.write(str(self.colors[i, 2])+'\n')
 
-    def isopop(self, array: ma.masked_array, nbnotnull:int=99999):
+    def isopop(self, array: ma.masked_array, nbnotnull: int = 99999):
         """Remplissage des valeurs de palette sur base d'une équirépartition de valeurs"""
 
         sortarray = array.flatten(order='F')
@@ -607,7 +621,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
 
         sortarray.sort(axis=-1)
 
-        #valeurs min et max
+        # valeurs min et max
         if nbnotnull == 0:
             self.values[0] = 0
             self.values[1:] = 1
@@ -617,7 +631,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
 
             self.values[0] = sortarray[0]
 
-            if(nbnotnull==99999):
+            if (nbnotnull == 99999):
                 self.values[-1] = sortarray[-1]
                 nb = sortarray.count()
             else:
@@ -625,41 +639,41 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
                 nb = nbnotnull
 
             interv = int(nb / (self.nb-1))
-            if interv==0:
+            if interv == 0:
                 self.values[:] = self.values[-1]
                 self.values[0] = self.values[-1]-1.
             else:
-                for cur in range(1,self.nb-1):
+                for cur in range(1, self.nb-1):
                     self.values[cur] = sortarray[cur * interv]
 
         self.fill_segmentdata()
 
-    def defaultgray_minmax(self,array: ma.masked_array,nbnotnull=99999):
+    def defaultgray_minmax(self, array: ma.masked_array, nbnotnull=99999):
         """Remplissage des valeurs de palette sur base d'une équirépartition de valeurs"""
 
-        self.nb=2
-        self.values = np.asarray([np.min(array),np.max(array)])
-        self.colors = np.asarray([[0,0,0,255],[255,255,255,255]],dtype=np.int32)
-        self.colorsflt = np.asarray([[0.,0.,0.,1.],[1.,1.,1.,1.]],dtype=np.float64)
+        self.nb = 2
+        self.values = np.asarray([np.min(array), np.max(array)], dtype=np.float64)
+        self.colors = np.asarray([[0, 0, 0, 255], [255, 255, 255, 255]], dtype=np.int32)
+        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
 
         self.fill_segmentdata()
 
-    def defaultblue_minmax(self,array: ma.masked_array,nbnotnull=99999):
+    def defaultblue_minmax(self, array: ma.masked_array, nbnotnull=99999):
         """Remplissage des valeurs de palette sur base d'une équirépartition de valeurs"""
 
-        self.nb=2
-        self.values = np.asarray([np.min(array),np.max(array)])
-        self.colors = np.asarray([[255,255,255,255],[0,0,255,255]],dtype=np.int32)
-        self.colorsflt = np.asarray([[0.,0.,0.,1.],[1.,1.,1.,1.]],dtype=np.float64)
+        self.nb = 2
+        self.values = np.asarray([np.min(array), np.max(array)], dtype=np.float64)
+        self.colors = np.asarray([[255, 255, 255, 255], [0, 0, 255, 255]], dtype=np.int32)
+        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
 
         self.fill_segmentdata()
 
     def defaultblue(self):
         """Remplissage des valeurs de palette sur base d'une équirépartition de valeurs"""
 
-        self.nb=2
-        self.values = np.asarray([0.,1.])
-        self.colors = np.asarray([[255,255,255,255],[0,0,255,255]],dtype=np.int32)
-        self.colorsflt = np.asarray([[0.,0.,0.,1.],[1.,1.,1.,1.]],dtype=np.float64)
+        self.nb = 2
+        self.values = np.asarray([0., 1.], dtype=np.float64)
+        self.colors = np.asarray([[255, 255, 255, 255], [0, 0, 255, 255]], dtype=np.int32)
+        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
 
         self.fill_segmentdata()

wolfhece/apps/splashscreen.py

@@ -19,7 +19,7 @@ from   wx.adv import SplashScreen as SplashScreen,SPLASH_CENTRE_ON_SCREEN,SPLASH
 
 try:
     from ..libs import wolfogl
-except:
+except ImportError:
     print("** WolfOGL not found **")
     print("Without WolfOGL, the application will not work !")
     print("Please reinstall 'wolfhece' package -- pip install wolfhece --force-reinstall")
@@ -38,7 +38,7 @@ class WolfLauncher(SplashScreen):
 
         # try:
         #     wolfogl.init()
-        # except Exception as e:
+        # except ImportError:
         #     print("Error initializing WolfOGL -- We must stop here !")
         #     print("Please reinstall 'wolfhece' package -- pip install wolfhece")
         #     exit()

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 38
+        self.patch = 39
 
     def __str__(self):
 

wolfhece/pyviews.py

@@ -181,17 +181,21 @@ class WolfViews(Element_To_Draw):
 
         if self.plotted:
 
-            for cur,pal in zip(self.view,self.pals):
+            for cur, pal in zip(self.view, self.pals):
                 oldplotted = cur.plotted
                 cur.plotted=True
 
                 if isinstance(cur,WolfArray):
-                    if cur.rgb is None:
-                        if pal is not None:
-                            if VERSION_RGB ==1: cur.rgb = pal.get_rgba(cur.array)
-                        else:
+                    if VERSION_RGB ==1:
+                        if cur.rgb is None:
+                            if pal is not None:
+                                cur.rgb = pal.get_rgba(cur.array)
+                            else:
+                                cur.mypal.defaultgray_minmax(cur.array)
+                                cur.rgb = cur.mypal.get_rgba(cur.array)
+                    elif VERSION_RGB == 2:
+                        if pal is None:
                             cur.mypal.defaultgray_minmax(cur.array)
-                            if VERSION_RGB ==1: cur.rgb = cur.mypal.get_rgba(cur.array)
 
                 cur.plot(sx,sy,xmin,ymin,xmax,ymax)
                 cur.plotted = oldplotted

wolfhece/wolf_array.py

@@ -53,7 +53,7 @@ from .drawing_obj import Element_To_Draw
 
 try:
     from .libs import wolfogl
-except:
+except ImportError:
     msg=_('Error importing wolfogl.pyd')
     msg+=_('   Python version : ' + sys.version)
     msg+=_('   If your Python version is not 3.10.x, you need to get an adapted library in wolfhece library path libs')
@@ -4163,7 +4163,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                  create:bool        = False,
                  mapviewer          = None,
                  nullvalue:float    = 0.,
-                 srcheader:header_wolf  = None,
+                 srcheader:header_wolf = None,
                  idx:str            = '',
                  plotted:bool       = False,
                  need_for_wx:bool   = False,
@@ -4173,7 +4173,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         Constructor of the WolfArray class
 
         :param fname: filename/filepath - if provided, the file will be read on disk
-        :param mold: initialize from a copy a the mold object --> must be a WolArray
+        :param mold: initialize from a copy a the mold object --> must be a WolArray if not None
         :param masknull: mask data based on the nullvalue
         :param crop: crop data based on the spatial extent [[xmin, xmax],[ymin,ymax]]
         :param whichtype: type of the numpy array (float32 as default)
@@ -4188,7 +4188,11 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param mask_source: mask to link to the data
 
         """
-        # wolfogl.powermode('ON')
+        try:
+            pass
+            # wolfogl.powermode('ON')
+        except PermissionError:
+            print(_('wolfogl not available -- Pleas check your wolfhece installation'))
 
         Element_To_Draw.__init__(self, idx, plotted, mapviewer, need_for_wx)
         header_wolf.__init__(self)
@@ -6182,6 +6186,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             newArray.array = np.ma.masked_array(self.array + other.array, self.array.mask)
         newArray.count()
+
+        assert newArray.array.dtype == self.array.dtype, _('Bad dtype')
+
         return newArray
 
     def __mul__(self, other):
@@ -6208,6 +6215,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             newArray.array = np.ma.masked_array(self.array * other.array, self.array.mask)
         newArray.count()
+
+        assert newArray.array.dtype == self.array.dtype, _('Bad dtype')
+
         return newArray
 
     def __sub__(self, other):
@@ -6234,6 +6244,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             newArray.array = np.ma.masked_array(self.array - other.array, self.array.mask)
         newArray.count()
+
+        assert newArray.array.dtype == self.array.dtype, _('Bad dtype')
+
         return newArray
 
     def __pow__(self, other):
@@ -6256,6 +6269,9 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         newArray.array = np.ma.masked_array(self.array ** other, self.array.mask)
         newArray.count()
+
+        assert newArray.array.dtype == self.array.dtype, _('Bad dtype')
+
         return newArray
 
     def __truediv__(self, other):
@@ -6282,6 +6298,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             newArray.array = np.ma.masked_array(np.where(other == 0., 0., self.array / other.array), self.array.mask)
         newArray.count()
+
+        assert newArray.array.dtype == self.array.dtype, _('Bad dtype')
+
         return newArray
 
     def concatenate(self, list_arr:list["WolfArray"], nullvalue:float = 0.):

wolfhece/wolfresults_2D.py

@@ -1787,14 +1787,20 @@ class OneWolfResult:
             self._current.rgb = curpal.get_rgba(self._current.array)
             self._current.rgb[self._current.array.mask] = [1., 1., 1., 1.]
 
-        if which == 'wd_u':
-            self._view.pals = [bluepal,curpal]
-        elif which =='t_wl_q':
-            self._view.pals = [graypal,curpal,None]
-        elif which =='t_wd_q':
-            self._view.pals = [graypal,bluepal,None]
-        elif which =='t_wd_u':
-            self._view.pals = [graypal,bluepal,None]
+        if which in [views_2D.WD_Q, views_2D.WD_U]:
+            self._view.pals = [curpal, None]
+        elif which in [views_2D.WL_U, views_2D.WL_Q]:
+            self._view.pals = [curpal, None]
+
+        elif which == views_2D.T_WL_Q:
+            self._view.pals = [graypal, curpal, None]
+        elif which == views_2D.T_WL_Q:
+            self._view.pals = [graypal, curpal, None]
+
+        elif which == views_2D.T_WD_Q:
+            self._view.pals = [graypal, bluepal, None]
+        elif which == views_2D.T_WD_U:
+            self._view.pals = [graypal, bluepal, None]
 
     def get_critdiam(self, which:int) -> WolfArray:
         """

{wolfhece-2.1.38.dist-info → wolfhece-2.1.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.38
+Version: 2.1.39
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece

{wolfhece-2.1.38.dist-info → wolfhece-2.1.39.dist-info}/RECORD

@@ -10,7 +10,7 @@ wolfhece/PyDraw.py,sha256=MQO149Cp8QtxWceXpKWLsDbE6JBrVbqEWoAOXWfHl2w,390751
 wolfhece/PyGui.py,sha256=_1LKelusQ-FS0AtgpwFiXKMZ2glky7K1WINTI93H0k0,103438
 wolfhece/PyGuiHydrology.py,sha256=f60E8K9eGTnRq5RDF6yvt-ahf2AYegwQ9t25zZ2Mk1A,14946
 wolfhece/PyHydrographs.py,sha256=jwtSNMMACwarxrtN1UeQYth99UNrhwPx1IGgUwcooHA,3774
-wolfhece/PyPalette.py,sha256=lqWd-jZkEyYeeAyaiIaGZq_bxXRiiMhDXN68QYoVCfU,26181
+wolfhece/PyPalette.py,sha256=uxibQSz5u1q8bgZv-VId6o_SI5TTfLHPs9DpJomVwSA,27179
 wolfhece/PyParams.py,sha256=wwgmP-_7wiiPLTcyX8a5jR6FyC1D2c4oBPc1VWQqtSA,97383
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
@@ -42,18 +42,18 @@ wolfhece/pydike.py,sha256=hPBQsmSTW4QAp1wcOzb-TL3L7eet2WT1sJx2q-WNQ-Q,2241
 wolfhece/pylogging.py,sha256=4TI8hgBB65z-zpvU5Rfa2jkPXPhJaqXjHVPwbcdzTNc,4528
 wolfhece/pypolygons_scen.py,sha256=x-tnYLNq3MPV51NbaU14trgRj8qyUyOrMdF1zDsUX3I,37444
 wolfhece/pyshields.py,sha256=7k-qe2EJgr9fJE62jyPmlWQwRj8T0DK4iuMU844ZhYs,23281
-wolfhece/pyviews.py,sha256=G4PHtXJ8F9PQDt_hcKnxF5kmA1_Fy-8hGiJN2wa_9j4,10017
+wolfhece/pyviews.py,sha256=jSTXCsmzw5OIZusj3Ynfd2o2XvRq7TaDnbt-dyNlbi0,10198
 wolfhece/pywalous.py,sha256=yRaWJjKckXef1d9D5devP0yFHC9uc6kRV4G5x9PNq9k,18972
 wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=m0Akg1jpe8L7139afVANhqUI09q7YlQvlGm2mcs7gJQ,356155
+wolfhece/wolf_array.py,sha256=7-5l96kuQdTE3CStLyf8PkyRD3QX1Us7DOTbF7INepY,356721
 wolfhece/wolf_hist.py,sha256=7jeVrgSkM3ErJO6SRMH_PGzfLjIdw8vTy87kesldggk,3582
 wolfhece/wolf_texture.py,sha256=EqZI6qCR6ouT3wEtnG_NkVLdvUhfY65JVTj5b6o4lXI,16576
 wolfhece/wolf_tiles.py,sha256=2Ho2I20rHRY81KXxjgLOYISdF4OkJ2d6omeY4shDoGI,10386
 wolfhece/wolf_vrt.py,sha256=89XoDhCJMHiwPQUuOduxtTRKuIa8RDxgNqX65S4xp9M,10569
 wolfhece/wolf_zi_db.py,sha256=baE0niMCzybWGSvPJc5FNxo9ZxsGfU4p-FmfiavFHAs,12967
-wolfhece/wolfresults_2D.py,sha256=U6k8BeQj2g3EUpAQq7m0nSdLtNKrrn_knWKKs1KoAQ8,165462
+wolfhece/wolfresults_2D.py,sha256=MlvE2OoSwk1P_CeTwotV1QDBJYeHhSCjUprG3c42tRc,165714
 wolfhece/xyz_file.py,sha256=Se4nCPwYAYLSA5i0zsbnZUKoAMAD0mK1FJea5WSZUkk,5755
 wolfhece/acceptability/Parallels.py,sha256=h4tu3SpC_hR5Hqa68aruxhtAyhs8u666YuZ40_fR5zg,3979
 wolfhece/acceptability/__init__.py,sha256=hfgoPKLDpX7drN1Vpvux-_5Lfyc_7feT2C2zQr5v-Os,258
@@ -70,8 +70,8 @@ wolfhece/apps/__init__.py,sha256=OzzKItATWV0mDkz_LC2L3w5sgT2rt8ExXXCbR_FwvlY,24
 wolfhece/apps/check_install.py,sha256=icFpkjfwNGDX-0NZVa-ijrCrqmGHEKDiFphjN8uTyh8,928
 wolfhece/apps/curvedigitizer.py,sha256=_hRR2PWow7PU7rTHIbc6ykZ08tCXcK9uy7RFrb4EKkE,5196
 wolfhece/apps/isocurrent.py,sha256=MuwTodHxdc6PrqNpphR2ntYf1NLL2n9klTPndGrOHDQ,4109
-wolfhece/apps/splashscreen.py,sha256=Z95ca-r_SZFpTJZIILuAcKyzl6ElZR08Y5mpQ5y4ZDc,2920
-wolfhece/apps/version.py,sha256=oID8AvPVNdgq4kmuDFo7jFiw8pv1XddrAgr_ttxcAgk,388
+wolfhece/apps/splashscreen.py,sha256=SrustmIQeXnsiD-92OzjdGhBi-S7c_j-cSvuX4T6rtg,2929
+wolfhece/apps/version.py,sha256=9TV-RYEEy9X0HeZ9xYxf6PRts-on5mB43zJZtbq4_bY,388
 wolfhece/apps/wolf.py,sha256=mM6Tyi4DlKQILmO49cDUCip9fYVy-hLXkY3YhZgIeUQ,591
 wolfhece/apps/wolf2D.py,sha256=yPQGee7fsegoQ8GfWKrWEjX1Az_ApL-UWlBiqPvaIyY,565
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -171,7 +171,7 @@ wolfhece/lazviewer/viewer/viewer.exe,sha256=pF5nwE8vMWlEzkk-SOekae9zpOsPhTWhZbqa
 wolfhece/lazviewer/viewer/viewer.py,sha256=8_MQCaQOS0Z_oRPiGoRy1lq-aCirReX3hWEBjQID0ig,24665
 wolfhece/libs/get_infos.cp310-win_amd64.pyd,sha256=45b6uo0r2zPD4KbpHR8QZC0TwQHDb9S0It7-kv0GWTA,77824
 wolfhece/libs/verify_wolf.cp310-win_amd64.pyd,sha256=ceWkovmTDfQcIzlxOBjUUDoHu6ZglOlUFADaRuAe3WM,127488
-wolfhece/libs/wolfogl.cp310-win_amd64.pyd,sha256=1nQE30ZDXTmnjnaJisDDlP5zvt5Chu2Lxz1a-bZTY1A,294912
+wolfhece/libs/wolfogl.cp310-win_amd64.pyd,sha256=e27Epa44wBSrXiwzeUpl2ud8oCPJpFbfWd_5P5l6sAo,294912
 wolfhece/libs/wolfpy.cp310-win_amd64.pyd,sha256=6omqEaxmQll-Gg24e90wVomAB9rO_tyyOES2FewXn58,36457472
 wolfhece/libs/GL/gl.h,sha256=IhsS_fOLa8GW9MpiLZebe9QYRy6uIB_qK_uQMWMOoeg,46345
 wolfhece/libs/GL/glaux.h,sha256=I3vxXdrzVH05TmjEeAOgKn3egbPt34WMjbeKq5LaBvE,7130
@@ -249,8 +249,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=8PlMYrb_8jI8h9F0_EagpM
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.1.38.dist-info/METADATA,sha256=YabVhQz0G97k82q5CR8b4lqyCKpVhdhWpbIrjeJ9Yuw,2463
-wolfhece-2.1.38.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
-wolfhece-2.1.38.dist-info/entry_points.txt,sha256=yggeO1Fa80pi2BrOd9k5dTkiFlefGPwG6HztZhY0-qw,366
-wolfhece-2.1.38.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.38.dist-info/RECORD,,
+wolfhece-2.1.39.dist-info/METADATA,sha256=83wPlCtt2A7BPb-3QuxZrLSWn3AGA5uppBHC79HuiBU,2463
+wolfhece-2.1.39.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+wolfhece-2.1.39.dist-info/entry_points.txt,sha256=yggeO1Fa80pi2BrOd9k5dTkiFlefGPwG6HztZhY0-qw,366
+wolfhece-2.1.39.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.39.dist-info/RECORD,,