wolfhece 2.1.100__py3-none-any.whl → 2.1.102__py3-none-any.whl

wolfhece/wolf_array.py

@@ -22,6 +22,7 @@ import logging
 import json
 import tempfile
 from pathlib import Path
+from tqdm import tqdm
 
 try:
     from OpenGL.GL import *
@@ -115,6 +116,7 @@ WOLF_ARRAY_CSR_DOUBLE = 5
 WOLF_ARRAY_FULL_INTEGER = 6
 WOLF_ARRAY_FULL_SINGLE_3D = 7
 WOLF_ARRAY_FULL_INTEGER8 = 8
+WOLF_ARRAY_FULL_UINTEGER8 = 88
 
 WOLF_ARRAY_MB_SINGLE = 3
 WOLF_ARRAY_MB_INTEGER = 9
@@ -866,7 +868,7 @@ class header_wolf():
             elif dtype == np.int16:
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER16
             elif dtype == np.uint8:
-                self.wolftype = WOLF_ARRAY_FULL_INTEGER8
+                self.wolftype = WOLF_ARRAY_FULL_UINTEGER8
             elif dtype == np.int8:
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER8
             else:
@@ -999,7 +1001,9 @@ class header_wolf():
         :param forceupdate: if True, the file is rewritten even if it already exists
         """
 
-        assert wolftype in [WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_SYM_DOUBLE, WOLF_ARRAY_FULL_LOGICAL, WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_SINGLE_3D, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MNAP_INTEGER, WOLF_ARRAY_FULL_INTEGER16_2], _('The type of array is not correct')
+        assert wolftype in [WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_SYM_DOUBLE, WOLF_ARRAY_FULL_LOGICAL,
+                            WOLF_ARRAY_CSR_DOUBLE, WOLF_ARRAY_FULL_INTEGER, WOLF_ARRAY_FULL_SINGLE_3D, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_UINTEGER8,
+                            WOLF_ARRAY_MB_SINGLE, WOLF_ARRAY_MB_INTEGER, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_MNAP_INTEGER, WOLF_ARRAY_FULL_INTEGER16_2], _('The type of array is not correct')
 
         if not os.path.exists(filename) or forceupdate:
             with open(filename,'w') as f:
@@ -1685,11 +1689,11 @@ class Ops_Array(wx.Frame):
 
             self.m_button7 = wx.Button(self.Interpolation, wx.ID_ANY, _("Stage/Volume/Surface evaluation"), wx.DefaultPosition,
                                     wx.DefaultSize, 0)
-            self.m_button7.SetToolTip(_('Evaluate stage-volume-surface relationship. \n Results : plots and arrays saved on disk'))
+            self.m_button7.SetToolTip(_('Evaluate stage-volume-surface relationship.\nResults : csv and array saved on disk\n\n CAUTION : This function will be applied only on the selected area except if you select "all".\nIn the latter case, the computation time could be long if the array are very large.'))
 
             if self.parentarray.nb_blocks>0:
                 self.m_button7.Disable()
-                self.m_button7.SetToolTip(_('Evaluate stage-volume-surface relationship. \n Results : plots and arrays saved on disk\n\nThis function is not available for multi-block arrays.'))
+                self.m_button7.SetToolTip(_('Evaluate stage-volume-surface relationship.\nResults : arrays and csv file saved on disk\n\nThis function is not available for multi-block arrays.'))
 
             gSizer1.Add(self.m_button7, 0, wx.EXPAND)
             self.m_button7.Bind(wx.EVT_BUTTON, self.volumesurface)
@@ -2674,17 +2678,29 @@ class Ops_Array(wx.Frame):
 
         # operator value
         opval = self.opvalue.GetValue()
-        if opval.lower() == 'null' or opval.lower() == 'nan':
+        if opval.lower() == 'null' or opval.lower() == 'nan' or opval.lower() == 'nul':
             curopvalue = self.parentarray.nullvalue
         else:
-            curopvalue = float(opval)
+            try:
+                tmp_float = float(opval)
+            except:
+                logging.error('Error in float conversion - Do you try to set null value ? - Accepted values : "Null" or "NaN"')
+                return
+
+            curopvalue = tmp_float
 
         # condition value
         curcondvalue = self.condvalue.GetValue()
-        if curcondvalue.lower() == 'null' or curcondvalue.lower() == 'nan':
+        if curcondvalue.lower() == 'null' or curcondvalue.lower() == 'nan' or curcondvalue.lower() == 'nul':
             curcondvalue = self.parentarray.nullvalue
         else:
-            curcondvalue = float(curcondvalue)
+            try:
+                tmp_float = float(curcondvalue)
+            except:
+                logging.error('Error in float conversion - Do you try to set null value ? - Accepted values : "Null" or "NaN"')
+                return
+
+            curcondvalue = tmp_float
 
         self.parentarray.SelectionData.treat_select(curop, curcond, curopvalue, curcondvalue)
 
@@ -2694,8 +2710,16 @@ class Ops_Array(wx.Frame):
         curop = self.choiceop.GetSelection()
         curcond = self.condition.GetSelection()
 
-        curopvalue = float(self.opvalue.GetValue())
-        curcondvalue = float(self.condvalue.GetValue())
+        try:
+            curopvalue = float(self.opvalue.GetValue())
+        except:
+            logging.error('Error in float conversion - operator')
+            return
+        try:
+            curcondvalue = float(self.condvalue.GetValue())
+        except:
+            logging.error('Error in float conversion - condition')
+            return
 
         self.parentarray.SelectionData.mask_condition(curop, curcond, curopvalue, curcondvalue)
         self.refresh_array()
@@ -4464,8 +4488,10 @@ class SelectionData():
         if self.nb == 0:
             return None
 
-        newarray = WolfArray()
+        if self.myselection == 'all':
+            return WolfArray(mold=self.parent)
 
+        newarray = WolfArray()
         lochead = self._get_header()
         if lochead is None:
             logging.error(_('Error in get_newarray !'))
@@ -4588,33 +4614,35 @@ class SelectionData():
 
                 if self.nb == 0 or self.myselection == 'all':
                     myarray = array1
-                    axs = myarray.volume_estimation()
+                    fig, axs = myarray.volume_estimation()
 
                     myarray = array2
-                    axs = myarray.volume_estimation(axs)
+                    fig, axs = myarray.volume_estimation(axs)
                 else:
                     myarray = array1.mngselection.get_newarray()
-                    axs = myarray.volume_estimation()
+                    fig, axs = myarray.volume_estimation()
 
                     myarray = array2.mngselection.get_newarray()
-                    axs = myarray.volume_estimation(axs)
+                    fig, axs = myarray.volume_estimation(axs)
             else:
                 if len(self.parent.mngselection.myselection) == 0 or self.parent.mngselection.myselection == 'all':
                     myarray = self.parent
                 else:
                     myarray = self.parent.mngselection.get_newarray()
+                    myarray.SelectionData.selections = self.parent.mngselection.selections.copy()
 
-                myarray.volume_estimation()
+                fig, axs = myarray.volume_estimation()
         else:
             if self.nb == 0 or self.myselection == 'all':
                 myarray = self.parent
             else:
                 myarray = self.get_newarray()
+                myarray.SelectionData.selections = self.selections.copy()
 
-            myarray.volume_estimation()
+            fig, axs = myarray.volume_estimation()
 
         if show:
-            plt.show()
+            fig.show()
 
 class SelectionDataMB(SelectionData):
     """ Extension of SelectionData to manage multiple blocks """
@@ -4877,6 +4905,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                  plotted:bool       = False,
                  need_for_wx:bool   = False,
                  mask_source:np.ndarray = None,
+                 np_source:np.ndarray = None,
                  ) -> None:
         """
         Constructor of the WolfArray class
@@ -4895,6 +4924,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         :param plotted: True = will be plotted if required by the mapviewer
         :param need_for_wx: True = a wxApp is required (if no application is underway --> Error)
         :param mask_source: mask to link to the data
+        :param np_source: numpy array to link to the data
 
         """
         try:
@@ -4982,7 +5012,16 @@ class WolfArray(Element_To_Draw, header_wolf):
             if self.nb_blocks>0:
                 self.myblocks = {}
 
-            self.allocate_ressources()
+            if np_source is None:
+                self.allocate_ressources()
+            else:
+                assert np_source.shape == (self.nbx, self.nby), _('Shape of np_source is not compatible with header')
+
+                if self.dtype != np_source.dtype:
+                    logging.warning(_('dtype of np_source is not compatible with header -- Conversion will be done'))
+                    np_source = np_source.astype(self.dtype)
+
+                self.array = ma.MaskedArray(np_source, mask= np_source[:,:] == self.nullvalue, copy=False, order='C')
 
             # # FIXME Why not initialize with nullvalue ?
             # self.array = ma.MaskedArray(np.ones((self.nbx, self.nby), order='F', dtype=self.dtype))
@@ -5054,6 +5093,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 self.init_from_new(new)
 
+
         self.add_ops_sel() # Ajout d'un gestionnaire de sélection et d'opérations
 
     def set_opacity(self, alpha:float):
@@ -5094,7 +5134,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             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:
+        elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_UINTEGER8]:
             return size
         else:
             return size * 4
@@ -5355,6 +5395,8 @@ class WolfArray(Element_To_Draw, header_wolf):
             dtype = np.int16
         elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
             dtype = np.int8
+        elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+            dtype = np.uint8
         elif self.wolftype == WOLF_ARRAY_FULL_LOGICAL:
             dtype = np.int16
 
@@ -5374,6 +5416,8 @@ class WolfArray(Element_To_Draw, header_wolf):
             dtype = gdal.GDT_Int16
         elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
             dtype = gdal.GDT_Byte
+        elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+            dtype = gdal.GDT_Byte
         elif self.wolftype == WOLF_ARRAY_FULL_LOGICAL:
             dtype = gdal.GDT_Int16
 
@@ -5404,6 +5448,8 @@ class WolfArray(Element_To_Draw, header_wolf):
             dtype = _('int16 - 2 bytes per values')
         elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
             dtype = _('int8 - 1 byte per values')
+        elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+            dtype = _('uint8 - 1 byte per values')
         elif self.wolftype == WOLF_ARRAY_FULL_LOGICAL:
             dtype = _('int16 - 2 bytes per values')
 
@@ -6062,7 +6108,7 @@ class WolfArray(Element_To_Draw, header_wolf):
           - uniquement dans les mailles sélectionnées si elles existent
           - dans les mailles contenues dans le polygone sinon
 
-        On utilise ensuite "griddata" pour interpoler les altitudes des mailles
+        On utilise ensuite "griddata" de Scipy pour interpoler les altitudes des mailles
         depuis les vertices 3D du polygone
         """
 
@@ -6125,17 +6171,27 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.array.data[allij[:, 0], allij[:, 1]] = newz
 
     def interpolate_on_polylines(self, working_zone:zone, usemask=True):
+        """ Interpolation sous toutes les polylignes d'une même zone """
 
         for curvec in working_zone.myvectors:
             self.interpolate_on_polyline(curvec, usemask)
 
 
-    def interpolate_on_cloud(self, xy:np.ndarray, z:np.ndarray, method='linear'):
+    def interpolate_on_cloud(self, xy:np.ndarray, z:np.ndarray, method:Literal['linear', 'nearest', 'cubic']= 'linear'):
         """
-        See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
+        Interpolation sur un nuage de points.
+
+        L'interpolation a lieu :
+          - uniquement dans les mailles sélectionnées si elles existent
+          - dans les mailles contenues dans le polygone convexe contenant les points sinon
 
-            method == nearest, linear or cubic
+        Using griddata from Scipy.
 
+        :param xy: numpy.array of vertices - shape (n,2)
+        :param z: numpy.array of values - shape (n,)
+        :param method: method for the interpolation -- 'nearest', 'linear' or 'cubic'
+
+        See : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
         """
 
         if self.mngselection.myselection == [] or self.mngselection.myselection == 'all':
@@ -6159,18 +6215,36 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         self.reset_plot()
 
-    def interpolate_on_triangulation(self, coords, triangles, grid_x=None, grid_y = None, mask_tri=None, interp_method = 'matplotlib'):
-        import matplotlib.tri as mtri
+    def interpolate_on_triangulation(self, coords, triangles,
+                                     grid_x=None, grid_y = None,
+                                     mask_tri=None, interp_method:Literal['matplotlib','scipy'] = 'matplotlib'):
         """
-        See : https://matplotlib.org/stable/gallery/images_contours_and_fields/triinterp_demo.html
+        Interpolation sur une triangulation.
+
+        L'interpolation a lieu :
+          - uniquement dans les mailles sélectionnées si elles existent
+          - dans les mailles contenues dans la triangulation sinon
+
+        Matplotlib is used by default, but Scipy(griddata) can be used as well. If Matplotlib crashes, try with Scipy.
+        Matplotlib is more strict on the quality of the triangulation.
 
-            method == linear
+        :param coords: numpy.array of vertices - shape (n,3)
+        :param triangles: numpy.array of triangles - shape (m,3)
+        :param grid_x: numpy.array of x values where the interpolation will be done -- if None, the grid is created from the array
+        :param grid_y: numpy.array of y values where the interpolation will be done -- if None, the grid is created from the array
+        :param mask_tri: numpy.array of mask for the triangles
+        :param interp_method: method for the interpolation -- 'matplotlib' or 'scipy'
+
+        For matplotlib algo, see : https://matplotlib.org/stable/gallery/images_contours_and_fields/triinterp_demo.html
+        For scipy algo, see : https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.griddata.html
 
         """
 
 
         if interp_method =='matplotlib':
 
+            import matplotlib.tri as mtri
+
             use_scipy=False
 
             try:
@@ -6291,10 +6365,16 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.reset_plot()
         return
 
-    def import_from_gltf(self, fn:str='', fnpos:str='', interp_method:Literal['matplotlib','numpy'] = 'matplotlib'):
+    def import_from_gltf(self, fn:str='', fnpos:str='', interp_method:Literal['matplotlib','scipy'] = 'matplotlib'):
         """
-        interp_method == 'matplotlib' or 'griddata'
+        Import from GLTF/GLB format
+
+        :param fn: filename
+        :param fnpos: filename for the position's information
+        :param interp_method: method for the interpolation -- 'matplotlib' or 'scipy'
+
         """
+        #FIXME : add the possibility to use PyVista
 
         if fn == '' or fnpos == '':
             logging.info(_('Retry !! -- Bad files'))
@@ -6459,7 +6539,6 @@ class WolfArray(Element_To_Draw, header_wolf):
         triangles.append([[i + decal, i + decal + 1, i + decal + nby] for i in range(nby - 1)])
         triangles.append([[i + decal + nby, i + decal + 1, i + decal + nby + 1] for i in range(nby - 1)])
 
-        from tqdm import tqdm
         for k in tqdm(range(1, nbx - 1)):
             decal = k * nby
             triangles.append([[i + decal, i + decal + 1, i + decal + nby] for i in range(nby - 1)])
@@ -6499,7 +6578,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         return mylap
 
-    def volume_estimation(self, axs=None):
+    def volume_estimation(self, axs:plt.Axes= None):
         """ Estimation of the volume of the selected zone """
 
         vect = self.array[np.logical_not(self.array.mask)].flatten()
@@ -6529,58 +6608,125 @@ class WolfArray(Element_To_Draw, header_wolf):
         deltaz = (zmax - zmin) / nb
         curz = zmin
         nbgroupement = []
-        longueur = []
+        labeled_areas = []
         stockage = []
         z = []
 
-        dlg = wx.MessageDialog(None, _("Would you like to calculate relationships on the basis of the largest area ? \n if Yes, no guarantee on the volume increase"), style = wx.YES_NO|wx.YES_DEFAULT)
+        methods = [_("All cells below the elevation (even if cells are disconnected)"),
+                     _("Only the largest connected area below the elevation (not necessarily the same for each elevation)"),
+                        _("Only the area below the elevation (if containing the cells stored in memory selection)")]
+
+        keys_select = list(self.SelectionData.selections.keys())
+        if len(keys_select) == 0:
+            methods = methods[:2]
+            use_memory = False
+
+        dlg = wx.SingleChoiceDialog(None, _("Choose a method for selecting the area to integrate"), _("Labeling?"), methods)
         ret = dlg.ShowModal()
-        if ret == wx.ID_YES:
-            labeled= True
-        dlg.Destroy()
+
+        if ret == wx.ID_CANCEL:
+            dlg.Destroy()
+            return
+
+        if dlg.GetSelection() == 0:
+            labeled = False
+        else:
+            labeled = True
+            if dlg.GetSelection() == 1:
+                use_memory = False
+            else:
+                if len(keys_select) >1:
+                    dlg = wx.SingleChoiceDialog(None, _("Choose a memory selection"), _("Memory selection?"), keys_select)
+                    ret = dlg.ShowModal()
+
+                    if ret == wx.ID_CANCEL:
+                        dlg.Destroy()
+                        return
+
+                    key = keys_select[dlg.GetSelection()]
+                else:
+                    key = keys_select[0]
+
+                xy_key = self.SelectionData.selections[key]['select']
+                if len(xy_key) == 0:
+                    logging.error(_('Empty selection'))
+                    return
+
+                ij_key = self.xy2ij_np(xy_key)
+
+                use_memory = True
 
         extensionmax = WolfArray(mold=self)
         extensionmax.array[:, :] = 0.
 
         if labeled:
-            for i in range(nb + 1):
-                logging.info(_('  Step ') +str(i))
+            for i in tqdm(range(nb + 1)):
                 z.append(curz)
 
+                # Compute difference between the array and the current elevation
                 if i == 0:
                     diff = self.array - (curz + 1.e-3)
                 else:
                     diff = self.array - curz
 
+                # Keep only the negative values
                 diff[diff > 0] = 0.
                 diff.data[diff.mask] = 0.
-                labeled_array, num_features = label(diff.data)
-                labeled_array = ma.asarray(labeled_array)
-                labeled_array.mask = self.array.mask
-
-                # groupement = labeled_array
-                # groupement[labeled_array.mask] = 0
-                # nbgroupement.append(num_features)
-                # for j in range(1, nbgroupement[i] + 1):
-                #     taille = (np.sum(groupement[groupement == j]) // j)
-                #     longueur.append([taille, j])
 
+                if np.count_nonzero(diff < 0.) > 1:
+                    # More than one cell below the elevation
+
+                    # Labeling of the cells below the elevation
+                    labeled_array, num_features = label(diff.data)
+                    # Applying the same mask as the original array
+                    labeled_array = ma.asarray(labeled_array)
+                    labeled_array.mask = self.array.mask
+
+                    if use_memory:
+                        # Use only the labeled areas containing the cells stored in memory selection
+                        labeled_areas = []
+                        for curij in ij_key:
+                            labeled_areas.append(labeled_array[curij[0], curij[1]])
+
+                        # Remove masked value
+                        labeled_areas = [x for x in labeled_areas if x is not ma.masked]
+                        # Remove duplicates
+                        labeled_areas = list(set(labeled_areas))
+
+                        for curarea in labeled_areas:
+                            if curarea ==0:
+                                volume = 0.
+                                surface = 0.
+                                continue
+
+                            # Search
+                            mask = labeled_array == curarea
+                            area = np.where(mask)
+                            volume = -self.dx * self.dy * np.sum(diff[area])
+                            surface = self.dx * self.dy * len(area[0])
+                            extensionmax.array[np.logical_and(mask, extensionmax.array[:, :] == 0.)] = float(i + 1)
 
-                longueur = list(sum_labels(np.ones(labeled_array.shape, dtype=np.int32), labeled_array, range(1, num_features+1)))
-
-                longueur.sort(key=lambda x: x[0], reverse=True)
+                    else:
+                        labeled_areas = list(sum_labels(np.ones(labeled_array.shape, dtype=np.int32), labeled_array, range(1, num_features+1)))
+                        labeled_areas = [[x, y] for x, y in zip(labeled_areas, range(1, num_features+1))]
+                        labeled_areas.sort(key=lambda x: x[0], reverse=True)
+                        jmax = labeled_areas[0][1]
+                        nbmax = labeled_areas[0][0]
+
+                        volume = -self.dx * self.dy * np.sum(diff[labeled_array == jmax])
+                        surface = self.dx * self.dy * nbmax
+                        extensionmax.array[np.logical_and(labeled_array == jmax, extensionmax.array[:, :] == 0.)] = float(i + 1)
+                else:
+                    # Only one cell below the elevation
+                    volume = -self.dx * self.dy * np.sum(diff)
+                    surface = self.dx * self.dy * np.count_nonzero(diff<0.)
+                    extensionmax.array[np.logical_and(diff[:,:]<0., extensionmax.array[:, :] == 0.)] = float(i + 1)
 
-                jmax = longueur[0][1]
-                nbmax = longueur[0][0]
-                volume = -self.dx * self.dy * np.sum(diff[labeled_array == jmax])
-                surface = self.dx * self.dy * nbmax
                 stockage.append([volume, surface])
                 curz += deltaz
 
-                extensionmax.array[np.logical_and(labeled_array == jmax, extensionmax.array[:, :] == 0.)] = float(i + 1)
         else:
-            for i in range(nb + 1):
-                logging.info(_('  Step ') +str(i))
+            for i in tqdm(range(nb + 1)):
                 z.append(curz)
 
                 if i == 0:
@@ -6597,7 +6743,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                 extensionmax.array[np.logical_and(diff[:,:]<0., extensionmax.array[:, :] == 0.)] = float(i + 1)
 
-        dlg = wx.FileDialog(None, _('Choose filename'), wildcard='bin (*.bin)|*.bin|All (*.*)|*.*', style=wx.FD_SAVE)
+        dlg = wx.FileDialog(None, _('Choose filename for zoning result'), wildcard='bin (*.bin)|*.bin|tif (*.tif)|*.tif|All (*.*)|*.*', style=wx.FD_SAVE)
         ret = dlg.ShowModal()
         if ret == wx.ID_CANCEL:
             dlg.Destroy()
@@ -6611,22 +6757,25 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         if axs is None:
             fig, axs = plt.subplots(1, 2, tight_layout=True)
+        else:
+            fig = axs[0].get_figure()
+
         axs[0].plot(z, [x[0] for x in stockage])
         axs[0].scatter(z, [x[0] for x in stockage])
         axs[0].set_xlabel(_("Elevation [m]"), size=15)
-        axs[0].set_ylabel(_("Volume [m^3]"), size=15)
+        axs[0].set_ylabel(_("Volume [$m^3$]"), size=15)
         axs[1].step(z, [x[1] for x in stockage], where='post')
         axs[1].scatter(z, [x[1] for x in stockage])
         axs[1].set_xlabel(_("Elevation [m]"), size=15)
-        axs[1].set_ylabel(_("Surface [m^2]"), size=15)
-        plt.suptitle(_("Retention capacity of the selected zone"), fontsize=20)
+        axs[1].set_ylabel(_("Surface [$m^2$]"), size=15)
+        fig.suptitle(_("Retention capacity of the selected zone"), fontsize=20)
 
         with open(fn[:-4] + '_hvs.txt', 'w') as f:
-            f.write('H [m]\tZ [m DNG]\tVolume [m^3]\tSurface [m^2]\n')
+            f.write('H [m]\tZ [m DNG]\tVolume [$m^3$]\tSurface [$m^2$]\n')
             for curz, (curv, curs) in zip(z, stockage):
                 f.write('{}\t{}\t{}\t{}\n'.format(curz - zmin, curz, curv, curs))
 
-        return axs
+        return fig, axs
 
     def paste_all(self, fromarray:"WolfArray", mask_after:bool=True):
         """ Paste all the values from another WolfArray """
@@ -6737,6 +6886,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                 dtype = np.int16
             elif self.wolftype == WOLF_ARRAY_FULL_INTEGER8:
                 dtype = np.int8
+            elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+                dtype = np.uint8
 
         self.dx = myhead.dx
         self.dy = myhead.dy
@@ -6907,20 +7058,24 @@ class WolfArray(Element_To_Draw, header_wolf):
         self.plotted = False
 
         if unload and self.filename != '':
-            if askquestion and self.wx_exists:
-                dlg = wx.MessageDialog(None,
-                                    _('Do you want to unload data? \n If YES, the data will be reloaded from file once checekd \n If not saved, modifications will be lost !!'),
-                                    style=wx.YES_NO)
-                ret = dlg.ShowModal()
-                if ret == wx.ID_YES:
-                        unload=True
+            if Path(self.filename).exists():
+                # An array can exists with a filename but no written data on disk
+                # In this case, we don't want to delete the data in memory
 
-            if unload:
-                self.delete_lists()
-                self.array = np.zeros([1])
-                if VERSION_RGB==1 : self.rgb = None
-                self.loaded = False
-                return
+                if askquestion and self.wx_exists:
+                    dlg = wx.MessageDialog(None,
+                                        _('Do you want to unload data? \n If YES, the data will be reloaded from file once checekd \n If not saved, modifications will be lost !!'),
+                                        style=wx.YES_NO)
+                    ret = dlg.ShowModal()
+                    if ret == wx.ID_YES:
+                            unload=True
+
+                if unload:
+                    self.delete_lists()
+                    self.array = np.zeros([1])
+                    if VERSION_RGB==1 : self.rgb = None
+                    self.loaded = False
+                    return
 
         if not forceresetOGL:
             if askquestion and self.wx_exists:
@@ -7556,6 +7711,9 @@ class WolfArray(Element_To_Draw, header_wolf):
                 elif locarray.dtype == np.int8:
                     self.wolftype = WOLF_ARRAY_FULL_INTEGER8
                     logging.warning(_('Data type changed to int8'))
+                elif locarray.dtype == np.uint8:
+                    self.wolftype = WOLF_ARRAY_FULL_UINTEGER8
+                    logging.warning(_('Data type changed to uint8'))
                 else:
                     logging.error(_('Unsupported type in numpy file -- Abort wrting header file'))
                     writing_header = False
@@ -7863,6 +8021,9 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER8]:
             locarray = np.frombuffer(f.read(self.nbx * self.nby * 2), dtype=np.int8)
             self.array = ma.masked_array(locarray.copy(), dtype=np.int8)
+        elif self.wolftype in [WOLF_ARRAY_FULL_UINTEGER8]:
+            locarray = np.frombuffer(f.read(self.nbx * self.nby * 2), dtype=np.uint8)
+            self.array = ma.masked_array(locarray.copy(), dtype=np.uint8)
 
         if self.nbdims == 2:
             self.array = self.array.reshape(self.nbx, self.nby, order='F')
@@ -8075,6 +8236,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                     value=np.int16(value)
                 elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER8]:
                     value=np.int8(value)
+                elif self.wolftype in [WOLF_ARRAY_FULL_UINTEGER8]:
+                    value=np.uint8(value)
         except:
             logging.error(_('Type not supported : {} - {}'.format(value, type(value))))
             logging.warning(_('Masking operation compromised'))
@@ -8431,7 +8594,7 @@ class WolfArray(Element_To_Draw, header_wolf):
 
         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]:
+            if self.wolftype not in [WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_UINTEGER8]:
                 # 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)
@@ -8442,6 +8605,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif VERSION_RGB in [2 ,3]:
             if self.wolftype not in [WOLF_ARRAY_FULL_SINGLE,
                                      WOLF_ARRAY_FULL_INTEGER8,
+                                     WOLF_ARRAY_FULL_UINTEGER8,
                                      WOLF_ARRAY_FULL_INTEGER16,
                                      WOLF_ARRAY_FULL_INTEGER16_2,
                                      WOLF_ARRAY_FULL_INTEGER,
@@ -8691,6 +8855,14 @@ class WolfArray(Element_To_Draw, header_wolf):
                             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 == WOLF_ARRAY_FULL_UINTEGER8:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_uint8_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_uint8_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:
@@ -8747,6 +8919,14 @@ class WolfArray(Element_To_Draw, header_wolf):
                             elif self.nbnotnull > 0:
                                 wolfogl.addmeall_int8_pal_mask(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), self.array.mask)
+                        elif self.wolftype == WOLF_ARRAY_FULL_UINTEGER8:
+                            if self.nbnotnull != self.nbx * self.nby:
+                                if self.nbnotnull > 0:
+                                    wolfogl.addme_uint8_pal_mask(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), self.array.mask)
+                            elif self.nbnotnull > 0:
+                                wolfogl.addmeall_uint8_pal_mask(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), self.array.mask)
                         elif self.wolftype in [WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_INTEGER16_2]:
                             if self.nbnotnull != self.nbx * self.nby:
                                 if self.nbnotnull > 0:
@@ -9014,6 +9194,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                 return WOLF_ARRAY_FULL_INTEGER
             elif curarray.dtype == np.int8:
                 return WOLF_ARRAY_FULL_INTEGER8
+            elif curarray.dtype == np.uint8:
+                return WOLF_ARRAY_FULL_UINTEGER8
 
         self.array = np.ma.array(array.copy())
         self.wolftype = wolftype_from_npz(array)