wolfhece 2.1.16__py3-none-any.whl → 2.1.18__py3-none-any.whl

wolfhece/PyDraw.py

@@ -852,6 +852,13 @@ class WolfMapViewer(wx.Frame):
             # self.menu2d_bc = self.menuwolf2d.Append(wx.ID_ANY, _("Manage boundary conditions..."), _("BC manager"))
             self.menu2d_video = self.menuwolf2d.Append(wx.ID_ANY, _("Create video..."), _("Video/Movie"))
 
+            self.menuwolf2d.AppendSeparator()
+
+            self.menu2d_dangermap = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map"), _("Compute the danger map"))
+            self.menu2d_dangermaph = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map - only h"), _("Compute the danger map"))
+
+            self.menuwolf2d.AppendSeparator()            
+
             self.menubar.Append(self.menuwolf2d, _('Results 2D'))
 
             self.menuwolf2d.Bind(wx.EVT_MENU, self.Onmenuwolf2d)
@@ -875,7 +882,12 @@ class WolfMapViewer(wx.Frame):
 
 
     def get_canvas_bounds(self, gridsize:float = None):
-        """ Retourne les limites de la zone d'affichage """
+        """ 
+        Retourne les limites de la zone d'affichage 
+        
+        :return: [xmin, ymin, xmax, ymax]
+
+        """
 
         if gridsize is None:
 
@@ -1182,6 +1194,82 @@ class WolfMapViewer(wx.Frame):
             if self.active_res2d is not None:
                 self.create_video()
 
+        elif itemlabel == _("Danger map - only h"):
+            if self.active_res2d is None:
+                logging.warning(_('No active 2D result !'))
+                return
+
+            with wx.NumberEntryDialog(None, _('Danger map'), _('From step'), _('Danger map'), 1, 1, self.active_res2d.get_nbresults()) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                start_step = dlg.GetValue()
+            
+            with wx.NumberEntryDialog(None, _('Danger map'), _('To step'), _('Danger map'), self.active_res2d.get_nbresults(), start_step, self.active_res2d.get_nbresults()) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                end_step = dlg.GetValue()
+
+            with wx.NumberEntryDialog(None, _('Danger map'), _('Every'), _('Danger map'), 1, 1, 60) as dlg:
+                
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                every = dlg.GetValue()
+
+            danger_map = self.active_res2d.danger_map_only_h(start_step-1, end_step-1, every)
+
+            with wx.DirDialog(None, _('Choose a directory'), style=wx.DD_DEFAULT_STYLE) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                outdir = dlg.GetPath()
+
+            danger_map.write_all(Path(outdir) / 'danger_h.tif')
+
+        elif itemlabel == _("Danger map"):
+            if self.active_res2d is None:
+                logging.warning(_('No active 2D result !'))
+                return
+
+            with wx.NumberEntryDialog(None, _('Danger map'), _('From step'), _('Danger map'), 1, 1, self.active_res2d.get_nbresults()) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                start_step = dlg.GetValue()
+            
+            with wx.NumberEntryDialog(None, _('Danger map'), _('To step'), _('Danger map'), self.active_res2d.get_nbresults(), start_step, self.active_res2d.get_nbresults()) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                end_step = dlg.GetValue()
+
+            with wx.NumberEntryDialog(None, _('Danger map'), _('Every'), _('Danger map'), 1, 1, 60) as dlg:
+                
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                every = dlg.GetValue()
+
+            danger_maps = self.active_res2d.danger_map(start_step-1, end_step-1, every)
+
+            with wx.DirDialog(None, _('Choose a directory'), style=wx.DD_DEFAULT_STYLE) as dlg:
+
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return
+                
+                outdir = dlg.GetPath()
+
+            names = ['danger_h.tif', 'danger_u.tif', 'danger_q.tif']
+            for name, danger_map in zip(names, danger_maps):
+                danger_map.write_all(Path(outdir) / name)
+
         elif itemlabel == _("Setup cache..."):
 
             if self.active_res2d is None:
@@ -2689,13 +2777,26 @@ class WolfMapViewer(wx.Frame):
                                '2015': 'ORTHO_2015', '2016': 'ORTHO_2016', '2017': 'ORTHO_2017',
                                '2018': 'ORTHO_2018', '2019': 'ORTHO_2019', '2020': 'ORTHO_2020',
                                '2021': 'ORTHO_2021', '2022 printemps': 'ORTHO_2022_PRINTEMPS', '2022 été': 'ORTHO_2022_ETE',
-                               '2023 été': 'ORTHO_2023_ETE'}}
+                               '2023 été': 'ORTHO_2023_ETE',
+                               }}
+        data_2021 = {'EAU': {'IDW': 'ZONES_INONDEES_IDW', 
+                             'Emprise': 'ZONES_INONDEES', 
+                             'Emprise wo Alea': 'ZONES_INONDEES_wo_alea'}}
+        
         for idx, (k, item) in enumerate(orthos.items()):
             for kdx, (m, subitem) in enumerate(item.items()):
                 self.add_object(which='wmsback',
                                 newobj=imagetexture('PPNC', m, k, subitem,
                                                     self, xmin, xmax, ymin, ymax, -99999, 1024),
                                 ToCheck=False, id='PPNC ' + m)
+
+        for idx, (k, item) in enumerate(data_2021.items()):
+            for kdx, (m, subitem) in enumerate(item.items()):
+                self.add_object(which='wmsback',
+                                newobj=imagetexture('PPNC', m, k, subitem,
+                                                    self, xmin, xmax, ymin, ymax, -99999, 1024),
+                                ToCheck=False, id='Data 2021 ' + m)
+
         self.add_object(which='wmsback',
                         newobj=imagetexture('PPNC', 'Orthos France', 'OI.OrthoimageCoverage.HR', '',
                                             self, xmin, xmax, ymin, ymax, -99999, 1024, France=True, epsg='EPSG:27563'),
@@ -5511,7 +5612,7 @@ class WolfMapViewer(wx.Frame):
         Add object to current Frame/Drawing area
         """
 
-        filterArray = "bin (*.bin)|*.bin|Elevation WOLF2D (*.top)|*.top|Geotif (*.tif)|*.tif|Float ESRI (*.flt)|*.flt|Numpy (*.npy)|*.npy|Numpy named arrays(*.npz)|*.npz|all (*.*)|*.*"
+        filterArray = "All supported formats|*.bin;*.tif;*.tiff;*.top;*.flt;*.npy;*.npz|bin (*.bin)|*.bin|Elevation WOLF2D (*.top)|*.top|Geotif (*.tif)|*.tif|Float ESRI (*.flt)|*.flt|Numpy (*.npy)|*.npy|Numpy named arrays(*.npz)|*.npz|all (*.*)|*.*"
         filterjson = "json (*.json)|*.json|all (*.*)|*.*"
         filterall = "all (*.*)|*.*"
         filterres2d = "all (*.*)|*.*"

wolfhece/PyGuiHydrology.py

@@ -3,6 +3,9 @@ import wx
 from .PyTranslate import _
 from .PyDraw import WolfMapViewer
 from .RatingCurve import *
+from.PyVertexvectors import vector, Zones, zone, getIfromRGB, getRGBfromI
+
+import logging
 
 
 class selectpoint(wx.Frame):
@@ -112,32 +115,62 @@ class selectpoint(wx.Frame):
 
 
 class GuiHydrology(WolfMapViewer):
+    """ Mapviewer of the hydrology model -- see HydrologyModel in PyGui.py """
+
+    def __init__(self, parent=None, title='WOLF Hydrological model - viewer', w=500, h=500, treewidth=200, wolfparent=None, wxlogging=None):
+        """ Constructor
+        
+        :param parent: parent window - wx.Frame
+        :param title: title of the window - str
+        :param w: width of the window - int
+        :param h: height of the window - int
+        :param treewidth: width of the tree - int
+        :param wolfparent: wolf parent instance -- PyGui.HydrologyModel
+        :type wolfparent: HydrologyModel
+        :param wxlogging: logging instance -- PyGui.WolfLog
+        """
 
-    def __init__(self, parent=None, title='MyForm', w=500, h=500, treewidth=200, wolfparent=None, wxlogging=None):
         super(GuiHydrology, self).__init__(parent, title=title, w=w, h=h, 
-                                           treewidth=treewidth, wolfparent=wolfparent,wxlogging=wxlogging)
+                                           treewidth=treewidth, 
+                                           wolfparent=wolfparent,
+                                           wxlogging=wxlogging)
 
-        self.parent = parent
+        from .PyGui import HydrologyModel
 
-        self.filemenu.Insert(0, 1100, _('New from scratch'), _('Create a new simulation from scratch...'))
+        self.wolfparent:HydrologyModel
 
-        self.toolsmenu = wx.Menu()
-        self.toolsmenu.Append(1200, _('Forced exchanges'), _('Manage the forced exchanges...'))
-        self.toolsmenu.Append(1201, _('Crop MNT/MNS'), _('Cropping data...'))
-        self.toolsmenu.Append(1202, _('Crop land use (COSW)'), _('Cropping data...'))
-        self.toolsmenu.Append(1205, _('Analyze slope'), _('Slope analyzer...'))
-        self.toolsmenu.Append(1203, _('IRM - QDF'), _('Manage data...'))
-        self.toolsmenu.Append(1204, _('SPW - Hydrometry'), _('Manage data...'))
-        self.menubar.Append(self.toolsmenu, _('&Tools'))
+        # self.filemenu.Insert(0, wx.ID_ANY, _('New from scratch'), _('Create a new simulation from scratch...'))
 
         self.modelmenu = wx.Menu()
-        paramgen = self.modelmenu.Append(1500, _('New'), _('Wizard !'))
-        paramgen = self.modelmenu.Append(1501, _('Interior points'), _('Interior points'))
-        paramgen = self.modelmenu.Append(1502, _('Topology'), _('Topology manager'))
-        paramgen = self.modelmenu.Append(1503, _('Main model'), _('General parameters'))
-        paramgen = self.modelmenu.Append(1504, _('Basin'), _('Basin parameters'))
-        paramgen = self.modelmenu.Append(1505, _('Subbasins'), _('Sub-Basin parameters'))
-        self.menubar.Append(self.modelmenu, _('&Model'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Choose outlet'), _('Wizard !'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Interior points'), _('Interior points'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Topology'), _('Topology manager'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Main model'), _('General parameters'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Basin'), _('Basin parameters'))
+        paramgen = self.modelmenu.Append(wx.ID_ANY, _('Subbasins'), _('Sub-Basin parameters'))
+        self.menubar.Append(self.modelmenu, _('&Hydrological model'))
+
+        self.toolsmenu = wx.Menu()
+        self.toolsmenu.Append(wx.ID_ANY, _('Forced exchanges'), _('Manage the forced exchanges...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Crop MNT/MNS'), _('Cropping data...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Crop land use (COSW)'), _('Cropping data...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Analyze slope'), _('Slope analyzer...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('IRM - QDF'), _('Manage data...'))
+
+        self.toolsmenu.AppendSeparator()
+
+        self.toolsmenu.Append(wx.ID_ANY, _('Find upstream watershed'), _('Find upstream watershed based on click...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Find upstream watershed - limit to sub'), _('Find upstream watershed based on click but limit to subbasin...'))
+
+        self.toolsmenu.AppendSeparator()
+
+        self.toolsmenu.Append(wx.ID_ANY, _('Select upstream watershed'), _('Select upstream watershed based on click...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Select upstream watershed - limit to sub'), _('Select upstream watershed based on click but limit to subbasin...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Select upstream rivers'), _('Select upstream rivers based on click...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Select upstream rivers - limit to sub'), _('Select upstream rivers based on click but limit to subbasin...'))
+        self.toolsmenu.Append(wx.ID_ANY, _('Select downstream rivers'), _('Select downstream rivers based on click...'))
+
+        self.menubar.Append(self.toolsmenu, _('&Tools Hydrology'))
 
         # self.computemenu = wx.Menu()
         # paramgen = self.computemenu.Append(1300,_('Calibration/Optimisation'),_('Parameters calibration of the model'))
@@ -149,23 +182,169 @@ class GuiHydrology(WolfMapViewer):
         # paramgen = self.resultsmenu.Append(1401,_('Plot'),_('Plot'))
         # self.menubar.Append(self.resultsmenu,_('&Results'))
 
+    @property
+    def watershed(self):
+
+        if self.wolfparent is None:
+            return None
+        
+        if self.wolfparent.mycatchment is None:
+            return None
+
+        return self.wolfparent.mycatchment.charact_watrshd
+
     def OnMenubar(self, event):
+        """ Event handler for the menubar """
 
+        # Call the parent event handler
         super().OnMenubar(event)
 
+        # If not handled by the parent, handle it here
+
         id = event.GetId()
         item = self.menubar.FindItemById(id)
+        if item is None:
+            return
+
+        itemlabel = item.ItemLabel
 
-        if id == wx.ID_EXECUTE:
-            print(_('Do anything !!'))
-        elif id == 1503:
-            self.parent.mainparams.Show()
-        elif id == 1504:
-            self.parent.basinparams.Show()
-        # elif id==1300:
-        #     self.myoptimisation = Optimisation()
-        #     self.myoptimisation.Show()
-        elif id == 1500:
-            myselect = selectpoint(title=_('Outlet'), SPWstations=self.parent.SPWstations,
-                                   DCENNstations=self.parent.DCENNstations)
+        if itemlabel == _('Choose outlet'):
+            myselect = selectpoint(title=_('Outlet'), 
+                                   SPWstations=self.wolfparent.SPWstations,
+                                   DCENNstations=self.wolfparent.DCENNstations)
             myselect.Show()
+
+        elif itemlabel == _('Interior points'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Topology'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Main model'):
+            self.wolfparent.mainparams.Show()
+
+        elif itemlabel == _('Basin'):
+            self.wolfparent.basinparams.Show()
+
+        elif itemlabel == _('Subbasins'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Forced exchanges'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Crop MNT/MNS'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Crop land use (COSW)'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Analyze slope'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('IRM - QDF'):
+            logging.warning(_('Not yet implemented !'))
+
+        elif itemlabel == _('Find upstream watershed'):
+            self.action = 'Find upstream watershed'
+
+        elif itemlabel == _('Find upstream watershed - limit to sub'):
+            self.action = 'Find upstream watershed - limit to sub'
+
+        elif itemlabel == _('Select upstream watershed'):
+            self.action = 'Select upstream watershed'
+
+        elif itemlabel == _('Select upstream watershed - limit to sub'):
+            self.action = 'Select upstream watershed - limit to sub'
+
+        elif itemlabel == _('Select upstream rivers'):
+            self.action = 'Select upstream rivers'
+
+        elif itemlabel == _('Select upstream rivers - limit to sub'):
+            self.action = 'Select upstream rivers - limit to sub'
+
+        elif itemlabel == _('Select downstream rivers'):
+            self.action = 'Select downstream rivers'
+
+
+    def OnRightDown(self, e: wx.MouseEvent):
+        
+        # Call the parent event handler
+        super().OnRightDown(e)
+
+        if self.action is None:
+            logging.info(_('No action selected !'))
+            return
+        
+        if self.action == '':
+            logging.info(_('No action selected !'))
+            return
+
+        pos = e.GetPosition()
+        x, y = self.getXY(pos)
+
+        alt = e.AltDown()
+        ctrl = e.ControlDown()
+        shiftdown = e.ShiftDown()
+
+        if self.active_array is None:
+            logging.warning(_('No active array !'))
+            return
+
+        if not (self.active_array.dx == self.watershed.header.dx and self.active_array.dy == self.watershed.header.dy):
+            logging.warning(_('Active array and watershed do not have the same resolution !'))
+            return
+
+        if 'Find upstream watershed' in self.action:
+            
+            starting_node = self.watershed.get_node_from_xy(x,y)
+            up_vect = self.watershed.get_vector_from_upstream_node(starting_node, limit_to_sub='limit to sub' in self.action)
+
+            if up_vect is None:
+                logging.warning(_('No upstream watershed found !'))
+                return
+
+            def props_vec(vec:vector):
+                vec.myprop.color = getIfromRGB((255,0,0))
+                vec.myprop.width = 3
+                vec.myprop.transparent = False
+                vec.myprop.alpha = 122
+                vec.myprop.filled = False
+
+            if self.active_array.Operations is not None:
+                newzone = zone(name = str(starting_node.sub))
+                
+                self.active_array.Operations.show_structure_OpsVectors()
+                self.active_array.Operations.myzones.add_zone(newzone, forceparent=True)
+                newzone.add_vector(up_vect, forceparent=True)
+
+                props_vec(up_vect)
+                
+                self.active_array.Operations.myzones.prep_listogl()
+                self.active_array.Operations.myzones.fill_structure()
+                
+                self.Refresh()           
+            else:
+                logging.warning(_('No operations frame in the active array!'))
+                
+        elif 'Select upstream watershed' in self.action:
+                        
+            xy = self.watershed.get_xy_upstream_node(self.watershed.get_node_from_xy(x,y), limit_to_sub='limit to sub' in self.action)
+            self.active_array.SelectionData.set_selection_from_list_xy(xy)            
+            self.Refresh()           
+
+        elif 'Select upstream rivers' in self.action:
+
+            xy = self.watershed.get_xy_upstream_node(self.watershed.get_node_from_xy(x,y), 
+                                                     limit_to_sub='limit to sub' in self.action,
+                                                     limit_to_river=True)
+            
+            self.active_array.SelectionData.set_selection_from_list_xy(xy)            
+            self.Refresh()           
+
+        elif 'Select downstream rivers' in self.action:
+
+            xy = self.watershed.get_xy_downstream_node(self.watershed.get_node_from_xy(x,y))
+            self.active_array.SelectionData.set_selection_from_list_xy(xy) 
+            self.Refresh()           
+
+

wolfhece/PyParams.py

@@ -927,6 +927,7 @@ class Wolf_Param(wx.Frame):
             # priority to default parameters
             if key_Param.ADDED_JSON in param_def.keys():
                 param[key_Param.ADDED_JSON] = param_def[key_Param.ADDED_JSON]
+                
             param[key_Param.COMMENT] = param_def[key_Param.COMMENT]
             param[key_Param.TYPE] = param_def[key_Param.TYPE]
 
@@ -1223,6 +1224,7 @@ class Wolf_Param(wx.Frame):
                 # PARAMETRE
                 # ---------
                 curparam = self._add_param_from_str(param, groupname, groupdict)
+                curparam[key_Param.ADDED_JSON]=None
 
     def _CreateDefaultFile(self):
         """ Create a default file """
@@ -2266,7 +2268,8 @@ class Wolf_Param(wx.Frame):
                 self.myparams[curGroup][curParam][key_Param.TYPE] = templateDict[key_Param.TYPE]
                 if key_Param.ADDED_JSON in templateDict:
                     self.myparams[curGroup][curParam][key_Param.ADDED_JSON] = templateDict[key_Param.ADDED_JSON]
-
+                else:
+                    self.myparams[curGroup][curParam][key_Param.ADDED_JSON] = None
         # transfert des paramètres en surplus dans le dictionnaire savedDict
         for i in range(nbElements+1, iterMax+1):
             curParam = curIncParam.replace("$n$",str(i))

wolfhece/PyVertexvectors.py

@@ -729,6 +729,10 @@ class vectorproperties:
         try:
             if updateOGL:
                 self.parent.parentzone.prep_listogl()
+
+                if self.parent.parentzone.parent is None:
+                    logging.critical('Problem with OpenGL update - parent/mapviewer is None -- Track this issue')
+
                 self.parent.parentzone.parent.mapviewer.Refresh()
         except:
             logging.warning('Problem with OpenGL update - vectorproperties.fill_property')

wolfhece/PyWMS.py

@@ -12,7 +12,7 @@ from .PyTranslate import _
 def to_image(mybytes:BytesIO) -> Image:
     return Image.open(mybytes)
 
-def getWalonmap(cat:Literal['IMAGERIE/ORTHO_2021', 'ALEA', 'CADMAP', 'LIDAXES', '$IDW', 'ZONES_INONDEES'],
+def getWalonmap(cat:Literal['IMAGERIE/ORTHO_2021', 'ALEA', 'CADMAP', 'LIDAXES', '$IDW', 'EAU/ZONES_INONDEES'],
                 xl:float,
                 yl:float,
                 xr:float,
@@ -23,6 +23,8 @@ def getWalonmap(cat:Literal['IMAGERIE/ORTHO_2021', 'ALEA', 'CADMAP', 'LIDAXES',
 
     if cat.find('$')>0:
         catloc=cat[:cat.find('$')]
+    elif cat.find('_wo_alea')>0:
+        catloc=cat[:cat.find('_wo_alea')]
     else:
         catloc=cat
 
@@ -78,18 +80,17 @@ def getWalonmap(cat:Literal['IMAGERIE/ORTHO_2021', 'ALEA', 'CADMAP', 'LIDAXES',
         elif cat.find('LIDAXES')>0:
             curcont=['4,5,6,7,8,9,11,13']
             curstyles=['default,default,default,default,default,default,default,default']
-        elif cat.find('$IDW')>0:
-            curcont=[ul.quote('Zones inondées - Modélisation IDW')]
+        elif cat.find('IDW')>0:
+            curcont=['0']
             curstyles=['default']
         elif cat.find('ZONES_INONDEES')>0:
-            layers=[
-                ul.quote('Zones inondables'),
-                ul.quote('Zones inondées - Satellites'),
-                ul.quote('Zones indondées - Verviers'),
-                ul.quote('Zones inondées - Enquêtes SPW'),
-                ul.quote('Zones inondées - Digitalisations')]
-            curcont=['{},{},{},{},{},{}'.format(layers[0],layers[1],layers[2],layers[3],layers[4])]
-            curstyles=['default,default,default,default,default']
+
+            if 'wo_alea' in cat:
+                curcont = list(wms.contents)[1:]
+                curstyles=['default']*len(curcont)
+            else:
+                curcont = list(wms.contents)
+                curstyles=['default']*len(curcont)
 
         try:
             img=wms.getmap(layers=curcont,styles=curstyles,srs='EPSG:31370',bbox=(xl,yl,xr,yr),size=(w,h),format='image/png',transparent=True)

wolfhece/RatingCurve.py

@@ -501,13 +501,13 @@ class SPWMIGaugingStations(Element_To_Draw):
         self.ymin = min(y)
         self.ymax = max(y)
 
-    def _plot(self, size:float=10.):
-        for curstation in self.mystations.values:
+    def _plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size:float=10.):
+        for curstation in self.mystations.values():
             curstation.plot(size)
 
 class SPWDCENNGaugingStations(Element_To_Draw):
 
-    mystations:dict
+    mystations:dict[int:gaugingstation]
     myrivers:dict
     gaugings:SPWGaugings
     hrefs:SPWhrefs
@@ -633,6 +633,18 @@ class SPWDCENNGaugingStations(Element_To_Draw):
 
         pass
 
-    def plot(self,size:float=10.):
-        for id in self.mystations:
-            self.mystations[id].plot(size)
+    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size:float=10.):
+        self._plot(size)
+
+    def find_minmax(self,update=False):
+        x = [cur.x for cur in self.mystations.values()]
+        y = [cur.y for cur in self.mystations.values()]
+
+        self.xmin = min(x)
+        self.xmax = max(x)
+        self.ymin = min(y)
+        self.ymax = max(y)
+
+    def _plot(self, size:float=10.):
+        for curstation in self.mystations.values():
+            curstation.plot(size)

wolfhece/Results2DGPU.py

@@ -380,24 +380,94 @@ class wolfres2DGPU(Wolfresults_2D):
             else:
                 _, _, _, _, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
         else:
-            _, _, _, _, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
+            __, __, __, __, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
+
+        wd_np = wd_np.T
+        qx_np = qx_np.T
+        qy_np = qy_np.T
 
         curblock = self.myblocks[getkeyblock(1,False)]
+        
+        curblock.waterdepth.array.data[:,:] = curblock.waterdepth.nullvalue
+        curblock.qx.array.data[:,:] = curblock.qx.nullvalue
+        curblock.qy.array.data[:,:] = curblock.qy.nullvalue
+
+        curblock.waterdepth.array.mask[:,:] = True
+        curblock.qx.array.mask[:,:] = True
+        curblock.qy.array.mask[:,:] = True
+        
         if self.epsilon > 0.:
-            curblock.waterdepth.array=ma.masked_less_equal(wd_np.astype(np.float32).T, self.epsilon)
+            # curblock.waterdepth.array=ma.masked_less_equal(wd_np.astype(np.float32).T, self.epsilon)
+            
+            ij = np.where(wd_np >= self.epsilon)
+            curblock.waterdepth.array.data[ij] = wd_np[ij]
+            curblock.waterdepth.array.mask[ij] = False
         else:
-            curblock.waterdepth.array=ma.masked_equal(wd_np.astype(np.float32).T, 0.)
+            # curblock.waterdepth.array=ma.masked_equal(wd_np.astype(np.float32).T, 0.)
+            
+            ij = np.where(wd_np > 0.)
+            curblock.waterdepth.array.data[ij] = wd_np[ij]
+            curblock.waterdepth.array.mask[ij] = False
+
+        # curblock.qx.array=ma.masked_where(curblock.waterdepth.array.mask,qx_np.astype(np.float32).T)
+        # curblock.qy.array=ma.masked_where(curblock.waterdepth.array.mask,qy_np.astype(np.float32).T)
 
-        curblock.qx.array=ma.masked_where(curblock.waterdepth.array.mask,qx_np.astype(np.float32).T)
-        curblock.qy.array=ma.masked_where(curblock.waterdepth.array.mask,qy_np.astype(np.float32).T)
+        curblock.qx.array.data[ij]  = qx_np[ij]
+        curblock.qy.array.data[ij]  = qy_np[ij]
+
+        curblock.qx.array.mask[ij] = False
+        curblock.qy.array.mask[ij] = False
 
         curblock.waterdepth.count()
         curblock.qx.count()
         curblock.qy.count()
 
-        curblock.waterdepth.set_nullvalue_in_mask()
-        curblock.qx.set_nullvalue_in_mask()
-        curblock.qy.set_nullvalue_in_mask()
+        # curblock.waterdepth.set_nullvalue_in_mask()
+        # curblock.qx.set_nullvalue_in_mask()
+        # curblock.qy.set_nullvalue_in_mask()
+
+        if self.to_filter_independent:
+            self.filter_independent_zones()
+
+        self.current_result = which
+        self.loaded=True
+
+    def _read_oneresult_only_h(self, which:int=-1):
+        """
+        Lecture d'un pas de sauvegarde
+
+        which: result number to read; 0-based; -1 == last one
+        """
+
+        which = self._sanitize_result_step(which)
+
+        # 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)
+        else:
+            __, __, __, __, wd_np, qx_np, qy_np = self._result_store.get_result(which+1)
+
+        wd_np = wd_np.T
+
+        curblock = self.myblocks[getkeyblock(1,False)]
+        
+        curblock.waterdepth.array.data[:,:] = curblock.waterdepth.nullvalue
+
+        curblock.waterdepth.array.mask[:,:] = True
+        
+        if self.epsilon > 0.:
+            ij = np.where(wd_np >= self.epsilon)
+            curblock.waterdepth.array.data[ij] = wd_np[ij]
+            curblock.waterdepth.array.mask[ij] = False
+        else:
+            ij = np.where(wd_np > 0.)
+            curblock.waterdepth.array.data[ij] = wd_np[ij]
+            curblock.waterdepth.array.mask[ij] = False
+
+        curblock.waterdepth.count()
 
         if self.to_filter_independent:
             self.filter_independent_zones()

wolfhece/apps/version.py

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