wolfhece 2.1.25__py3-none-any.whl → 2.1.27__py3-none-any.whl

wolfhece/wolf_array.py

@@ -77,6 +77,7 @@ WOLF_ARRAY_MNAP_INTEGER = 20
 
 WOLF_ARRAY_MB = [WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_MNAP_INTEGER]
 
+VERSION_RGB = 2
 
 def getkeyblock(i, addone=True) -> str:
     """
@@ -648,6 +649,8 @@ class header_wolf():
         if isinstance(filename, Path):
             filename = str(filename)
 
+        locpath = Path(filename)
+
         if filename.endswith('.tif') or filename.endswith('.tiff') :
             from osgeo import gdal
 
@@ -680,7 +683,7 @@ class header_wolf():
             """
 
             dtype = raster.GetRasterBand(1).DataType
-
+            
             if dtype == 1:
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER8
             elif dtype in [2,3]:
@@ -696,9 +699,61 @@ class header_wolf():
                 logging.error(_('Please convert the raster to a supported datatype - or upgrade the code to support this datatype'))
                 logging.error(_('See : read_txt_header and import_geotif in wolf_array.py'))
                 return
-            return
 
-        if filename.endswith('.flt'):
+        elif filename.endswith('.npy') and not os.path.exists(filename + '.txt'):
+            # Il y de fortes chances que cette matrice numpy provienne d'une modélisation GPU
+            #  et donc que les coordonnées et la résolution soient disponibles dans un fichier parameters.json
+            if (locpath.parent / 'parameters.json').exists():
+                with open(locpath.parent / 'parameters.json', 'r') as f:
+                    params = json.load(f)
+
+                if 'parameters' in params.keys():
+                    if "dx" in params['parameters'].keys() :
+                        self.dx = float(params['parameters']["dx"])
+                    if "dy" in params['parameters'].keys() :
+                        self.dy = float(params['parameters']["dy"])
+                    if "base_coord_x" in params['parameters'].keys() :
+                        self.origx = float(params['parameters']["base_coord_x"])
+                    if "base_coord_y" in params['parameters'].keys() :
+                        self.origy = float(params['parameters']["base_coord_y"])
+
+                self.nullvalue = 99999.
+            else:
+
+                self.dx = 1.
+                self.dy = 1.
+                self.origx = 0.
+                self.origy = 0.
+
+            # Numpy format
+            with open(filename, 'rb') as f:
+                version = np.lib.format.read_magic(f)
+                if version[0] == 1:
+                    shape, fortran, dtype = np.lib.format.read_array_header_1_0(f)
+                elif version[0] == 2:
+                    shape, fortran, dtype = np.lib.format.read_array_header_2_0(f)
+                else:
+                    raise ValueError("Unknown numpy version: %s" % version)
+        
+            self.nbx, self.nby = shape         
+
+            if dtype == np.float32:
+                self.wolftype = WOLF_ARRAY_FULL_SINGLE
+            elif dtype == np.float64:
+                self.wolftype = WOLF_ARRAY_FULL_DOUBLE
+            elif dtype == np.int32:
+                self.wolftype = WOLF_ARRAY_FULL_INTEGER
+            elif dtype == np.int16:
+                self.wolftype = WOLF_ARRAY_FULL_INTEGER16
+            elif dtype == np.uint8:
+                self.wolftype = WOLF_ARRAY_FULL_INTEGER8
+            elif dtype == np.int8:
+                self.wolftype = WOLF_ARRAY_FULL_INTEGER8
+            else:
+                logging.error(_('Unsupported type in numpy file -- Abort loading'))
+                return
+
+        elif filename.endswith('.flt'):
             # Fichier .flt
             if not os.path.exists(filename[:-4] + '.hdr'):
                 logging.warning(_('File {} does not exist -- Retry!'.format(filename[:-4] + '.hdr')))
@@ -1523,7 +1578,7 @@ class Ops_Array(wx.Frame):
         Toolssizer.Add(self.labelling, 1, wx.EXPAND)
         Toolssizer.Add(self.extract_selection, 1, wx.EXPAND)
 
-        self.ApplyTools.SetToolTip(_("Apply Nullvalue into memmory/object"))
+        self.ApplyTools.SetToolTip(_("Apply Nullvalue into memory/object"))
         self.nullborder.SetToolTip(_("Set null value on the border of the array\n\nYou will be asked for the width of the border (in cells)"))
         self.filter_zone.SetToolTip(_("Filter the array based on contiguous zones\n\nConservation of the ones which contain selected nodes"))
         self.labelling.SetToolTip(_("Labelling of contiguous zones using Scipy.label function\n\nReplacing the current values by the labels"))
@@ -4104,6 +4159,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                  mask_source:np.ndarray = None,
                  ) -> None:
         """
+        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
@@ -4122,10 +4178,8 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         """
 
-
         Element_To_Draw.__init__(self, idx, plotted, mapviewer, need_for_wx)
         header_wolf.__init__(self)
-        """ Constructeur d'un WOLF array """
 
         self.mngselection = None
 
@@ -4147,7 +4201,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.loaded = False
         self.masknull = masknull
 
-        self.rgb = None         # numpy array with colorize values
+        if VERSION_RGB==1 : self.rgb = None         # numpy array with colorize values
         self.alpha = 1.         # transparency alpha value
         self.shading = False    # if True, rgb will be shaded
 
@@ -4158,6 +4212,8 @@ class WolfArray(Element_To_Draw, header_wolf):
             self.shaded = WolfArray(whichtype=WOLF_ARRAY_HILLSHAPE)
             self.shaded.mypal.defaultgray()
             self.shaded.mypal.automatic = False
+        else:
+            self.shaded = None
 
         self._nullvalue = nullvalue
         self.nbnotnull = 99999      # number of non-null values in the entire aray
@@ -4209,12 +4265,17 @@ class WolfArray(Element_To_Draw, header_wolf):
         if fname is not None:
 
             self.filename = str(fname)
+            logging.info(_('Loading file : %s') % self.filename)
             self.read_all()
 
             if mask_source is not None:
+                logging.info(_('Applying mask from source'))
                 self.copy_mask_log(mask_source)
-            elif masknull and self.preload:
+                logging.info(_('Data masked'))
+            elif masknull and (self.preload or self.loaded):
+                logging.info(_('Masking data with nullvalue'))
                 self.mask_data(self.nullvalue)
+                logging.info(_('Data masked'))
 
         elif mold is not None:
             if self.cropini is None:
@@ -4269,6 +4330,54 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
+    @property
+    def memory_usage(self):
+        """
+        Return the memory usage of the header
+        """
+
+        if self.nbz == 0:
+            size = self.nbx * self.nby 
+        else:
+            size = self.nbx * self.nby * self.nbz
+
+        if self.wolftype == WOLF_ARRAY_FULL_SINGLE:
+            return size * 4
+        elif self.wolftype == WOLF_ARRAY_FULL_DOUBLE:
+            return size * 8
+        elif self.wolftype == WOLF_ARRAY_FULL_INTEGER:
+            return size * 4
+        elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
+            return size * 2
+        elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
+            return size
+        else:
+            return size * 4
+        
+    @property
+    def memory_usage_mask(self):
+        """
+        Return the memory usage of the mask
+        """
+
+        if self.nbz == 0:
+            size = self.nbx * self.nby
+        else:
+            size = self.nbx * self.nby * self.nbz
+
+        return size * 1
+
+    def __del__(self):
+        """ Destructeur de la classe """
+        import gc
+        self.delete_lists()
+        del self.array 
+        if VERSION_RGB==1 : del self.rgb
+        del self._array3d
+        del self.mypal
+        del self.shaded
+        gc.collect()
+    
     def extract_selection(self):
         """ Extract the current selection """
 
@@ -4689,6 +4798,54 @@ class WolfArray(Element_To_Draw, header_wolf):
         band.FlushCache()
         band.ComputeStatistics(True)
 
+    def _import_npy(self, fn:str='', crop:list[float]=None):
+        """ 
+        Import a numpy file.
+
+        Must be called after the header is initialized, e.g. read_txt_header.
+
+        :param fn: filename
+        :param crop: crop the data - [xmin, xmax, ymin, ymax]
+        """
+
+        if fn !='':
+            pass
+        elif self.filename !='':
+            fn = self.filename
+        else:
+            return
+
+        # Numpy format
+        locarray = np.load(self.filename)
+
+        assert locarray.shape[0] == self.nbx, _('Incompatible dimensions')
+        assert locarray.shape[1] == self.nby, _('Incompatible dimensions')
+
+        if crop is not None :
+            logging.error(_('Cropping not yet implemented for numpy files'))
+
+            imin, jmin = self.get_ij_from_xy(crop[0][0], crop[1][0])
+            imax, jmax = self.get_ij_from_xy(crop[0][1], crop[1][1])
+
+            imin = int(imin)
+            jmin = int(jmin)
+            imax = int(imax)
+            jmax = int(jmax)
+
+            self.nbx = imax - imin
+            self.nby = jmax - jmin
+            self.dx  = self.dx
+            self.dy  = self.dy
+            self.origx, self.origy = self.get_xy_from_ij(imin, jmin)
+            self.origx -= self.dx / 2.
+            self.origy -= self.dy / 2.
+            self.translx = self.translx
+            self.transly = self.transly
+
+            locarray = locarray[imin:imax, jmin:jmax]
+
+        self.array = np.ma.asarray(locarray)
+
     def import_geotif(self, fn:str='', which:int = None, crop:list[float]=None):
         """
         Import de la matrice au format Geotiff
@@ -4712,65 +4869,69 @@ class WolfArray(Element_To_Draw, header_wolf):
             return
 
         if crop is not None :
-            if os.path.exists(fn):
+            if not os.path.exists(fn):
+                logging.error(_('File not found'))
+                return
 
-                tmpdx = self.dx
+            tmpdx = self.dx
 
-                fn_crop = fn + '_crop.tif'
-                if type(crop) is np.ndarray:
-                    pass
-                elif type(crop) is list:
-                    pass
-                else:
-                    if not self.wx_exists:
-                        logging.error(_('Crop must be a list or a numpy array with 4 values - xmin, xmax, ymin, ymax'))
-                        return
+            fn_crop = fn + '_crop.tif'
+            if type(crop) is np.ndarray:
+                pass
+            elif type(crop) is list:
+                pass
+            else:
+                if not self.wx_exists:
+                    logging.error(_('Crop must be a list or a numpy array with 4 values - xmin, xmax, ymin, ymax'))
+                    return
+
+                raster:gdal.Dataset
+                raster = gdal.Open(fn)
+                geotr = raster.GetGeoTransform()
+                self.dx = geotr[1]
+                self.dy = abs(geotr[5])
 
-                    raster:gdal.Dataset
-                    raster = gdal.Open(fn)
-                    geotr = raster.GetGeoTransform()
-                    self.dx = geotr[1]
-                    self.dy = abs(geotr[5])
 
+                newcrop = CropDialog(None)
 
-                    newcrop = CropDialog(None)
+                if self.wx_exists:
+                    bounds = self.mapviewer.get_canvas_bounds()
 
-                    if self.wx_exists:
-                        bounds = self.mapviewer.get_canvas_bounds()
+                    newcrop.dx.Value = str(self.dx)
+                    newcrop.dy.Value = str(self.dy)
 
-                        newcrop.dx.Value = str(self.dx)
-                        newcrop.dy.Value = str(self.dy)
+                    newcrop.dx.Enable(False)
+                    newcrop.dy.Enable(False)
 
-                        newcrop.dx.Enable(False)
-                        newcrop.dy.Enable(False)
+                    newcrop.ox.Value = str(float((bounds[0] // 50.) * 50.))
+                    newcrop.ex.Value = str(float((bounds[2] // 50.) * 50.))
+                    newcrop.oy.Value = str(float((bounds[1] // 50.) * 50.))
+                    newcrop.ey.Value = str(float((bounds[3] // 50.) * 50.))
 
-                        newcrop.ox.Value = str(float((bounds[0] // 50.) * 50.))
-                        newcrop.ex.Value = str(float((bounds[2] // 50.) * 50.))
-                        newcrop.oy.Value = str(float((bounds[1] // 50.) * 50.))
-                        newcrop.ey.Value = str(float((bounds[3] // 50.) * 50.))
+                badvalues = True
+                while badvalues:
+                    badvalues = False
 
-                    badvalues = True
-                    while badvalues:
-                        badvalues = False
+                    ret = newcrop.ShowModal()
+                    if ret == wx.ID_CANCEL:
+                        newcrop.Destroy()
+                        return
+                    else:
+                        crop = [float(newcrop.ox.Value), float(newcrop.ex.Value),
+                                float(newcrop.oy.Value), float(newcrop.ey.Value)]
 
-                        ret = newcrop.ShowModal()
-                        if ret == wx.ID_CANCEL:
-                            newcrop.Destroy()
-                            return
-                        else:
-                            crop = [float(newcrop.ox.Value), float(newcrop.ex.Value),
-                                    float(newcrop.oy.Value), float(newcrop.ey.Value)]
+                        tmpdx = float(newcrop.dx.Value)
+                        tmpdy = float(newcrop.dy.Value)
 
-                            tmpdx = float(newcrop.dx.Value)
-                            tmpdy = float(newcrop.dy.Value)
+                    if self.dx != tmpdx or self.dy != tmpdy:
+                        if tmpdx / self.dx != tmpdy / self.dy:
+                            badvalues = True
 
-                        if self.dx != tmpdx or self.dy != tmpdy:
-                            if tmpdx / self.dx != tmpdy / self.dy:
-                                badvalues = True
+                newcrop.Destroy()
 
-                    newcrop.Destroy()
+            xmin, xmax, ymin, ymax = crop
 
-                xmin, xmax, ymin, ymax = crop
+            if self.wx_exists:
 
                 with wx.FileDialog(None, _('Save the cropped file for later'), wildcard="Tiff files (*.tif)|*.tif",
                                     style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT) as fileDialog:
@@ -4783,6 +4944,11 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                 gdal.Translate(fn_crop, fn, projWin=[xmin, ymax, xmax, ymin])
                 fn  = fn_crop
+            else:
+                from tempfile import NamedTemporaryFile
+                tmpfile = NamedTemporaryFile(suffix='.tif')
+                gdal.Translate(str(tmpfile.name), fn, projWin=[xmin, ymax, xmax, ymin])
+                fn = str(tmpfile.name)
 
         raster:gdal.Dataset
         raster = gdal.Open(fn)
@@ -4864,8 +5030,6 @@ class WolfArray(Element_To_Draw, header_wolf):
             elif self.array.dtype == np.int8:
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER8
 
-            self.mask_data(self.nullvalue)
-
         except:
             logging.warning(_('Error during importing tif file'))
 
@@ -5860,8 +6024,9 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.loaded = True
 
-        if self.rgb is None:
-            self.updatepalette(0)
+        if VERSION_RGB==1 : 
+            if self.rgb is None:
+                self.updatepalette(0)
 
     def uncheck_plot(self, unload:bool=True, forceresetOGL:bool=False, askquestion:bool=True):
         """
@@ -5886,7 +6051,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             if unload:
                 self.delete_lists()
                 self.array = np.zeros([1])
-                self.rgb = None
+                if VERSION_RGB==1 : self.rgb = None
                 self.loaded = False
                 return
 
@@ -5896,10 +6061,10 @@ class WolfArray(Element_To_Draw, header_wolf):
                 ret = dlg.ShowModal()
                 if ret == wx.ID_YES:
                     self.delete_lists()
-                    self.rgb = None
+                    if VERSION_RGB==1 : self.rgb = None
         else:
             self.delete_lists()
-            self.rgb = None
+            if VERSION_RGB==1 : self.rgb = None
 
     def get_header(self, abs:bool=True) -> header_wolf:
         """
@@ -5964,7 +6129,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
     def __add__(self, other):
         """Surcharge de l'opérateur d'addition"""
-        newArray = WolfArray()
+        newArray = WolfArray(whichtype=self.wolftype)
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -5985,11 +6150,12 @@ class WolfArray(Element_To_Draw, header_wolf):
                 newArray.array = np.ma.masked_array(self.array + other, self.array.mask)
         else:
             newArray.array = np.ma.masked_array(self.array + other.array, self.array.mask)
+        newArray.count()
         return newArray
 
     def __mul__(self, other):
         """Surcharge de l'opérateur d'addition"""
-        newArray = WolfArray()
+        newArray = WolfArray(whichtype=self.wolftype)
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -6010,11 +6176,12 @@ class WolfArray(Element_To_Draw, header_wolf):
                 newArray.array = np.ma.masked_array(self.array * other, self.array.mask)
         else:
             newArray.array = np.ma.masked_array(self.array * other.array, self.array.mask)
+        newArray.count()
         return newArray
 
     def __sub__(self, other):
         """Surcharge de l'opérateur de soustraction"""
-        newArray = WolfArray()
+        newArray = WolfArray(whichtype=self.wolftype)
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -6035,11 +6202,12 @@ class WolfArray(Element_To_Draw, header_wolf):
                 newArray.array = np.ma.masked_array(self.array - other, self.array.mask)
         else:
             newArray.array = np.ma.masked_array(self.array - other.array, self.array.mask)
+        newArray.count()
         return newArray
 
     def __pow__(self, other):
         """Surcharge de l'opérateur puissance"""
-        newArray = WolfArray()
+        newArray = WolfArray(whichtype=self.wolftype)
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -6056,11 +6224,12 @@ class WolfArray(Element_To_Draw, header_wolf):
             newArray.translz = self.translz
 
         newArray.array = np.ma.masked_array(self.array ** other, self.array.mask)
+        newArray.count()
         return newArray
 
     def __truediv__(self, other):
         """Surcharge de l'opérateur division"""
-        newArray = WolfArray()
+        newArray = WolfArray(whichtype=self.wolftype)
         newArray.nbx = self.nbx
         newArray.nby = self.nby
         newArray.dx = self.dx
@@ -6081,7 +6250,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                 newArray.array = np.ma.masked_array(self.array / other, self.array.mask)
         else:
             newArray.array = np.ma.masked_array(np.where(other == 0., 0., self.array / other.array), self.array.mask)
-
+        newArray.count()
         return newArray
 
     def concatenate(self, list_arr:list["WolfArray"], nullvalue:float = 0.):
@@ -6363,70 +6532,48 @@ class WolfArray(Element_To_Draw, header_wolf):
     def read_all(self, which_band = None):
         """ Lecture d'un Wolf aray depuis le nom de fichier """
 
+        THRESHOLD = 20_000_000
+
         if not os.path.exists(self.filename):
             if self.wx_exists:
                 logging.warning(_('No data file : ')+self.filename)
             return
+        
+        def check_threshold(nbx, nby, THRESHOLD) -> bool:
+            if nbx * nby > THRESHOLD:
+                logging.info(_('The array is very large > 100M pixels'))
+                logging.info(_('Preloading is not recommended for efficiency reasons'))
+                logging.info(_('Maybe could you crop the array to a smaller size'))
+                logging.info(_('Disabling automatic colormap update'))
+                self.mypal.automatic = False
+                return True
+            else:
+                return False
 
         if self.filename.endswith('.tif') or self.filename.endswith('.tiff'):
-            self.import_geotif(which= which_band, crop = self.cropini)
-            # self.mask_data(self.nullvalue)
-            self.loaded = True
-        elif self.filename.endswith('.npy'):
-            # Numpy format
-            locarray = np.load(self.filename)
-            self.array = np.ma.asarray(locarray)
-
-            self.nbx, self.nby = self.array.shape
+            self.read_txt_header()
 
-            if locarray.dtype == np.float32:
-                self.wolftype = WOLF_ARRAY_FULL_SINGLE
-            elif locarray.dtype == np.float64:
-                self.wolftype = WOLF_ARRAY_FULL_DOUBLE
-            elif locarray.dtype == np.int32:
-                self.wolftype = WOLF_ARRAY_FULL_INTEGER
-            elif locarray.dtype == np.int16:
-                self.wolftype = WOLF_ARRAY_FULL_INTEGER16
-            elif locarray.dtype == np.uint8:
-                self.wolftype = WOLF_ARRAY_FULL_INTEGER8
-            elif locarray.dtype == np.int8:
-                self.wolftype = WOLF_ARRAY_FULL_INTEGER8
-            else:
-                logging.error(_('Unsupported type in numpy file -- Abort loading'))
-                return
+            if self.preload:
+                
+                update_min_max = check_threshold(self.nbx, self.nby, THRESHOLD)
 
-            tmp_wolftype = self.wolftype
+                self.import_geotif(which= which_band, crop = self.cropini)
+                self.loaded = True
 
-            # Il y de fortes chances que cette matrice numpy provienne d'une modélisation GPU
-            #  et donc que les coordonnées et la résolution soient disponibles dans un fichier parameters.json
-            locpath = Path(self.filename)
-            if (locpath.parent / 'parameters.json').exists():
-                with open(locpath.parent / 'parameters.json', 'r') as f:
-                    params = json.load(f)
+                if update_min_max:
+                    self.mypal.distribute_values(self.array.min(), self.array.max())
 
-                if 'parameters' in params.keys():
-                    if "dx" in params['parameters'].keys() :
-                        self.dx = float(params['parameters']["dx"])
-                    if "dy" in params['parameters'].keys() :
-                        self.dy = float(params['parameters']["dy"])
-                    if "base_coord_x" in params['parameters'].keys() :
-                        self.origx = float(params['parameters']["base_coord_x"])
-                    if "base_coord_y" in params['parameters'].keys() :
-                        self.origy = float(params['parameters']["base_coord_y"])
+        elif self.filename.endswith('.npy'):
+            self.read_txt_header()
 
-                self.nullvalue = 99999.
-            elif (locpath.parent / (locpath.name + '.txt')).exists():
-                self.read_txt_header()
+            if self.preload:
+                update_min_max = check_threshold(self.nbx, self.nby, THRESHOLD)
 
-                # Le header contient également un type
-                # Vérification de la cohérence
-                if self.wolftype != tmp_wolftype:
-                    logging.warning(_('Inconsistent type in header and numpy file'))
-                    logging.warning(_('Forcing type from Numpy file'))
-                    self.wolftype = tmp_wolftype
+                self._import_npy(crop = self.cropini)
+                self.loaded = True
 
-            self.mask_data(self.nullvalue)
-            self.loaded = True
+                if update_min_max:
+                    self.mypal.distribute_values(self.array.min(), self.array.max())
 
         else:
             self.read_txt_header()
@@ -6436,9 +6583,13 @@ class WolfArray(Element_To_Draw, header_wolf):
                 self.myblocks = {}
 
             if self.preload:
+                update_min_max = check_threshold(self.nbx, self.nby, THRESHOLD)
+
                 self.read_data()
                 self.loaded = True
-        return
+
+                if update_min_max:
+                    self.mypal.distribute_values(self.array.min(), self.array.max())
 
     def write_all(self, newpath:str = None):
         """
@@ -6802,8 +6953,17 @@ class WolfArray(Element_To_Draw, header_wolf):
         if self.array is None:
             return
 
-        if self.wolftype in [WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2, WOLF_ARRAY_FULL_INTEGER8]:
-            value=int(value)
+        try:
+            if not (np.isnan(value) or math.isnan(value)):
+                if self.wolftype in [WOLF_ARRAY_FULL_INTEGER]:
+                    value=np.int32(value)
+                elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
+                    value=np.int16(value)
+                elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER8]:
+                    value=np.int8(value)
+        except:
+            logging.error(_('Type not supported : {} - {}'.format(value, type(value))))
+            logging.warning(_('Masking operation compromised'))
 
         if value is not None:
 
@@ -7149,29 +7309,44 @@ class WolfArray(Element_To_Draw, header_wolf):
         if self.array is None:
             return
 
-        if self.wolftype != WOLF_ARRAY_FULL_SINGLE:
-            # FIXME: Currently, only float32 is supported in Cython/OpenGL library
-            self._tmp_float32 = self.array.astype(dtype=np.float32)
-        else:
-            self._tmp_float32 = None
-
         if self.mypal.automatic:
             if onzoom != []:
                 self.mypal.isopop(self.get_working_array(onzoom), self.nbnotnullzoom)
             else:
                 self.mypal.isopop(self.get_working_array(), self.nbnotnull)
 
-        self.rgb = self.mypal.get_rgba(self.array)
+        if VERSION_RGB==1 : 
+            if self.nbx * self.nby > 1_000_000 : logging.info(_('Computing colors'))
+            if self.wolftype not in [WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_INTEGER8]:
+                # FIXME: Currently, only some types are supported in Cython/OpenGL library
+                self._tmp_float32 = self.array.astype(dtype=np.float32)
+                self.rgb = self.mypal.get_rgba(self._tmp_float32)
+            else:
+                self._tmp_float32 = None
+                self.rgb = self.mypal.get_rgba(self.array)
+            if self.nbx * self.nby > 1_000_000 : logging.info(_('Colors computed'))
+        elif VERSION_RGB==2 :
+            if self.wolftype not in [WOLF_ARRAY_FULL_SINGLE, 
+                                     WOLF_ARRAY_FULL_INTEGER8,
+                                     WOLF_ARRAY_FULL_INTEGER16,
+                                     WOLF_ARRAY_FULL_INTEGER16_2,
+                                     WOLF_ARRAY_FULL_INTEGER,
+                                     WOLF_ARRAY_FULL_DOUBLE]:
+                # 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 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]
 
-        self.rgb[self.array.mask] = [1., 1., 1., 0.]
+        if VERSION_RGB==1 : self.rgb[self.array.mask] = [1., 1., 1., 0.]
 
         if self.myops is not None:
             # update the wx
@@ -7333,6 +7508,8 @@ 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
 
         if not cursize in self.mygrid.keys():
@@ -7363,26 +7540,81 @@ class WolfArray(Element_To_Draw, header_wolf):
                 iend = min(istart + step, self.nbx)
 
                 try:
-                    if self.wolftype != WOLF_ARRAY_FULL_SINGLE:
-                        if self.nbnotnull != self.nbx * self.nby:
-                            if self.nbnotnull > 0:
-                                wolfogl.addme(self._tmp_float32, self.rgb, ox, oy, dx, dy, jstart,
-                                              jend, istart, iend, cursize, self.nullvalue, self.alpha)
-                        elif self.nbnotnull > 0:
-                            wolfogl.addmeall(self._tmp_float32, self.rgb, ox, oy, dx, dy, jstart,
-                                             jend, istart, iend, cursize, self.nullvalue, self.alpha)
-                    else:
-                        if self.nbnotnull != self.nbx * self.nby:
-                            if self.nbnotnull > 0:
-                                wolfogl.addme(self.array, self.rgb, ox, oy, dx, dy, jstart, jend, istart, iend, cursize,
-                                              self.nullvalue, self.alpha)
-                        elif self.nbnotnull > 0:
-                            wolfogl.addmeall(self.array, self.rgb, ox, oy, dx, dy, jstart, jend, istart, iend, cursize,
-                                             self.nullvalue, self.alpha)
-                except:
+                    if VERSION_RGB == 1:
+                        if self.wolftype != WOLF_ARRAY_FULL_SINGLE:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_uint8(self._tmp_float32, self.rgb, ox, oy, dx, dy, jstart,
+                                                jend, istart, iend, cursize, self.nullvalue, np.uint8(self.alpha*255))
+                            elif self.nbnotnull > 0:
+                                wolfogl.addmeall_uint8(self._tmp_float32, self.rgb, ox, oy, dx, dy, jstart,
+                                                jend, istart, iend, cursize, self.nullvalue, np.uint8(self.alpha*255))
+                        else:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_uint8(self.array, self.rgb, ox, oy, dx, dy, jstart, jend, istart, iend, cursize,
+                                                self.nullvalue, np.uint8(self.alpha*255))
+                            elif self.nbnotnull > 0:
+                                wolfogl.addmeall_uint8(self.array, self.rgb, ox, oy, dx, dy, jstart, jend, istart, iend, cursize,
+                                                self.nullvalue, np.uint8(self.alpha*255))
+                    elif VERSION_RGB == 2:
+                        if self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_int8_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.nbnotnull > 0:
+                                wolfogl.addmeall_int8_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 in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_int16_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.nbnotnull > 0:
+                                wolfogl.addmeall_int16_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_INTEGER:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_int_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.nbnotnull > 0:
+                                wolfogl.addmeall_int_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_DOUBLE:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_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.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:
+                            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))
+                            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))
+                        else:
+                            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))
+                            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))
+
+                except Exception as e:
+                    logging.error(repr(e))
+                    raise NameError(_('OpenGL error in WolfArray.fillonecellgrid -- Please report this case with the data file and the context in which the error occured'))
+
                     pass
                 glEndList()
-            except:
+            except Exception as e:
+                logging.error(repr(e))
                 raise NameError(
                     'Opengl in WolfArray_fillonecellgrid -- maybe a conflict with an existing opengl32.dll file - please rename the opengl32.dll in the libs directory and retry')
 
@@ -7896,8 +8128,11 @@ class WolfArrayMB(WolfArray):
                 self.read_data()
                 if self.masknull:
                     self.mask_data(self.nullvalue)
-                if self.rgb is None:
-                    self.rgb = np.ones((self.nbx, self.nby, 4), order='F', dtype=np.integer)
+
+                if VERSION_RGB==1 : 
+                    if self.rgb is None:
+                        self.rgb = np.ones((self.nbx, self.nby, 4), order='F', dtype=np.integer)
+
                 self.updatepalette(0)
                 self.loaded = True
             else:
@@ -7923,7 +8158,7 @@ class WolfArrayMB(WolfArray):
 
             for curblock in self.myblocks.values():
                 curblock.uncheck_plot(unload, forceresetOGL, askquestion=False)
-                self.rgb = None
+                if VERSION_RGB==1 : self.rgb = None
 
             self.myblocks = {}
             self.loaded = False
@@ -8168,8 +8403,10 @@ class WolfArrayMB(WolfArray):
                 self.mypal.isopop(allarrays, self.nbnotnull)
 
         self.link_palette()
-        for curblock in self.myblocks.values():
-            curblock.rgb = self.mypal.get_rgba(curblock.array)
+        
+        if VERSION_RGB ==1: 
+            for curblock in self.myblocks.values():
+                curblock.rgb = self.mypal.get_rgba(curblock.array)
 
         if self.myops is not None:
             self.myops.update_palette()