wolfhece 2.2.23__py3-none-any.whl → 2.2.25__py3-none-any.whl

wolfhece/Coordinates_operations.py

@@ -1,4 +1,5 @@
 from pyproj import Transformer
+from pyproj.transformer import TransformerGroup
 from concurrent.futures import ProcessPoolExecutor
 import numpy as np
 from osgeo import gdal
@@ -19,7 +20,8 @@ def transform_chunk_coordinates(inputEPSG:str, outputEPSG:str, chunk:np.ndarray)
     :type chunk: np.ndarray
     """
     COO_TRANSFORMER = Transformer.from_crs(inputEPSG, outputEPSG, always_xy=True)
-    return COO_TRANSFORMER.transform(chunk[:, 0], chunk[:, 1])
+    ret = COO_TRANSFORMER.transform(chunk[:, 0], chunk[:, 1])
+    return ret
 
 def transform_coordinates(points:np.ndarray, inputEPSG:str="EPSG:3812", outputEPSG:str="EPSG:31370", chunk_size:int=1000):
     """

wolfhece/PyDraw.py

@@ -4914,7 +4914,8 @@ class WolfMapViewer(wx.Frame):
                        dpi:int= 300,
                        add_title:bool = False,
                        figsizes= [10.,10.],
-                       arrayid_as_title:bool = False):
+                       arrayid_as_title:bool = False,
+                       resid_as_title:bool = False):
         """
         Sauvegarde de la fenêtre d'affichage dans un fichier
 
@@ -4970,6 +4971,8 @@ class WolfMapViewer(wx.Frame):
                 pot_title = self.viewer_name
                 if arrayid_as_title:
                     pot_title = self.active_array.idx
+                if resid_as_title:
+                    pot_title = self.active_res2d.idx
 
                 self.display_canvasogl(fig=fig,
                                        ax=ax,
@@ -9919,16 +9922,21 @@ class WolfMapViewer(wx.Frame):
 
         # Get all checked arrays
         checked_arrays = self.get_list_keys(drawing_type= draw_type.ARRAYS, checked_state= True)
+        checked_results = self.get_list_keys(drawing_type= draw_type.RES2D, checked_state= True)
+
         old_active = self.active_array
+        old_res2d = self.active_res2d
 
-        if len(checked_arrays) == 0:
+        if len(checked_arrays) + len(checked_results) == 0:
             logging.warning(_('No arrays checked for export'))
-            return
+            return []
 
         def uncheck_all():
             # uncheck arrays
             for curarray in checked_arrays:
                 self.uncheck_id(curarray, unload= False, forceresetOGL= False)
+            for curres in checked_results:
+                self.uncheck_id(curres, unload= False, forceresetOGL= False)
 
         fn = str(fn)
         ret = []
@@ -9938,10 +9946,21 @@ class WolfMapViewer(wx.Frame):
             self.active_array = self.get_obj_from_id(curel, drawtype= draw_type.ARRAYS)
             ret.append((self.save_canvasogl(fn + '_' + str(idx) + '.png', mpl, ds, add_title= add_title, arrayid_as_title=True), curel))
 
+        for idx, curel in enumerate(checked_results):
+            uncheck_all()
+            self.check_id(curel)
+            self.active_res2d = self.get_obj_from_id(curel, drawtype= draw_type.RES2D)
+            ret.append((self.save_canvasogl(fn + '_' + str(idx + len(checked_arrays)) + '.png', mpl, ds, add_title= add_title, resid_as_title=True), curel))
+
         self.active_array = old_active
+        self.active_res2d = old_res2d
+
         for curarray in checked_arrays:
             self.check_id(curarray)
 
+        for curres in checked_results:
+            self.check_id(curres)
+
         self.Refresh()
 
         return ret
@@ -11757,6 +11776,97 @@ class WolfMapViewer(wx.Frame):
             else:
                 logging.warning(_('Reload not yet implemented for this type of object'))
 
+        elif _('Rasterize active zone') in text:
+
+            if self.active_array is None and self.active_res2d is None:
+                logging.warning(_('No active array selected'))
+                return
+
+            if self.active_array is not None and self.active_res2d is not None:
+                # Show a dialog to choose between array or res2d
+                dlg = wx.SingleChoiceDialog(None, _('Choose the type of rasterization'), _('Rasterization Type'), ['Array', 'Res2D'], style=wx.CHOICEDLG_STYLE)
+                ret = dlg.ShowModal()
+                if ret != wx.ID_OK:
+                    dlg.Destroy()
+                    return
+                choice = dlg.GetSelection()
+                dlg.Destroy()
+                if choice == 0:
+                    based_array = self.active_array
+                else:
+                    if self.active_res2d.nb_blocks == 1:
+                        based_array = self.active_res2d.get_header_block(1)
+                    elif self.active_res2d.nb_blocks > 1:
+                        logging.error(_('Rasterization not implemented for multi-blocks res2d -- Convert to mono-blocks first'))
+                        return
+
+            elif self.active_array is not None:
+                based_array = self.active_array
+            elif self.active_res2d is not None:
+                if self.active_res2d.nb_blocks == 1:
+                    based_array = self.active_res2d.get_header_block(1)
+                elif self.active_res2d.nb_blocks > 1:
+                    logging.error(_('Rasterization not implemented for multi-blocks res2d -- Convert to mono-blocks first'))
+                    return
+
+            if isinstance(self.selected_object, Zones):
+                if self.selected_object.active_zone is None:
+                    logging.warning(_('No active zone selected'))
+                    return
+                if self.selected_object.active_zone.parent is None:
+                    logging.warning(_('No parent object for the active zone'))
+                else:
+                    new_zone = based_array.rasterize_zone_along_grid(self.selected_object.active_zone, outformat= zone)
+                    if new_zone is not None:
+                        new_zone.myname = self.selected_object.active_zone.myname + '_rasterized'
+                        self.selected_object.active_zone.parent.add_zone(new_zone, forceparent=True)
+                        self.selected_object.active_zone.parent.fill_structure()
+                        self.selected_object.active_zone.reset_listogl()
+
+        elif _('Rasterize active vector') in text:
+
+            if self.active_array is None and self.active_res2d is None:
+                logging.warning(_('No active array selected'))
+                return
+
+            if self.active_array is not None and self.active_res2d is not None:
+                # Show a dialog to choose between array or res2d
+                dlg = wx.SingleChoiceDialog(None, _('Choose the type of rasterization'), _('Rasterization Type'), ['Array', 'Res2D'], style=wx.CHOICEDLG_STYLE)
+                ret = dlg.ShowModal()
+                if ret != wx.ID_OK:
+                    dlg.Destroy()
+                    return
+                choice = dlg.GetSelection()
+                dlg.Destroy()
+                if choice == 0:
+                    based_array = self.active_array
+                else:
+                    if self.active_res2d.nb_blocks == 1:
+                        based_array = self.active_res2d.get_header_block(1)
+                    elif self.active_res2d.nb_blocks > 1:
+                        logging.error(_('Rasterization not implemented for multi-blocks res2d -- Convert to mono-blocks first'))
+                        return
+
+            elif self.active_array is not None:
+                based_array = self.active_array
+            elif self.active_res2d is not None:
+                if self.active_res2d.nb_blocks == 1:
+                    based_array = self.active_res2d.get_header_block(1)
+                elif self.active_res2d.nb_blocks > 1:
+                    logging.error(_('Rasterization not implemented for multi-blocks res2d -- Convert to mono-blocks first'))
+                    return
+
+            if isinstance(self.selected_object, Zones):
+                if self.selected_object.active_vector is None:
+                    logging.warning(_('No active vector selected'))
+                    return
+
+                vec_raster = based_array.rasterize_vector_along_grid(self.selected_object.active_vector)
+                if vec_raster is not None:
+                    vec_raster.myname = self.selected_object.active_vector.myname + '_rasterized'
+                    self.selected_object.active_vector.parentzone.add_vector(vec_raster, forceparent=True, update_struct=True)
+                    self.selected_object.active_vector.parentzone.reset_listogl()
+
     def OnClose(self, event):
         """ Close the application """
 
@@ -14546,6 +14656,9 @@ class WolfMapViewer(wx.Frame):
             tracks.append(_('Load flight'))
             tracks.append(_('Save flight'))
 
+            tracks.append(_('Rasterize active zone'))
+            tracks.append(_('Rasterize active vector'))
+
             # Récupération des items du menu contextuel
             menuitems = self.popupmenu.GetMenuItems()
             text = [cur.GetItemLabelText() for cur in menuitems]
@@ -14583,6 +14696,10 @@ class WolfMapViewer(wx.Frame):
                 self.popupmenu.Append(wx.ID_ANY, _('Convert to multi-blocks (result)'), _('Convert to multi-blocks'))
                 self.popupmenu.Append(wx.ID_ANY, _('Extract current step as IC (result)'), _('Extract current step as IC'))
 
+            if isinstance(self.selected_object, Zones):
+                self.popupmenu.Append(wx.ID_ANY, _('Rasterize active zone'), _('Rasterize active zone'))
+                self.popupmenu.Append(wx.ID_ANY, _('Rasterize active vector'), _('Rasterize active vector'))
+
             if isinstance(self.selected_object, Zones | Bridge | Weir):
                 self.popupmenu.Append(wx.ID_ANY, _('Export to Shape file'), _('Export to Shape file'))
                 self.popupmenu.Append(wx.ID_ANY, _('Export active zone to Shape file'), _('Export active zone to Shape file'))

wolfhece/PyVertex.py

@@ -36,7 +36,6 @@ from .drawing_obj import Element_To_Draw
 from .textpillow import Text_Image, Text_Infos, Font_Priority
 from .wolf_texture import Text_Image_Texture
 
-
 def getRGBfromI(rgbint:int):
     """ Convert integer to RGB """
 
@@ -731,6 +730,20 @@ class cloud_vertices(Element_To_Draw):
                 curval = curline.split(sep)
                 nbcols = len(curval)
 
+                if not header:
+                    try:
+                        x = float(curval[0])
+                        y = float(curval[1])
+                        z = 0.
+                        if nbcols > 2:
+                            z = float(curval[2])
+                    except ValueError as e:
+                        logging.error(_('Error converting first row to float as "header" is set to False.'))
+                        logging.error(_('Check your input file : ')+fname)
+                        logging.info(_('Using the first row as header.'))
+                        header = True
+                        headers = curhead.split(sep)
+
             if nbcols < 2:
                 logging.warning(_('Not enough values on one line -- Retry !!'))
                 return

wolfhece/PyVertexvectors.py

@@ -1799,7 +1799,7 @@ class vector:
 
         myls = self.asshapely_ls()
 
-        mypar = myls.parallel_offset(distance=abs(distance),side=side,join_style=JOIN_STYLE.round)
+        mypar = myls.parallel_offset(distance=abs(distance), side=side, join_style=JOIN_STYLE.round)
 
         if mypar.geom_type=='MultiLineString':
             return None
@@ -1810,7 +1810,7 @@ class vector:
             #     #On souhaite garder une même orientation pour les vecteurs
             #     mypar = substring(mypar, 1., 0., normalized=True)
 
-            newvec = vector(name='par'+str(distance), parentzone=self.parentzone)
+            newvec = vector(name='par' + str(distance) +'_'+ self.myname, parentzone= self.parentzone)
 
             for x,y in mypar.coords:
                 xy = Point(x,y)
@@ -4133,8 +4133,8 @@ class zone:
         if mypl is None or mypr is None:
             return
 
-        self.add_vector(mypl,0)
-        self.add_vector(mypr,2)
+        self.add_vector(mypl, 0)
+        self.add_vector(mypr, 2)
 
     def create_multibin(self, nb:int = None, nb2:int = 0) -> Triangulation:
         """
@@ -7468,6 +7468,15 @@ class Zones(wx.Frame, Element_To_Draw):
             if self.verify_activevec():
                 return
 
+            if self.active_zone.nbvectors > 1:
+                dlg = wx.MessageDialog(None, _('You already have more than one vector in the active zone. This action will conserve only the active vector.\nDo you want to continue?'), _('Warning'), style=wx.YES_NO | wx.ICON_WARNING)
+                ret = dlg.ShowModal()
+                if ret == wx.ID_NO:
+                    dlg.Destroy()
+                    return
+                logging.warning(_('You already have more than one vector in the active zone. This action will conserve only the active vector and you want it.'))
+                dlg.Destroy()
+
             self.mapviewer.start_action('dynamic parallel', _('Dynamic parallel'))
 
             firstvert=wolfvertex(0.,0.)

wolfhece/Results2DGPU.py

@@ -14,7 +14,7 @@ from os import path
 from pathlib import Path
 from scipy.sparse import csr_array
 from multiprocessing import Pool
-from typing import Union
+from typing import Union, Literal
 from tqdm import tqdm
 import logging
 
@@ -26,41 +26,38 @@ from .CpGrid import CpGrid
 from .PyPalette import wolfpalette
 
 try:
-    from wolfgpu.results_store import ResultsStore, ResultType
+    from wolfgpu.results_store import ResultsStore, ResultType, PerformancePolicy
 except ImportError:
     logging.debug(_("Unable to import wolfgpu.results_store.ResultsStore. Please install wolfgpu package or add a symlink to the wolfgpu package in the wolfhece directory"))
 
-def _load_res(x) -> tuple[csr_array, csr_array, csr_array]:
+def _load_res(x) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     store:ResultsStore
     i:int
 
-    store, i = x
-    _, _, _, _, wd_np, qx_np, qy_np = store.get_result(i+1)
+    store, i, mode = x
 
-    if isinstance(wd_np, csr_array) and isinstance(qx_np, csr_array) and isinstance(qy_np, csr_array):
-        return wd_np, qx_np, qy_np
-    else:
-        return csr_array(wd_np), csr_array(qx_np), csr_array(qy_np)
+    _, _, _, _, wd_np, qx_np, qy_np = store.get_result(i+1, untile= mode == 'UNTILED')
+    return wd_np, qx_np, qy_np
 
-def _load_res_h(x) -> tuple[csr_array, csr_array, csr_array]:
+
+def _load_res_h(x) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
     store:ResultsStore
     i:int
 
-    store, i = x
-    wd_np = store.get_named_result('h',i+1)
+    store, i, mode = x
 
-    if isinstance(wd_np, csr_array):
-        return wd_np
-    else:
-        return csr_array(wd_np)
+    wd_np = store.get_named_result('h', i+1, untile= mode == 'UNTILED')
+    return wd_np
 
 class Cache_Results2DGPU():
     """
     Gestion en mémoire de plusieurs résultats GPU
-    Stockage CSR afin d'économiser la mémoire (Scipy CSR)
+    Stockage CSR afin d'économiser la mémoire (Scipy CSR) ou Numpy array dense
     """
 
-    def __init__(self, fname:str, start_idx:int, end_idx:int = -1, only_h=False) -> None:
+    def __init__(self, fname:str, start_idx:int, end_idx:int = -1,
+                 only_h=False, every:int= 1,
+                 mode:Literal['TILED', 'UNTILED'] = 'TILED', memory_max_size:int = 12 * 1024 * 1024 * 1024) -> None:
         """
         Chargement de résultats sur base du répertoire de sauvegarde de la simulation GPU
 
@@ -72,74 +69,198 @@ class Cache_Results2DGPU():
         :param start_idx: index de départ (0-based)
         :param end_idx: index de fin (0-based)
         :param only_h: lecture de la hauteur d'eau seulement
+        :param every: lecture de chaque ième résultat (1 = tous les résultats, 2 = un sur deux, etc.)
+        :param mode: 'TILED' pour les résultats en tuiles, 'UNTILED' pour les résultats non-tuilés
+        :param memory_max_size: taille mémoire maximale en octets pour le cache (par défaut 12 Go)
+
         """
 
-        self._results:Union[dict[str,tuple[csr_array, csr_array, csr_array]], dict[str,csr_array]] # typage
+        self._mode = mode
+        self._results:Union[dict[str,tuple[np.ndarray, np.ndarray, np.ndarray]], dict[str,np.ndarray]] # typage
 
         # ResultsStore unique
         self._result_store = ResultsStore(Path(fname), mode='r')
         self._only_h = only_h
+        self.memory_max_size = memory_max_size
+
+        mem_one_res = self._estimate_memory_size_one_result()
+        logging.info(_("Estimated memory size for one result: {:.2f} MB").format(mem_one_res))
+        self._maximum_n_results = int(self.memory_max_size // mem_one_res) if self.memory_max_size is not None else 10_000
 
         if end_idx == -1:
             end_idx = self._result_store.nb_results
 
         if end_idx>start_idx:
+
             self.start_idx = int(max(start_idx,0))
             self.end_idx   = int(min(end_idx, self._result_store.nb_results))
+            self._every = int(max(every, 1))
+
+            if (self.end_idx - self.start_idx) // self._every > self._maximum_n_results:
+                logging.warning(_("Too many results to cache in memory. "
+                                  "Only the first {} results will be cached.").format(self._maximum_n_results))
+                self.end_idx = int(min(int(self.start_idx + self._maximum_n_results * self._every), self._result_store.nb_results))
+
+            self._range_to_process = list(range(self.start_idx, self.end_idx, self._every))
+            if self.end_idx-1 not in self._range_to_process:
+                self._range_to_process.append(self.end_idx-1)
 
             # Lecture en multiprocess des résultats
             if only_h:
                 with Pool() as pool:
-                    _results = pool.map(_load_res_h, [(self._result_store,i) for i in range(self.start_idx, self.end_idx)])
+                    _results = pool.map(_load_res_h, [(self._result_store, i, mode) for i in self._range_to_process])
                     self._results = {i+1:res for i,res in enumerate(_results)}
             else:
                 with Pool() as pool:
-                    _results = pool.map(_load_res, [(self._result_store,i) for i in range(self.start_idx, self.end_idx)])
+                    _results = pool.map(_load_res, [(self._result_store, i, mode) for i in self._range_to_process])
                     self._results = {i+1:res for i,res in enumerate(_results)}
 
+    def _estimate_memory_size_one_result(self):
+        """ Read one result to estimate memory size """
+        res = self._result_store.get_result(1, untile=False)
+        if self._only_h:
+            return res[4].nbytes / 1024 / 1024
+        else:
+            return (res[4].nbytes + res[5].nbytes + res[6].nbytes) / 1024 / 1024
+
+    @property
+    def memory_size(self) -> int:
+        """
+        Estimation de la taille mémoire des résultats en cache
+
+        :return: taille mémoire en Mega-octets
+        """
+        if self._only_h:
+            return sum(res.nbytes for res in self._results.values()) / 1024 / 1024  # Convert to MB
+        else:
+            return sum(res[0].nbytes + res[1].nbytes + res[2].nbytes for res in self._results.values()) / 1024 / 1024  # Convert to MB
+
     @property
     def only_h(self):
         return self._only_h
 
-    def __getitem__(self,i:int):
+    @property
+    def _tile_packer(self):
+        """
+        Retourne le tile packer de la simulation
+        """
+        if self._result_store is not None:
+            return self._result_store.tile_packer()
+        else:
+            return None
+
+    def __getitem__(self, i:int):
         """Surcharge de l'opérateur []"""
         return self._results[i]
 
+    @property
+    def list_cached(self) -> list[int]:
+        """
+        Retourne la liste des indices des résultats en cache
+
+        :return: liste des indices (1-based)
+        """
+        return list(set(self._results.keys()))
+
+    def check_if_cached(self, idx:int) -> bool:
+        """
+        Vérifie si le résultat idx est dans le cache
+
+        :param idx: index du résultat (1-based)
+        :return: True si le résultat est dans le cache, False sinon
+        """
+
+        if idx not in self._results:
+            logging.info(_("Index {} not in cache").format(idx))
+            logging.info(_('We cache it now !'))
+
+            if self.only_h:
+                self._results[idx] = _load_res_h((self._result_store, idx-1, self._mode))
+            else:
+                self._results[idx] = _load_res((self._result_store, idx-1, self._mode))
+
+        return True
+
     def get_h(self, idx:int, dense:bool=True) -> Union[np.ndarray, csr_array]:
         """
         Retourne la matrice de hauteur d'eau de la position idx (0-based)
             - en CSR (Scipy CSR)
             - en dense (Numpy array)
+
+        :param idx: index du résultat (1-based)
+        :param dense: si True, retourne un Numpy array dense, sinon retourne un Scipy CSR array
         """
-        if not self.only_h:
-            return self._results[idx][0].toarray() if dense else self._results[idx][0]
+
+        self.check_if_cached(idx)
+
+        if self.only_h:
+            if self._tile_packer is None:
+                untiled = self._results[idx]
+            else:
+                untiled = self._tile_packer.unpack_array(self._results[idx])
+            if dense:
+                return untiled
+            else:
+                return csr_array(untiled)
         else:
-            return self._results[idx].toarray() if dense else self._results[idx]
+            if self._tile_packer is None:
+                untiled = self._results[idx][0]
+            else:
+                untiled = self._tile_packer.unpack_array(self._results[idx][0])
+            if dense:
+                return untiled
+            else:
+                return csr_array(untiled)
 
     def get_qx(self,idx:int, dense:bool=True) -> Union[np.ndarray, csr_array]:
         """
         Retourne la matrice de débit X d'eau de la position idx (0-based)
             - en CSR (Scipy CSR)
             - en dense (Numpy array)
+
+        :param idx: index du résultat (1-based)
+        :param dense: si True, retourne un Numpy array dense, sinon retourne un Scipy CSR array
         """
 
-        if not self.only_h:
-            return self._results[idx][1].toarray() if dense else self._results[idx][1]
-        else:
+        if self.only_h:
             return None
+        else:
+            self.check_if_cached(idx)
+
+            if self._tile_packer is None:
+                untiled = self._results[idx][1]
+            else:
+                untiled = self._tile_packer.unpack_array(self._results[idx][1])
+
+            if dense:
+                return untiled
+            else:
+                return csr_array(untiled)
 
     def get_qy(self,idx:int, dense:bool=True) -> Union[np.ndarray, csr_array]:
         """
         Retourne la matrice de débit Y d'eau de la position idx (0-based)
             - en CSR (Scipy CSR)
             - en dense (Numpy array)
+
+        :param idx: index du résultat (1-based)
+        :param dense: si True, retourne un Numpy array dense, sinon retourne un Scipy CSR array
         """
 
-        if not self.only_h:
-            return self._results[idx][2].toarray() if dense else self._results[idx][2]
-        else:
+        if self.only_h:
             return None
+        else:
+            self.check_if_cached(idx)
 
+            if self._tile_packer is None:
+                untiled = self._results[idx][2]
+            else:
+                untiled = self._tile_packer.unpack_array(self._results[idx][2])
+
+            if dense:
+                return untiled
+            else:
+                return csr_array(untiled)
 
 class wolfres2DGPU(Wolfresults_2D):
     """
@@ -427,7 +548,7 @@ class wolfres2DGPU(Wolfresults_2D):
 
         # stored result files are 1-based -> which+1
         if self._cache is not None:
-            if (which >= self._cache.start_idx and which < self._cache.end_idx) and (not self._cache.only_h):
+            if not self._cache.only_h:
                 wd_np = self._cache.get_h(which+1, True)
                 qx_np = self._cache.get_qx(which+1, True)
                 qy_np = self._cache.get_qy(which+1, True)
@@ -472,9 +593,9 @@ class wolfres2DGPU(Wolfresults_2D):
         curblock.qx.array.mask[ij] = False
         curblock.qy.array.mask[ij] = False
 
-        curblock.waterdepth.count()
-        curblock.qx.count()
-        curblock.qy.count()
+        curblock.waterdepth.nbnotnull = len(ij[0])
+        curblock.qx.nbnotnull = curblock.waterdepth.nbnotnull
+        curblock.qy.nbnotnull = curblock.waterdepth.nbnotnull
 
         # curblock.waterdepth.set_nullvalue_in_mask()
         # curblock.qx.set_nullvalue_in_mask()
@@ -497,10 +618,7 @@ class wolfres2DGPU(Wolfresults_2D):
 
         # stored result files are 1-based -> which+1
         if self._cache is not None:
-            if (which >= self._cache.start_idx and which < self._cache.end_idx):
-                wd_np = self._cache.get_h(which+1, True)
-            else:
-                _, _, _, _, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
+            wd_np = self._cache.get_h(which+1, True)
         else:
             __, __, __, __, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)