wolfhece 2.2.16__py3-none-any.whl → 2.2.17__py3-none-any.whl

wolfhece/PyDraw.py

@@ -797,7 +797,12 @@ class DragdropFileTarget(wx.FileDropTarget):
                     id = id + '_1'
 
                 try:
-                    newobj = WolfArray(fname=name, mapviewer= self.window)
+                    h = header_wolf.read_header(name)
+
+                    if h.nb_blocks>0:
+                        newobj = WolfArrayMB(fname=name, mapviewer= self.window)
+                    else:
+                        newobj = WolfArray(fname=name, mapviewer= self.window)
                     self.window.add_object('array', newobj = newobj, id  = id)
                 except:
                     logging.error(_('Error while loading array : ') + name)
@@ -2887,7 +2892,7 @@ class WolfMapViewer(wx.Frame):
             self.menuwolf2d.AppendSeparator()
 
             self.menu2d_dangermap = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map"), _("Compute the danger map"))
-            # self.menu2d_dangermap_mp = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map (multiprocess)"), _("Compute the danger map using multiprocessing -- Need to duplicate the model, the memory usage can be very high for large model"))
+            self.menu2d_dangermap_mp = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map (multiprocess)"), _("Compute the danger map using multiprocessing -- Need to duplicate the model, the memory usage can be very high for large model"))
             self.menu2d_dangermaph = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map - only h"), _("Compute the danger map - only waterdepth"))
 
             self.menuwolf2d.AppendSeparator()
@@ -3519,16 +3524,21 @@ class WolfMapViewer(wx.Frame):
                 every = dlg.GetValue()
 
             if itemlabel == _("Danger map"):
+                logging.info(_('Danger map -- Be patient !'))
                 pgbar = wx.ProgressDialog(_('Danger map'), _('Danger map'), maximum = end_step-1, parent=self, style = wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
                 def _callback(id, msg):
                     pgbar.Update(id+1-start_step, msg)
 
-                danger_maps = self.active_res2d.danger_map_multiprocess(start_step-1, end_step-1, every, _callback)
+                danger_maps = self.active_res2d.danger_map(start_step-1, end_step-1, every, _callback)
 
                 pgbar.Hide()
                 pgbar.Destroy()
+                logging.info(_('Danger map done !'))
             else:
+
+                logging.info(_('Multiprocess danger map -- Be patient !'))
                 danger_maps = self.active_res2d.danger_map_multiprocess(start_step-1, end_step-1, every)
+                logging.info(_('Multiprocess danger map done !'))
 
             with wx.DirDialog(None, _('Choose a directory to store results'), style=wx.DD_DEFAULT_STYLE) as dlg:
 
@@ -3537,9 +3547,24 @@ class WolfMapViewer(wx.Frame):
 
                 outdir = dlg.GetPath()
 
-            names = ['danger_h.tif', 'danger_u.tif', 'danger_q.tif', 'danger_Z.tif', 'danger_head.tif']
+            names = ['danger_h', 'danger_u',
+                     'danger_q', 'danger_Z',
+                     'danger_head',
+                     'danger_toal', 'danger_tom']
+
             for name, danger_map in zip(names, danger_maps):
-                danger_map.write_all(Path(outdir) / name)
+
+                if isinstance(danger_map, WolfArrayMB):
+                    name = name + '.bin'
+                    logging.info(_('Saving danger map {}').format(name))
+                    danger_map.write_all(Path(outdir) / name)
+                elif isinstance(danger_map, WolfArray):
+                    name = name + '.tif'
+                    logging.info(_('Saving danger map {}').format(name))
+                    danger_map.write_all(Path(outdir) / name)
+                else:
+                    logging.error(_('Bad type for danger map {} -- not saved !').format(name))
+                    continue
 
         elif itemlabel == _("Setup cache..."):
 

wolfhece/PyParams.py

@@ -333,6 +333,35 @@ class Wolf_Param(wx.Frame):
                           toShow,
                           toolbar=toolbar)
 
+    def __getstate__(self):
+        state =  self.__dict__.copy()
+        # Remove the wxPython GUI from the state to avoid pickling issues
+        state.pop('prop', None)
+        state.pop('sizer', None)
+        state.pop('callback', None)
+        state.pop('callbackdestroy', None)
+        state.pop('DestroyAtClosing', None)
+        state.pop('show_in_active_if_default', None)
+        state.pop('sizerbut', None)
+        state.pop('myIncGroup', None)
+        state.pop('myIncParam', None)
+        state.pop('update_incr_at_every_change', None)
+        state.pop('wxparent', None)
+        state.pop('gui_hydrometry', None)
+        state.pop('cloud_stations_real', None)
+        state.pop('cloud_stations', None)
+        state.pop('gui_hydrometry', None)
+
+        return state
+
+    def __setstate__(self, state):
+
+        self.__dict__.update(state)
+
+        # Reinitialize the wxPython GUI if it was not initialized before pickling
+        if self.wx_exists:
+            self._set_gui()
+
     @property
     def has_prop(self) -> bool:
         """ Return True if the property grid is available """

wolfhece/Results2DGPU.py

@@ -193,11 +193,17 @@ class wolfres2DGPU(Wolfresults_2D):
             if key in dct:
                 dct.pop(key)
 
+        dct['isGPU'] = True
+
         return dct
 
     def __setstate__(self, dct):
+
         super().__setstate__(dct)
 
+        self._loader(self.filename)
+        self._post_loader()
+
         self._result_store = None
         self._cache = None
         self.setup_store(self._result_store)

wolfhece/apps/version.py

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

wolfhece/assets/mesh.py

@@ -16,7 +16,7 @@ class Mesh2D(header_wolf):
         self.shape = src_header.shape
         self._factor = None
 
-    def plot_cells(self, ax:Axes=None, color='black', **kwargs):
+    def plot_cells(self, ax:Axes=None, transpose:bool= False, color='black', **kwargs):
         """ Plot the grid of the mesh.
         """
 
@@ -27,13 +27,28 @@ class Mesh2D(header_wolf):
 
         [xmin, xmax], [ymin, ymax] = self.get_bounds()
 
-        for y in np.linspace(ymin, ymax, endpoint=True, num=self.nby + 1):
-            ax.plot([xmin, xmax], [y, y], color=color, **kwargs)
+        if transpose:
+
+            # plot the grid of the mesh in a transposed way
+            for x in np.linspace(xmin, xmax, endpoint=True, num=self.nbx + 1):
+                ax.plot([ymin, ymax], [x, x], color=color, **kwargs)
 
-        for x in np.linspace(xmin, xmax, endpoint=True, num=self.nbx + 1):
-            ax.plot([x, x], [ymin, ymax], color=color, **kwargs)
+            for y in np.linspace(ymin, ymax, endpoint=True, num=self.nby + 1):
+                ax.plot([y, y], [xmin, xmax], color=color, **kwargs)
+
+            self.set_aspect_labels_matrice(ax=ax, **kwargs)
+
+        else:
+
+            # plot the grid of the mesh
+            for y in np.linspace(ymin, ymax, endpoint=True, num=self.nby + 1):
+                ax.plot([xmin, xmax], [y, y], color=color, **kwargs)
+
+            for x in np.linspace(xmin, xmax, endpoint=True, num=self.nbx + 1):
+                ax.plot([x, x], [ymin, ymax], color=color, **kwargs)
+
+            self.set_aspect_labels(ax=ax, **kwargs)
 
-        self.set_aspect_labels(ax=ax, **kwargs)
         return fig, ax
 
     def plot_center_cells(self, ax:Axes=None, color='black', linestyle='--', **kwargs):
@@ -77,6 +92,34 @@ class Mesh2D(header_wolf):
 
         return fig, ax
 
+    def set_ticks_as_matrice(self, ax:Axes=None, Fortran_type:bool = True, **kwargs):
+        """ Set the ticks of the axis as the row and column of a matrice """
+
+        if ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
+        [xmin, xmax], [ymin, ymax] = self.get_bounds()
+
+        if Fortran_type:
+            x_ticks = [f'{i}' for i in range(1,self.nbx+1)]
+            y_ticks = [f'{i}' for i in range(1,self.nby+1)]
+        else:
+            x_ticks = [f'{i}' for i in range(self.nbx)]
+            y_ticks = [f'{i}' for i in range(self.nby)]
+
+        ax.set_yticks(np.linspace(xmin+self.dx/2., xmax-self.dx/2., endpoint=True, num=self.nbx))
+        ax.set_xticks(np.linspace(ymin+self.dy/2., ymax-self.dy/2., endpoint=True, num=self.nby))
+        
+        x_ticks.reverse()
+        ax.set_yticklabels(x_ticks)
+        ax.set_xticklabels(y_ticks)
+
+        self.set_aspect_labels_matrice(ax=ax, **kwargs)
+
+        return fig, ax
+
     def plot_circle_at_centers(self, ax:Axes=None, color='black', radius:float=None, **kwargs):
         """ Plot circles at the center of the cells.
         """
@@ -124,6 +167,64 @@ class Mesh2D(header_wolf):
         self.set_aspect_labels(ax=ax, **kwargs)
 
         return fig, ax
+    
+    def plot_memoryposition_at_centers(self, ax:Axes=None, 
+                                       transpose=False, 
+                                       Fortran_type:bool = True, 
+                                       f_contiguous:bool = True,
+                                       **kwargs):
+        """ Plot the position of the cells at the center of the cells.
+        """
+
+        if ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
+        [xmin, xmax], [ymin, ymax] = self.get_bounds()
+
+        if transpose:
+            k = 0
+            if Fortran_type:
+                k+=1
+
+            all_y = list(np.linspace(xmin + self.dx/2., xmax - self.dx/2., endpoint=True, num=self.nbx))
+            all_x = list(np.linspace(ymin + self.dy/2., ymax - self.dy/2., endpoint=True, num=self.nby))
+
+            all_y.reverse()
+
+            if f_contiguous:
+
+                for x in all_x:
+                    for y in all_y:
+
+                        ax.text(x, y, f'{k}', horizontalalignment='center', verticalalignment='center', **kwargs)
+                        k+=1
+            else:
+
+                for y in all_y:
+                    for x in all_x:
+
+                        ax.text(x, y, f'{k}', horizontalalignment='center', verticalalignment='center', **kwargs)
+                        k+=1
+                        
+            self.set_aspect_labels_matrice(ax=ax, **kwargs)
+
+        else:
+            
+            k = 0
+            if Fortran_type:
+                k+=1
+
+            for y in np.linspace(ymin + self.dy/2., ymax - self.dy/2., endpoint=True, num=self.nby):
+                for x in np.linspace(xmin + self.dx/2., xmax - self.dx/2., endpoint=True, num=self.nbx):
+
+                    ax.text(x, y, f'{k}', horizontalalignment='center', verticalalignment='center', **kwargs)
+                    k+=1
+
+            self.set_aspect_labels(ax=ax, **kwargs)
+
+        return fig, ax
 
     def plot_indices_at_bordersX(self, ax:Axes=None, Fortran_type:bool = True, **kwargs):
         """ Plot the indices of the cells at the borders of the cells.
@@ -599,6 +700,27 @@ class Mesh2D(header_wolf):
         ax.set_xlabel('X (m)')
         ax.set_ylabel('Y (m)')
         return fig, ax
+    
+    def set_aspect_labels_matrice(self, ax:Axes=None, **kwargs):
+        """ Set the aspect of the plot to be equal.
+        """
+        if ax is None:
+            fig, ax = plt.subplots()
+        else:
+            fig = ax.figure
+
+        [xmin, xmax], [ymin, ymax] = self.get_bounds()
+
+        ax.set_aspect('equal')
+        ax.set_ylim(xmin, xmax)
+        ax.set_xlim(ymin, ymax)
+        ax.set_xlabel('columns')
+        ax.set_ylabel('rows')
+
+        #set x ais on the upper side
+        ax.xaxis.set_ticks_position('top')
+        ax.xaxis.set_label_position('top')
+        return fig, ax
 
     def zeros(self):
         """ Return a 2D array of zeros with the shape of the mesh.

wolfhece/hydrometry/kiwis_wolfgui.py

@@ -13,14 +13,13 @@ import logging
 
 from ..drawing_obj import Element_To_Draw
 
-# try:
-#     # Trying to import the hydrometry_hece module from the hydrometry_hece package
-#     # containing the KEY access to the SPW server
-#     from ..hydrometry_hece.kiwis_hece import hydrometry_hece as hydrometry
-# except:
-#     # If the hydrometry_hece module is not found, we import the hydrometry module from the hydrometry package
-#     from .kiwis import hydrometry
-from .kiwis import hydrometry
+try:
+    # Trying to import the hydrometry_hece module from the hydrometry_hece package
+    # containing the KEY access to the SPW server
+    from ..hydrometry_hece.kiwis_hece import hydrometry_hece as hydrometry
+except:
+    # If the hydrometry_hece module is not found, we import the hydrometry module from the hydrometry package
+    from .kiwis import hydrometry
 
 from .kiwis_gui import hydrometry_gui
 from ..PyVertex import cloud_vertices, wolfvertex, Cloud_Styles, getIfromRGB, getRGBfromI

wolfhece/wolf_array.py

@@ -7699,7 +7699,7 @@ class WolfArray(Element_To_Draw, header_wolf):
                                         self.nby)
                         cursel = [(x, y) for x in xall for y in yall]
 
-                    z = griddata(curlist, z, cursel, fill_value=np.NaN)
+                    z = griddata(curlist, z, cursel, fill_value=np.nan)
 
                     for cur, curz in zip(cursel, z):
                         if not np.isnan(curz):
@@ -10068,7 +10068,8 @@ class WolfArray(Element_To_Draw, header_wolf):
                         figsize:tuple=None,
                         Walonmap:bool=False,
                         cat:str='IMAGERIE/ORTHO_2022_ETE',
-                        first_mask_data:bool=True):
+                        first_mask_data:bool=True,
+                        with_legend:bool=False):
         """
         Plot the array - Matplotlib version
 
@@ -10117,6 +10118,10 @@ class WolfArray(Element_To_Draw, header_wolf):
             - `'IMAGERIE/ORTHO_2023_ETE'`
             - `'IMAGERIE/ORTHO_LAST'`
         :type cat: str, optional (Default value = `'IMAGERIE/ORTHO_2022_ETE'`)
+        :param first_mask_data: If True, applies the mask to the data before plotting. Default is True.
+        :type first_mask_data: bool, optional (Default value = True)
+        :param with_legend: If True, adds a color legend to the plot. Default is False.
+        :type with_legend: bool, optional (Default value = False)
         :return: If `getdata_im` is False, returns (fig, ax), where `fig` is the Matplotlib figure and `ax` is the axis. If `getdata_im` is True, returns (fig, ax, im), where `im` is the image object created by `imshow`.
         :rtype: tuple
         """
@@ -10146,6 +10151,11 @@ class WolfArray(Element_To_Draw, header_wolf):
                 logging.error(_('Error while fetching the map image from WalOnMap'))
                 logging.error(e)
 
+        if vmin is None and vmax is not None:
+            vmin = self.mypal.values[0]
+        elif vmax is None and vmin is not None:
+            vmax = self.mypal.values[-1]
+
         if (vmin is None) and (vmax is None):
             # im = ax.imshow(self.array.transpose(), origin='lower', cmap=self.mypal,
             #         extent=(self.origx, self.origx + self.dx * self.nbx, self.origy, self.origy + self.dy * self.nby))
@@ -10160,6 +10170,21 @@ class WolfArray(Element_To_Draw, header_wolf):
                                    self.origy + self.dy * self.nby),
                             alpha=np.select([self.array.mask.T, ~self.array.mask.T],
                                             [np.zeros(self.shape).T, np.ones(self.shape).T]))
+
+            if with_legend:
+                # add a legend in a new axis
+                ax_leg = fig.add_axes([0.92, 0.12, 0.04, 0.8])
+                from matplotlib.colorbar import ColorbarBase
+                from matplotlib import colors
+                cbar = ColorbarBase(ax_leg, cmap=self.mypal.cmap, norm=self.mypal.norm, orientation='vertical')
+                cbar.set_ticks(self.mypal.values)
+                cbar.set_ticklabels(self.mypal.values)
+                cbar.ax.tick_params(labelsize=8)
+                cbar.ax.yaxis.set_label_position('left')
+                cbar.ax.yaxis.set_ticks_position('right')
+                cbar.ax.yaxis.set_tick_params(width=0.5, size=2, direction='in', color='black')
+
+
         else:
             im = ax.imshow(self.array.transpose(),
                            origin='lower',
@@ -10171,7 +10196,27 @@ class WolfArray(Element_To_Draw, header_wolf):
                            vmin=vmin, vmax=vmax,
                            alpha=np.select([self.array.mask.T, ~self.array.mask.T],
                                            [np.zeros(self.shape).T, np.ones(self.shape).T])                           )
+
+
+            if with_legend:
+                # add a legend in a new axis
+                ax_leg = fig.add_axes([0.92, 0.12, 0.04, 0.8])
+                from matplotlib.colorbar import ColorbarBase
+                from matplotlib import colors
+                from matplotlib.colors import Normalize
+                cbar = ColorbarBase(ax_leg, cmap=self.mypal.cmap, norm= Normalize(vmin, vmax), orientation='vertical')
+                vals = list(np.linspace(vmin, vmax, self.mypal.nb, endpoint=True))
+                # limit to 2 decimal places
+                vals = [round(val, 2) for val in vals]
+                cbar.set_ticks(vals)
+                cbar.set_ticklabels(vals)
+                cbar.ax.tick_params(labelsize=8)
+                cbar.ax.yaxis.set_label_position('left')
+                cbar.ax.yaxis.set_ticks_position('right')
+                cbar.ax.yaxis.set_tick_params(width=0.5, size=2, direction='in', color='black')
+
         ax.set_aspect('equal')
+        fig.tight_layout()
 
         if getdata_im:
             return fig, ax, im
@@ -11437,7 +11482,7 @@ class WolfArrayMB(WolfArray):
         :param j: j index
         :param which_block: block index 1-based
         """
-        h = np.NaN
+        h = np.nan
         if which_block == 0:
             logging.warning("Block index is probably 0-based. It should be 1-based.")
             return h
@@ -11458,7 +11503,7 @@ class WolfArrayMB(WolfArray):
         Read the value at world coordinate (x,y). if `abs` is
         given, then the translation is is taken into account.
 
-        If no block covers the coordinate, then np.NaN is returned
+        If no block covers the coordinate, then np.nan is returned
         If several blocks cover the given coordinate then the first
         match is returned (and thus, the others are ignored).
 
@@ -11466,10 +11511,10 @@ class WolfArrayMB(WolfArray):
         :param y: y coordinate
         :param abs: if True, then the translation is taken into account
 
-        :return: the value at (x,y) or np.NaN if no block covers the coordinate
+        :return: the value at (x,y) or np.nan if no block covers the coordinate
         """
 
-        h = np.NaN
+        h = np.nan
         for curblock in self.myblocks.values():
             curblock: WolfArray
             nbx = curblock.nbx
@@ -12101,7 +12146,8 @@ class WolfArrayMB(WolfArray):
                         figsize:tuple=None,
                         Walonmap:bool=False,
                         cat:str='IMAGERIE/ORTHO_2022_ETE',
-                        first_mask_data:bool=True):
+                        first_mask_data:bool=True,
+                        with_legend:bool=False):
         """
         Plot the multi-block (MB) array - Matplotlib version
 
@@ -12153,6 +12199,10 @@ class WolfArrayMB(WolfArray):
             - `'IMAGERIE/ORTHO_2023_ETE'`
             - `'IMAGERIE/ORTHO_LAST'`
         :type cat: str, optional (Default value = `'IMAGERIE/ORTHO_2022_ETE'`)
+        :param first_mask_data: If True, applies the mask to the data before plotting. Default is True.
+        :type first_mask_data: bool, optional (Default value = True)
+        :param with_legend: If True, adds a color legend to the plot. Default is False.
+        :type with_legend: bool, optional (Default value = False)
         :return: If `getdata_im` is False, returns (fig, ax), where `fig` is the Matplotlib figure and `ax` is the axis. If `getdata_im` is True, returns (fig, ax, im), where `im` is the image object created by `imshow`.
         :rtype: tuple
         """
@@ -12167,7 +12217,8 @@ class WolfArrayMB(WolfArray):
                                             figsize=figsize,
                                             Walonmap=Walonmap,
                                             cat=cat,
-                                            first_mask_data=first_mask_data)
+                                            first_mask_data=first_mask_data,
+                                            with_legend=with_legend)
 
 
 class WolfArrayMNAP(WolfArrayMB):