wolfhece 2.2.14__py3-none-any.whl → 2.2.15__py3-none-any.whl

wolfhece/PyDraw.py

@@ -92,6 +92,8 @@ try:
     from .math_parser.calculator import Calculator
     from .wintab.wintab import Wintab
     from .images_tiles import ImagesTiles
+    from .PyWMS import Alaro_Navigator, get_Alaro_legend
+
 except ImportError as e:
     print(e)
     raise ImportError("Error importing wolf_texture, xyz_file, mesh2d, PyPalette, wolfresults_2D, PyTranslate, PyVertex, RatingCurve, wolf_array, PyParams, mesh2d.bc_manager, PyVertexvectors, Results2DGPU, PyCrosssections, GraphNotebook, lazviewer, picc, wolf_zi_db, math_parser.calculator, wintab. Please check your installation.")
@@ -1956,6 +1958,8 @@ class WolfMapViewer(wx.Frame):
 
     active_fig: MplFigViewer
 
+    alaro_navigator: Alaro_Navigator
+
 
     # def check_user_activity(self, *args):
     #     while True:
@@ -2008,8 +2012,6 @@ class WolfMapViewer(wx.Frame):
         self.treewidth = treewidth
         super(WolfMapViewer, self).__init__(wxparent, title=title, size=(w + self.treewidth, h))
 
-        self._tmp_vector_distance = None  # distance computation the vector
-
         self._wxlogging = wxlogging
         self.action = None  # Action à entreprendre
         self.update_absolute_minmax = False  # Force la MAJ de la palette
@@ -2092,6 +2094,8 @@ class WolfMapViewer(wx.Frame):
         self.menudrowning = None
         self.menudike = None
 
+        self.alaro_navigator = None
+
         self.filemenu = wx.Menu()
         openitem = self.filemenu.Append(wx.ID_OPEN, _('Open/Add project'), _('Open a full project from file'))
         saveproject = self.filemenu.Append(wx.ID_ANY, _('Save project as...'), _('Save the current project to file'))
@@ -2223,6 +2227,10 @@ class WolfMapViewer(wx.Frame):
         self.menu_contour_from_arrays = self.tools_menu.Append(wx.ID_ANY, _("Create contour from checked arrays..."), _("Create contour"))
         self.menu_calculator = self.tools_menu.Append(wx.ID_ANY, _("Calculator..."), _("Calculator"))
         self.menu_views = self.tools_menu.Append(wx.ID_ANY, _("Memory views..."), _("Memory views"))
+
+        self.menu_distances = self.tools_menu.Append(wx.ID_ANY, _("Memory distances..."), _("Memory distances"))
+        self.menu_distances_add = self.tools_menu.Append(wx.ID_ANY, _("Add distances to viewer..."), _("Add memory distances"))
+
         self.menu_digitizer = self.tools_menu.Append(wx.ID_ANY, _("Image digitizer..."), _("Image Digitizer"))
         self.calculator = None
         self.memory_views = None
@@ -2484,6 +2492,10 @@ class WolfMapViewer(wx.Frame):
 
         self.InitUI()
 
+        self._tmp_vector_distance = None  # distance computation the vector
+        self._distances = Zones(mapviewer=self, idx=_('Distances/Areas'))
+        self._distances.add_zone(zone(name='memory distances', parent=self._distances))  # distances memory
+
         # self._wintab = Wintab(self.GetHandle())
 
         # if self._wintab:
@@ -5287,6 +5299,111 @@ class WolfMapViewer(wx.Frame):
                                      '2022': '2022',
                                      }}
 
+        """cat:Literal['orthoimage_coverage',
+                       'orthoimage_coverage_2016',
+                       'orthoimage_coverage_2017',
+                       'orthoimage_coverage_2018',
+                       'orthoimage_coverage_2019',
+                       'orthoimage_coverage_2020',
+                       'orthoimage_coverage_2021',
+                       'orthoimage_coverage_2022']
+        """
+        ign_belgique = {'Orthophotos': {'Last': 'orthoimage_coverage',
+                                        '2016': 'orthoimage_coverage_2016',
+                                        '2017': 'orthoimage_coverage_2017',
+                                        '2018': 'orthoimage_coverage_2018',
+                                        '2019': 'orthoimage_coverage_2019',
+                                        '2020': 'orthoimage_coverage_2020',
+                                        '2021': 'orthoimage_coverage_2021',
+                                        '2022': 'orthoimage_coverage_2022',}}
+
+        """ ['crossborder',
+                            'crossborder_grey',
+                            'overlay',
+                            'topo',
+                            'topo_grey']"""
+        ign_cartoweb = {'CartoWeb': {'Crossborder': 'crossborder',
+                                    'Crossborder Grey': 'crossborder_grey',
+                                    'Overlay': 'overlay',
+                                    'Topographic': 'topo',
+                                    'Topographic Grey': 'topo_grey',}}
+
+        ign_postflood2021 = {'PostFlood2021': {'Flood 2021': 'orthoimage_flood'}}
+
+        """
+        ['10_m_u__wind_component',
+        '10_m_v__wind_component',
+        '2_m_Max_temp_since_ppp',
+        '2_m_Min_temp_since_ppp',
+        '2_m_dewpoint_temperature',
+        '2_m_temperature',
+        '2m_Relative_humidity',
+        'Convective_rain',
+        'Convective_snow',
+        'Geopotential',
+        'Inst_flx_Conv_Cld_Cover',
+        'Inst_flx_High_Cld_Cover',
+        'Inst_flx_Low_Cld_Cover',
+        'Inst_flx_Medium_Cld_Cover',
+        'Inst_flx_Tot_Cld_cover',
+        'Large_scale_rain',
+        'Large_scale_snow',
+        'Mean_sea_level_pressure',
+        'Relative_humidity',
+        'Relative_humidity_isobaric',
+        'SBL_Meridian_gust',
+        'SBL_Zonal_gust',
+        'Specific_humidity',
+        'Surf_Solar_radiation',
+        'Surf_Thermal_radiation',
+        'Surface_CAPE',
+        'Surface_Temperature',
+        'Surface_orography',
+        'Temperature',
+        'Total_precipitation',
+        'U-velocity',
+        'V-velocity',
+        'Vertical_velocity',
+        'Wet_Bulb_Poten_Temper',
+        'freezing_level_zeroDegC_isotherm'],
+        """
+        alaro = {'ALARO': {'10m_u_wind_component': '10_m_u__wind_component',
+                          '10m_v_wind_component': '10_m_v__wind_component',
+                          '2m_Max_temp_since_ppp': '2_m_Max_temp_since_ppp',
+                          '2m_Min_temp_since_ppp': '2_m_Min_temp_since_ppp',
+                          '2m_dewpoint_temperature': '2_m_dewpoint_temperature',
+                          '2m_temperature': '2_m_temperature',
+                          '2m_Relative_humidity': '2m_Relative_humidity',
+                          'Convective_rain': 'Convective_rain',
+                          'Convective_snow': 'Convective_snow',
+                          'Geopotential': 'Geopotential',
+                          'Inst_flx_Conv_Cld_Cover': 'Inst_flx_Conv_Cld_Cover',
+                          'Inst_flx_High_Cld_Cover': 'Inst_flx_High_Cld_Cover',
+                          'Inst_flx_Low_Cld_Cover': 'Inst_flx_Low_Cld_Cover',
+                          'Inst_flx_Medium_Cld_Cover': 'Inst_flx_Medium_Cld_Cover',
+                          'Inst_flx_Tot_Cld_cover': 'Inst_flx_Tot_Cld_cover',
+                          'Large_scale_rain': 'Large_scale_rain',
+                          'Large_scale_snow': 'Large_scale_snow',
+                          'Mean_sea_level_pressure': 'Mean_sea_level_pressure',
+                          'Relative_humidity': 'Relative_humidity',
+                          'Relative_humidity_isobaric': 'Relative_humidity_isobaric',
+                          'SBL_Meridian_gust': 'SBL_Meridian_gust',
+                          'SBL_Zonal_gust': 'SBL_Zonal_gust',
+                          'Specific_humidity': 'Specific_humidity',
+                          'Surf_Solar_radiation': 'Surf_Solar_radiation',
+                          'Surf_Thermal_radiation': 'Surf_Thermal_radiation',
+                          'Surface_CAPE': 'Surface_CAPE',
+                          'Surface_Temperature': 'Surface_Temperature',
+                          'Surface_orography': 'Surface_orography',
+                          'Temperature': 'Temperature',
+                          'Total_precipitation': 'Total_precipitation',
+                          'U-velocity': 'U-velocity',
+                          'V-velocity': 'V-velocity',
+                          'Vertical_velocity': 'Vertical_velocity',
+                          'Wet_Bulb_Poten_Temper': 'Wet_Bulb_Poten_Temper',
+                          'freezing_level_zeroDegC_isotherm': 'freezing_level_zeroDegC_isotherm',}}
+
+
         for idx, (k, item) in enumerate(orthos.items()):
             for kdx, (m, subitem) in enumerate(item.items()):
                 self.add_object(which='wmsback',
@@ -5308,6 +5425,27 @@ class WolfMapViewer(wx.Frame):
                                                     self, xmin, xmax, ymin, ymax, -99999, 1024, LifeWatch=True),
                                 ToCheck=False, id='LifeWatch LC' + m)
 
+        for idx, (k, item) in enumerate(ign_belgique.items()):
+            for kdx, (m, subitem) in enumerate(item.items()):
+                self.add_object(which='wmsback',
+                                newobj=imagetexture('Orthos IGN', m, k, subitem,
+                                                    self, xmin, xmax, ymin, ymax, -99999, 1024, IGN_Belgium=True),
+                                ToCheck=False, id='IGN ' + m)
+
+        for idx, (k, item) in enumerate(ign_cartoweb.items()):
+            for kdx, (m, subitem) in enumerate(item.items()):
+                self.add_object(which='wmsback',
+                                newobj=imagetexture('Cartoweb IGN', m, k, subitem,
+                                                    self, xmin, xmax, ymin, ymax, -99999, 1024, IGN_Cartoweb=True),
+                                ToCheck=False, id='IGN ' + m)
+
+        for idx, (k, item) in enumerate(ign_postflood2021.items()):
+            for kdx, (m, subitem) in enumerate(item.items()):
+                self.add_object(which='wmsback',
+                                newobj=imagetexture('IGN 2021', m, k, subitem,
+                                                    self, xmin, xmax, ymin, ymax, -99999, 1024, postFlood2021=True),
+                                ToCheck=False, id='orthos post2021')
+
         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'),
@@ -5331,6 +5469,20 @@ class WolfMapViewer(wx.Frame):
                                                     self, xmin, xmax, ymin, ymax, -99999, 1024),
                                 ToCheck=False, id=m)
 
+        for idx, (k, item) in enumerate(alaro.items()):
+            for kdx, (m, subitem) in enumerate(item.items()):
+                self.add_object(which='wmsfore',
+                                newobj=imagetexture('ALARO', m, k, subitem,
+                                                    self, xmin, xmax, ymin, ymax, -99999, 1024, Alaro=True),
+                                ToCheck=False, id='ALARO ' + m)
+
+        for idx, (k, item) in enumerate(ign_cartoweb.items()):
+            for kdx, (m, subitem) in enumerate(item.items()):
+                self.add_object(which='wmsfore',
+                                newobj=imagetexture('Cartoweb', m, k, subitem,
+                                                    self, xmin, xmax, ymin, ymax, -99999, 1024, IGN_Cartoweb=True),
+                                ToCheck=False, id='IGN_f ' + m)
+
         # self.add_object(which='wmsfore',
         #                 newobj=imagetexture('Cadastre Flandres', 'Plan Parcellaire 2024 (Flandres)', 'Adpf', '',
         #                                     self, xmin, xmax, ymin, ymax, -99999, 1024, Vlaanderen=True),
@@ -8309,6 +8461,20 @@ class WolfMapViewer(wx.Frame):
 
                 self._memory_views_gui.Show()
 
+        elif itemlabel == _("Memory distances..."):
+
+            if self._distances is not None:
+                if self._distances[-1].nbvectors == 0:
+                    logging.warning(_('No vector to show !'))
+                    return
+
+                self._distances.showstructure(self)
+
+        elif itemlabel == _("Add distances to viewer..."):
+
+            if self._distances is not None:
+                self.add_object('vector', newobj=self._distances, ToCheck=True, id='Distances')
+
         elif itemlabel == _("Create bridge and export gltf..."):
 
             if self.active_cs is None:
@@ -11477,8 +11643,32 @@ class WolfMapViewer(wx.Frame):
                     size = float(dlg.GetValue())
                 curobj.creategrid(size, self.xmin, self.ymin, self.xmax, self.ymax)
 
+            if 'alaro' in curobj.idx and check:
+                if self.alaro_navigator is None:
+                    self.alaro_navigator = Alaro_Navigator(self, curobj.idx, 'Alaro')
+                    self.alaro_navigator.Show()
+
             self.Refresh()
 
+    def _alaro_update_time(self):
+        """ Update the time of the alaro navigator """
+
+        objs = self.get_list_objects(drawing_type=draw_type.WMSFORE, checked_state=True)
+        for obj in objs:
+            obj.time = self.alaro_navigator.time_str
+            obj.alpha = self.alaro_navigator.alpha
+            obj.force_alpha = True
+
+        self._update_foreground()
+        self.Paint()
+
+    def _alaro_legends(self):
+        """ Show images of the checked alaro layers"""
+        objs = self.get_list_objects(drawing_type=draw_type.WMSFORE, checked_state=True)
+        for obj in objs:
+            img = Image.open(get_Alaro_legend(obj.idx.replace('alaro ', '')))
+            img.show()
+
     def getXY(self, pospix):
 
         width, height = self.canvas.GetSize()
@@ -12994,6 +13184,13 @@ class WolfMapViewer(wx.Frame):
 
             if self.action == 'distance along vector':
 
+                dlg = wx.MessageDialog(None, _('Memorize the vector ?'), _('Confirm'), wx.YES_NO | wx.YES_DEFAULT | wx.ICON_QUESTION)
+                ret = dlg.ShowModal()
+                dlg.Destroy()
+
+                if ret == wx.ID_YES:
+                    self._distances[-1].add_vector(self._tmp_vector_distance, forceparent=True, update_struct=True)
+
                 self._tmp_vector_distance = None
 
             elif self.action == 'pick landmap':

wolfhece/PyVertexvectors.py

@@ -6631,8 +6631,9 @@ class Zones(wx.Frame, Element_To_Draw):
         """
         Affichage des propriétés des zones
 
-        parent : soit une instance 'WolfMapViewer', soit une instance 'Ops_Array'  --> est utile pour transférer la propriété 'active_vector' et obtenir diverses informations
-          si parent est d'un autre type, il faut s'assurer que les options/actions sont consistantes
+        :param parent: soit une instance 'WolfMapViewer', soit une instance 'Ops_Array'  --> est utile pour transférer la propriété 'active_vector' et obtenir diverses informations
+                       si parent est d'un autre type, il faut s'assurer que les options/actions sont consistantes
+        :param forceupdate: si True, on force la mise à jour de la structure
 
         """
         self.showstructure(parent, forceupdate)
@@ -6652,8 +6653,9 @@ class Zones(wx.Frame, Element_To_Draw):
         """
         Affichage de la structure des zones
 
-        parent : soit une instance 'WolfMapViewer', soit une instance 'Ops_Array'  --> est utile pour transférer la propriété 'active_vector' et obtenir diverses informations
-          si parent est d'un autre type, il faut s'assurer que les options/actions sont consistantes
+        :param parent: soit une instance 'WolfMapViewer', soit une instance 'Ops_Array'  --> est utile pour transférer la propriété 'active_vector' et obtenir diverses informations
+                        si parent est d'un autre type, il faut s'assurer que les options/actions sont consistantes
+        :param forceupdate: si True, on force la mise à jour de la structure
 
         """
         if self.parent is None:

wolfhece/PyWMS.py

@@ -17,8 +17,12 @@ import wx
 import logging
 from typing import Union, Literal
 from enum import Enum
+from datetime import datetime, timedelta
 
-from .PyTranslate import _
+try:
+    from .PyTranslate import _
+except:
+    from wolfhece.PyTranslate import _
 
 def to_image(mybytes:BytesIO) -> Image:
     return Image.open(mybytes)
@@ -272,11 +276,638 @@ def getLifeWatch(cat:Literal['None'],
             logging.warning(_('Impossible to get data from web services'))
             return None
 
+def getNGI(cat:Literal['orthoimage_coverage',
+                       'orthoimage_coverage_2016',
+                       'orthoimage_coverage_2017',
+                       'orthoimage_coverage_2018',
+                       'orthoimage_coverage_2019',
+                       'orthoimage_coverage_2020',
+                       'orthoimage_coverage_2021',
+                       'orthoimage_coverage_2022'],
+                xl:float,
+                yl:float,
+                xr:float,
+                yr:float,
+                w:int = None,
+                h:int = None,
+                tofile=True,
+                format:Literal['image/png', 'image/GeoTIFF']='image/png') -> BytesIO:
+
+    wms=WebMapService(f'https://wms.ngi.be/inspire/ortho/service?',
+                        version='1.3.0', timeout=10)
+
+    ppkm = 300
+    if w is None and h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+    elif w is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = h/real_h
+        w = int(real_w * ppkm)
+        # h = int(real_h * ppkm)
+    elif h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = w/real_w
+        # w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+
+    MAXSIZE = 4000
+    if w > MAXSIZE:
+        pond = w / MAXSIZE
+        w = MAXSIZE
+        h = int(h / pond)
+    if h > MAXSIZE:
+        pond = h / MAXSIZE
+        h = MAXSIZE
+        w = int(w / pond)
+
+    if tofile:
+        img=wms.getmap(layers=['lc_hr_raster'],
+                    #    styles=['default'],
+                       srs='EPSG:31370',
+                       bbox=(xl,yl,xr,yr),
+                       size=(w,h),
+                       format='image/png',
+                       transparent=False)
+
+        out = open('LifeWatch.png', 'wb')
+        out.write(img.read())
+        out.close()
+        return None
+    else:
+        mycontents=list(wms.contents) # List all available layers
+        curcont=[cat] # 'MS
+        curstyles=['1']
+
+        # convert from EPSG:31370 to EPSG:3812
+        transf=pyproj.Transformer.from_crs('EPSG:31370','EPSG:3812')
+        x1,y1=transf.transform(xl,yl)
+        x2,y2=transf.transform(xr,yr)
+
+        try:
+            img=wms.getmap(layers=curcont,
+                        #    styles=curstyles,
+                           srs='EPSG:3812',
+                           bbox=(x1,y1,x2,y2),
+                           size=(w,h),
+                           format=format,
+                           transparent=False)
+
+            return BytesIO(img.read())
+
+        except:
+            logging.warning(_('Impossible to get data from web services'))
+            return None
+
+def getCartoweb(cat:Literal['crossborder',
+                            'crossborder_grey',
+                            'overlay',
+                            'topo',
+                            'topo_grey'],
+                xl:float,
+                yl:float,
+                xr:float,
+                yr:float,
+                w:int = None,
+                h:int = None,
+                tofile=True,
+                format:Literal['image/png', 'image/GeoTIFF']='image/png') -> BytesIO:
+
+    wms=WebMapService(f'https://cartoweb.wms.ngi.be/service?',
+                        version='1.3.0', timeout=10)
+
+    ppkm = 300
+    if w is None and h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+    elif w is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = h/real_h
+        w = int(real_w * ppkm)
+        # h = int(real_h * ppkm)
+    elif h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = w/real_w
+        # w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+
+    MAXSIZE = 2000
+    if w > MAXSIZE:
+        pond = w / MAXSIZE
+        w = MAXSIZE
+        h = int(h / pond)
+    if h > MAXSIZE:
+        pond = h / MAXSIZE
+        h = MAXSIZE
+        w = int(w / pond)
+
+    if tofile:
+        img=wms.getmap(layers=['lc_hr_raster'],
+                    #    styles=['default'],
+                       srs='EPSG:31370',
+                       bbox=(xl,yl,xr,yr),
+                       size=(w,h),
+                       format='image/png',
+                       transparent=False)
+
+        out = open('LifeWatch.png', 'wb')
+        out.write(img.read())
+        out.close()
+        return None
+    else:
+        mycontents=list(wms.contents) # List all available layers
+        curcont=[cat] # 'MS
+        curstyles=['1']
+
+        try:
+            img=wms.getmap(layers=curcont,
+                        #    styles=curstyles,
+                           srs='EPSG:31370',
+                           bbox=(xl,yl,xr,yr),
+                           size=(w,h),
+                           format=format,
+                           transparent=True)
+
+            return BytesIO(img.read())
+
+        except:
+            logging.warning(_('Impossible to get data from web services'))
+            return None
+
+def getOrthoPostFlood2021(cat:Literal['orthoimage_flood'],
+                xl:float,
+                yl:float,
+                xr:float,
+                yr:float,
+                w:int = None,
+                h:int = None,
+                tofile=True,
+                format:Literal['image/png', 'image/GeoTIFF']='image/png') -> BytesIO:
+
+    wms=WebMapService(f'https://wms.ngi.be/inspire/flood_ortho/service?',
+                        version='1.3.0', timeout=10)
+
+    ppkm = 300
+    if w is None and h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+    elif w is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = h/real_h
+        w = int(real_w * ppkm)
+        # h = int(real_h * ppkm)
+    elif h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = w/real_w
+        # w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+
+    MAXSIZE = 4000
+    if w > MAXSIZE:
+        pond = w / MAXSIZE
+        w = MAXSIZE
+        h = int(h / pond)
+    if h > MAXSIZE:
+        pond = h / MAXSIZE
+        h = MAXSIZE
+        w = int(w / pond)
+
+    if tofile:
+        img=wms.getmap(layers=['lc_hr_raster'],
+                    #    styles=['default'],
+                       srs='EPSG:31370',
+                       bbox=(xl,yl,xr,yr),
+                       size=(w,h),
+                       format='image/png',
+                       transparent=False)
+
+        out = open('LifeWatch.png', 'wb')
+        out.write(img.read())
+        out.close()
+        return None
+    else:
+        mycontents=list(wms.contents) # List all available layers
+        curcont=[cat] # 'MS
+        curstyles=['1']
+
+        # convert from EPSG:31370 to EPSG:3812
+        transf=pyproj.Transformer.from_crs('EPSG:31370','EPSG:3812')
+        x1,y1=transf.transform(xl,yl)
+        x2,y2=transf.transform(xr,yr)
+
+        try:
+            img=wms.getmap(layers=curcont,
+                        #    styles=curstyles,
+                           srs='EPSG:3812',
+                           bbox=(x1,y1,x2,y2),
+                           size=(w,h),
+                           format=format,
+                           transparent=False)
+
+            return BytesIO(img.read())
+
+        except:
+            logging.warning(_('Impossible to get data from web services'))
+            return None
+
+def get_Alaro_times():
+    wms=WebMapService(f'https://opendata.meteo.be/service/alaro/wms?',
+                        version='1.3.0', timeout=10)
+    times = wms['Total_precipitation'].timepositions[0].split('/')
+
+    return times
+
+def get_Alaro_legend(layer:str):
+    """ Get the legend of the layer
+
+    :param layer: name of the layer
+    :return: legend of the layer
+    """
+    import requests
+    from io import BytesIO
+    layers = ['10_m_u__wind_component',
+                         '10_m_v__wind_component',
+                         '2_m_Max_temp_since_ppp',
+                         '2_m_Min_temp_since_ppp',
+                         '2_m_dewpoint_temperature',
+                         '2_m_temperature',
+                         '2m_Relative_humidity',
+                         'Convective_rain',
+                         'Convective_snow',
+                         'Geopotential',
+                         'Inst_flx_Conv_Cld_Cover',
+                         'Inst_flx_High_Cld_Cover',
+                         'Inst_flx_Low_Cld_Cover',
+                         'Inst_flx_Medium_Cld_Cover',
+                         'Inst_flx_Tot_Cld_cover',
+                         'Large_scale_rain',
+                         'Large_scale_snow',
+                         'Mean_sea_level_pressure',
+                         'Relative_humidity',
+                         'Relative_humidity_isobaric',
+                         'SBL_Meridian_gust',
+                         'SBL_Zonal_gust',
+                         'Specific_humidity',
+                         'Surf_Solar_radiation',
+                         'Surf_Thermal_radiation',
+                         'Surface_CAPE',
+                         'Surface_Temperature',
+                         'Surface_orography',
+                         'Temperature',
+                         'Total_precipitation',
+                         'U-velocity',
+                         'V-velocity',
+                         'Vertical_velocity',
+                         'Wet_Bulb_Poten_Temper',
+                         'freezing_level_zeroDegC_isotherm']
+
+    layers_lowercase = [l.lower() for l in layers]
+    if layer.lower() not in layers_lowercase:
+        logging.warning(_('Layer not found in the list of available layers'))
+        return None
+
+    layer = layers[layers_lowercase.index(layer.lower())]
+
+    ows = "https://opendata.meteo.be/geoserver/alaro/ows?"
+
+    legend = requests.get(ows, params={'layer': layer,
+                                       'width': 50,
+                                       'height': 50,
+                                       'format': 'image/png',
+                                       'service': 'WMS',
+                                       'version': '1.3.0',
+                                       'request': 'GetLegendGraphic'})
+
+    return BytesIO(legend.content)
+
+def getAlaro(cat:Literal['10_m_u__wind_component',
+                         '10_m_v__wind_component',
+                         '2_m_Max_temp_since_ppp',
+                         '2_m_Min_temp_since_ppp',
+                         '2_m_dewpoint_temperature',
+                         '2_m_temperature',
+                         '2m_Relative_humidity',
+                         'Convective_rain',
+                         'Convective_snow',
+                         'Geopotential',
+                         'Inst_flx_Conv_Cld_Cover',
+                         'Inst_flx_High_Cld_Cover',
+                         'Inst_flx_Low_Cld_Cover',
+                         'Inst_flx_Medium_Cld_Cover',
+                         'Inst_flx_Tot_Cld_cover',
+                         'Large_scale_rain',
+                         'Large_scale_snow',
+                         'Mean_sea_level_pressure',
+                         'Relative_humidity',
+                         'Relative_humidity_isobaric',
+                         'SBL_Meridian_gust',
+                         'SBL_Zonal_gust',
+                         'Specific_humidity',
+                         'Surf_Solar_radiation',
+                         'Surf_Thermal_radiation',
+                         'Surface_CAPE',
+                         'Surface_Temperature',
+                         'Surface_orography',
+                         'Temperature',
+                         'Total_precipitation',
+                         'U-velocity',
+                         'V-velocity',
+                         'Vertical_velocity',
+                         'Wet_Bulb_Poten_Temper',
+                         'freezing_level_zeroDegC_isotherm'],
+                xl:float,
+                yl:float,
+                xr:float,
+                yr:float,
+                w:int = None,
+                h:int = None,
+                tofile=True,
+                format:Literal['image/png', 'image/GeoTIFF']='image/png',
+                time = None) -> BytesIO:
+
+    wms=WebMapService(f'https://opendata.meteo.be/service/alaro/wms?',
+                        version='1.3.0', timeout=10)
+
+    ppkm = 300
+    if w is None and h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+    elif w is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = h/real_h
+        w = int(real_w * ppkm)
+        # h = int(real_h * ppkm)
+    elif h is None:
+        real_w = (xr-xl)/1000
+        real_h = (yr-yl)/1000
+        ppkm = w/real_w
+        # w = int(real_w * ppkm)
+        h = int(real_h * ppkm)
+
+    MAXSIZE = 2000
+    if w > MAXSIZE:
+        pond = w / MAXSIZE
+        w = MAXSIZE
+        h = int(h / pond)
+    if h > MAXSIZE:
+        pond = h / MAXSIZE
+        h = MAXSIZE
+        w = int(w / pond)
+
+    if tofile:
+        img=wms.getmap(layers=['lc_hr_raster'],
+                    #    styles=['default'],
+                       srs='EPSG:31370',
+                       bbox=(xl,yl,xr,yr),
+                       size=(w,h),
+                       format='image/png',
+                       transparent=False)
+
+        out = open('LifeWatch.png', 'wb')
+        out.write(img.read())
+        out.close()
+        return None
+    else:
+        mycontents=list(wms.contents) # List all available layers
+        curcont=[cat] # 'MS
+        curstyles=['1']
+
+        # test = get_Alaro_legend(cat)
+
+        try:
+            if time is None:
+                time = wms[cat].timepositions[0].split('/')[0]
+
+            img=wms.getmap(layers=curcont,
+                        #    styles=curstyles,
+                           srs='EPSG:31370',
+                           bbox=(xl,yl,xr,yr),
+                           size=(w,h),
+                           format=format,
+                           transparent=False,
+                           time = time)
+
+            return BytesIO(img.read())
+
+        except:
+            logging.warning(_('Impossible to get data from web services'))
+            return None
+
+class Alaro_Navigator(wx.Frame):
+    """ Frame to navigate through Alaro data
+
+    Propose a caolendar to select the time of the data
+    """
+
+    def __init__(self, parent, id, title):
+        super(Alaro_Navigator, self).__init__(parent, title=title, size=(500, 150))
+
+        panel = wx.Panel(self)
+        vbox = wx.BoxSizer(wx.VERTICAL)
+        hbox = wx.BoxSizer(wx.HORIZONTAL)
+        hbox_start_end = wx.BoxSizer(wx.HORIZONTAL)
+        hbox_interv_alpha = wx.BoxSizer(wx.HORIZONTAL)
+
+        t_start, t_end, interv = get_Alaro_times()
+        self._start_date = wx.TextCtrl(panel, value=t_start.replace('.000Z', 'Z'), size=(100, -1), style=wx.TE_READONLY | wx.TE_CENTER)
+        self._end_date = wx.TextCtrl(panel, value=t_end.replace('.000Z', 'Z'), size=(100, -1), style=wx.TE_READONLY | wx.TE_CENTER)
+        self._interval = wx.TextCtrl(panel, value=interv.replace('PT',''), size=(100, -1), style=wx.TE_READONLY | wx.TE_CENTER)
+
+        self._btn_previous = wx.Button(panel, label=_('Previous'), size=(100, -1))
+        self._btn_next = wx.Button(panel, label=_('Next'), size=(100, -1))
+        self._time = wx.TextCtrl(panel, value=t_start.replace('.000Z', 'Z'), size=(100, -1), style=wx.TE_CENTER | wx.TE_PROCESS_ENTER)
+        self._alpha = wx.TextCtrl(panel, value='1.0', size=(100, -1), style=wx.TE_CENTER | wx.TE_PROCESS_ENTER)
+        self._alpha.SetToolTip(_('Transparency of the image (0-1)'))
+
+        self._btn_legend = wx.Button(panel, label=_('Legend'), size=(100, -1))
+        self._btn_legend.Bind(wx.EVT_BUTTON, self.OnLegend)
+
+        self._time.Bind(wx.EVT_TEXT_ENTER, self.OnEnterTime)
+
+        hbox.Add(self._btn_previous, 1, flag=wx.EXPAND | wx.ALL, border=1)
+        hbox.Add(self._time, 1, flag=wx.EXPAND | wx.ALL, border=1)
+        hbox.Add(self._btn_next, 1, flag=wx.EXPAND | wx.ALL, border=1)
+
+        hbox_start_end.Add(self._start_date, 1, flag=wx.EXPAND | wx.ALL, border=1)
+        hbox_start_end.Add(self._end_date, 1, flag=wx.EXPAND | wx.ALL, border=1)
+
+        hbox_interv_alpha.Add(self._interval, 1, flag=wx.EXPAND | wx.ALL, border=1)
+        hbox_interv_alpha.Add(self._alpha, 1, flag=wx.EXPAND | wx.ALL, border=1)
+
+        vbox.Add(hbox, 1, flag=wx.EXPAND | wx.ALL, border=1)
+        vbox.Add(hbox_start_end, 1, flag=wx.EXPAND | wx.ALL, border=1)
+        vbox.Add(hbox_interv_alpha, 1, flag=wx.EXPAND | wx.ALL, border=1)
+        vbox.Add(self._btn_legend, 1, flag=wx.EXPAND | wx.ALL, border=1)
+
+        panel.SetSizer(vbox)
+
+        self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
+        self._btn_previous.Bind(wx.EVT_BUTTON, self.OnPrevious)
+        self._btn_next.Bind(wx.EVT_BUTTON, self.OnNext)
+
+    def OnPrevious(self, event):
+        """ Hour minus interval
+        """
+
+        try:
+            time = self.time
+
+            # force the time to be rounded to the nearest interval
+            interval = timedelta(hours=1)
+            # nullify the minutes and seconds
+            time = time.replace(minute=0, second=0, microsecond=0, hour=time.hour - 1)
+
+            # check is the time is in the interval
+            if time < self.start or time > self.end:
+                wx.MessageBox(_('The date is not valid'), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+
+            self.time = time
+        except ValueError:
+            wx.MessageBox(_('The date is not valid'), _('Error'), wx.OK | wx.ICON_ERROR)
+            return
+        except Exception as e:
+            wx.MessageBox(_('An error occurred: ') + str(e), _('Error'), wx.OK | wx.ICON_ERROR)
+            return
+
+        self.Parent._alaro_update_time()
+
+        event.Skip()
+
+    def OnNext(self, event):
+        """ Hour plus interval
+        """
+
+        try:
+            time = self.time
+
+            # force the time to be rounded to the nearest interval
+            interval = timedelta(hours=1)
+            # nullify the minutes and seconds
+            time = time.replace(minute=0, second=0, microsecond=0, hour=time.hour + 1)
+
+            # check is the time is in the interval
+            if time < self.start or time > self.end:
+                wx.MessageBox(_('The date is not valid'), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+
+            self.time = time
+        except ValueError:
+            wx.MessageBox(_('The date is not valid'), _('Error'), wx.OK | wx.ICON_ERROR)
+            return
+        except Exception as e:
+            wx.MessageBox(_('An error occurred: ') + str(e), _('Error'), wx.OK | wx.ICON_ERROR)
+            return
+
+        self.Parent._alaro_update_time()
+
+        event.Skip()
+
+    def OnCloseWindow(self, event):
+        self.Hide()
+
+        event.Skip()
+
+    def OnLegend(self, event):
+        """ Called when the user press the legend button
+        """
+
+        # get the legend of the layer
+        layer = self.Parent._alaro_legends()
+
+        event.Skip()
+
+    def OnEnterTime(self, event):
+        """ Called when the user press enter in the time text box
+        """
+
+        # time must be rounded to the nearest interval
+        try:
+            time = self.time
+
+            # force the time to be rounded to the nearest interval
+            interval = timedelta(hours=1)
+            # nullify the minutes and seconds
+            time = time.replace(minute=0, second=0, microsecond=0)
+
+            # check is the time is in the interval
+            if time < self.start or time > self.end:
+                wx.MessageBox(_('The date is not valid'), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+
+            self.time = time
+        except ValueError:
+            wx.MessageBox(_('The date is not valid'), _('Error'), wx.OK | wx.ICON_ERROR)
+            return
+        except Exception as e:
+            wx.MessageBox(_('An error occurred: ') + str(e), _('Error'), wx.OK | wx.ICON_ERROR)
+            return
+
+        self.Parent._alaro_update_time()
+
+        event.Skip()
+
+    @property
+    def start(self):
+        """ Return the start date selected by the user
+        """
+        return datetime.strptime(self._start_date.GetValue(), '%Y-%m-%dT%H:%M:%SZ')
+
+    @property
+    def end(self):
+        """ Return the end date selected by the user
+        """
+        return datetime.strptime(self._end_date.GetValue(), '%Y-%m-%dT%H:%M:%SZ')
+
+    @property
+    def time(self):
+        """ Return the time selected by the user
+        """
+        return datetime.strptime(self._time.GetValue(), '%Y-%m-%dT%H:%M:%SZ')
+
+    @time.setter
+    def time(self, value:datetime):
+        """ Set the time selected by the user
+        """
+        self._time.SetValue(value.strftime('%Y-%m-%dT%H:%M:%SZ'))
+
+    @property
+    def time_str(self):
+        """ Return the time selected by the user as string
+        """
+        return self._time.GetValue()
+
+    @property
+    def alpha(self):
+        """ Return the alpha value selected by the user
+        """
+        try:
+            return float(self._alpha.GetValue())
+        except:
+            self._alpha.SetValue('1.0')
+            return 1.0
+
+
 if __name__=='__main__':
     # me=pyproj.CRS.from_epsg(27573)
     # t=pyproj.Transformer.from_crs(27573,4326)
     # getIGNFrance('OI.OrthoimageCoverage.HR','EPSG:27563',878000,332300,879000,333300,1000,1000)
-    img = getLifeWatch('',250000,160000,252000,162000,1000,1000,False)
+    img = getAlaro('Total_precipitation',250000,160000,252000,162000,1000,1000,False)
     img = Image.open(img)
     img.show()
     pass

wolfhece/apps/version.py

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

wolfhece/wolf_texture.py

@@ -26,7 +26,7 @@ import math
 import numpy as np
 
 from .PyTranslate import _
-from .PyWMS import getIGNFrance, getWalonmap, getVlaanderen, getLifeWatch
+from .PyWMS import getIGNFrance, getWalonmap, getVlaanderen, getLifeWatch, getNGI, getCartoweb, getOrthoPostFlood2021, getAlaro
 from .textpillow import Font_Priority, Text_Image,Text_Infos
 from .drawing_obj import Element_To_Draw
 
@@ -121,7 +121,7 @@ class genericImagetexture(Element_To_Draw):
 
         self.update_minmax()
 
-        self.oldview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height]
+        self.oldview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height, self.time]
 
         self.load()
 
@@ -189,7 +189,7 @@ class genericImagetexture(Element_To_Draw):
 
         self.update_minmax()
 
-        self.newview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height]
+        self.newview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height, self.time]
         if self.newview != self.oldview:
             self.load()
             self.oldview = self.newview
@@ -254,7 +254,9 @@ class imagetexture(Element_To_Draw):
                  xmin:float, xmax:float, ymin:float, ymax:float,
                  width:int = 1000, height:int = 1000,
                  France:bool = False, epsg='31370', Vlaanderen:bool = False,
-                 LifeWatch:bool = False) -> None:
+                 LifeWatch:bool = False, IGN_Belgium:bool = False,
+                 IGN_Cartoweb:bool = False, postFlood2021:bool = False,
+                 Alaro:bool = False) -> None:
 
         super().__init__(label+cat+subc, plotted=False, mapviewer=mapviewer, need_for_wx=False)
 
@@ -266,6 +268,10 @@ class imagetexture(Element_To_Draw):
         self.France = France
         self.Vlaanderen = Vlaanderen
         self.LifeWatch = LifeWatch
+        self.IGN_Belgium = IGN_Belgium
+        self.IGN_Cartoweb = IGN_Cartoweb
+        self.postFlood2021 = postFlood2021
+        self.Alaro = Alaro
 
         self.epsg = epsg
 
@@ -276,6 +282,10 @@ class imagetexture(Element_To_Draw):
         self.idtexture = (GLuint * 1)()
         self.idx = 'texture_{}'.format(self.idtexture)
 
+        self.time = None
+        self.alpha = 1.0
+        self.force_alpha = False
+
         try:
             glGenTextures(1, self.idtexture)
         except:
@@ -288,7 +298,7 @@ class imagetexture(Element_To_Draw):
         self.category = cat  # .upper()
         self.name = label
         self.subcategory = subc  # .upper()
-        self.oldview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height]
+        self.oldview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height, self.time]
 
         self.load()
 
@@ -313,6 +323,26 @@ class imagetexture(Element_To_Draw):
                 mybytes = getLifeWatch(self.category + '_' + self.subcategory,
                                        self.xmin, self.ymin, self.xmax, self.ymax,
                                        self.width, self.height, False)
+            elif self.IGN_Belgium:
+                mybytes = getNGI(self.subcategory,
+                                       self.xmin, self.ymin, self.xmax, self.ymax,
+                                       self.width, self.height, False)
+
+            elif self.IGN_Cartoweb:
+                mybytes = getCartoweb(self.subcategory,
+                                       self.xmin, self.ymin, self.xmax, self.ymax,
+                                       self.width, self.height, False)
+
+            elif self.postFlood2021:
+                mybytes = getOrthoPostFlood2021(self.subcategory,
+                                       self.xmin, self.ymin, self.xmax, self.ymax,
+                                       self.width, self.height, False)
+
+            elif self.Alaro:
+                mybytes = getAlaro(self.subcategory,
+                                       self.xmin, self.ymin, self.xmax, self.ymax,
+                                       self.width, self.height, False, time= self.time)
+
             else:
                 mybytes = getWalonmap(self.category + '/' + self.subcategory,
                                       self.xmin, self.ymin, self.xmax, self.ymax,
@@ -323,20 +353,51 @@ class imagetexture(Element_To_Draw):
                 return
 
             try:
-                image = Image.open(mybytes)
+                if isinstance(mybytes, bytes | BytesIO):
+                    image = Image.open(mybytes)
+
+                    if image.mode != 'RGBA':
+                        image = image.convert('RGBA')
+
+                    if self.force_alpha:
+                        if self.alpha < 0.0:
+                            self.alpha = 0.0
+                        if self.alpha > 1.0:
+                            self.alpha = 1.0
+
+                        alpha = Image.new('L', image.size, int(self.alpha * 255))
+
+                        image.putalpha(alpha)
+
+                elif isinstance(mybytes, str):
+                    image = Image.open(mybytes).convert('RGB')
+
+                    if image.width != self.width or image.height != self.height:
+                        image = image.resize((self.width, self.height), Image.ANTIALIAS)
+
+                    image_memory = BytesIO()
+                    image.save(image_memory, format='PNG')
+                    image = Image.open(image_memory)
+
+                elif isinstance(mybytes, Image.Image):
+                    image = mybytes
+                else:
+                    logging.error(_('Unknown type of image file : ') + str(type(mybytes)))
+                    return
+
             except Exception as e:
                 logging.warning(_('Error opening image file : ') + str(self.category + '/' + self.subcategory))
                 return
 
             glBindTexture(GL_TEXTURE_2D, self.idtexture[0])
             if self.subcategory[:5] == 'ORTHO':
-                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                              image.tobytes())
             elif image.mode == 'RGB':
-                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGB, GL_UNSIGNED_BYTE,
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image.width, image.height, 0, GL_RGB, GL_UNSIGNED_BYTE,
                              image.tobytes())
             else:
-                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width, image.height, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                              image.tobytes())
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
             glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR)
@@ -357,10 +418,10 @@ class imagetexture(Element_To_Draw):
         self.xmax = cx + dx * coeff
         self.ymin = cy - dy * coeff
         self.ymax = cy + dy * coeff
-        self.width = self.mapviewer.canvaswidth * 2 * coeff
-        self.height = self.mapviewer.canvasheight * 2 * coeff
+        self.width = int(self.mapviewer.canvaswidth * 2 * coeff)
+        self.height = int(self.mapviewer.canvasheight * 2 * coeff)
 
-        self.newview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height]
+        self.newview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height, self.time]
         if self.newview != self.oldview:
             self.load()
             self.oldview = self.newview
@@ -440,7 +501,7 @@ class Text_Image_Texture(genericImagetexture):
             self.width = self.myImage.width
             self.height = self.myImage.height
 
-        self.oldview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height]
+        self.oldview = [self.xmin, self.xmax, self.ymin, self.ymax, self.width, self.height, self.time]
 
     def findscale(self):
 

{wolfhece-2.2.14.dist-info → wolfhece-2.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.14
+Version: 2.2.15
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece

{wolfhece-2.2.14.dist-info → wolfhece-2.2.15.dist-info}/RECORD

@@ -8,7 +8,7 @@ wolfhece/Model1D.py,sha256=SI4oNF_J3MdjiWZoizS8kuRXLMVyymX9dYfYJNVCQVI,476989
 wolfhece/PandasGrid.py,sha256=YIleVkUkoP2MjtQBZ9Xgwk61zbgMj4Pmjj-clVTfPRs,2353
 wolfhece/PyConfig.py,sha256=Y0wtSIFpAMYa7IByh7hbW-WEOVjNsQEduq7vhIYdZQw,16716
 wolfhece/PyCrosssections.py,sha256=igU_ELrg5VrHU6RNbF5tHxPyVImpR3xdpfopJYc7haw,114711
-wolfhece/PyDraw.py,sha256=MUxnzykOYLJFkF9tA6nutkasSTyDEuNzbwnfa_vmZF8,635057
+wolfhece/PyDraw.py,sha256=XyISYI30lJA6ueh_-zcQakLagTeW7C9SnjHz6UYm-u8,645007
 wolfhece/PyGui.py,sha256=jhpOPYRDG3ms1oi7FUs2W80T4SdPssZEnijxqFtn6vA,145199
 wolfhece/PyGuiHydrology.py,sha256=sKafpOopBg50L5llZCI_fZtbebVTDtxvoRI6-osUwhg,14745
 wolfhece/PyHydrographs.py,sha256=1P5XAURNqCvtSsMQXhOn1ihjTpr725sRsZdlCEhhk6M,3730
@@ -17,8 +17,8 @@ wolfhece/PyParams.py,sha256=Dh9C_WYICMjo3m9roRySsu8ZgFzzYhSr6RpbaXZni0M,99423
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=WT2UprotBUEA6rvs8kXfPRscKrhIL4_pya2UylzoBJE,50385
-wolfhece/PyVertexvectors.py,sha256=yPqE1rmqCSAucjNjSo1_srKHMwjqYWe0lx7S2Wbpryw,327905
-wolfhece/PyWMS.py,sha256=e6cMA72xLnpFZQtM99lItTyIfUQKz0f5f1iL_bwJVPQ,9303
+wolfhece/PyVertexvectors.py,sha256=D-7aLqxAcJ39xDx1fwA1zzP1uFR28IiZUjFwpQEcv8E,328102
+wolfhece/PyWMS.py,sha256=-wU-oWS5il1z702gYd90xHx5O7PvGNr9nb693oue_cI,31412
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
 wolfhece/RatingCurve_xml.py,sha256=cUjReVMHFKtakA2wVey5zz6lCgHlSr72y7ZfswZDvTM,33891
@@ -60,7 +60,7 @@ wolfhece/tools2d_dll.py,sha256=oU0m9XYAf4CZsMoB68IuKeE6SQh-AqY7O5NVED8r9uw,13125
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
 wolfhece/wolf_array.py,sha256=PlImSCX5lUeoqPR7ogqak_Zl6dLyGn5EXUzeD_6-xAU,497218
 wolfhece/wolf_hist.py,sha256=7jeVrgSkM3ErJO6SRMH_PGzfLjIdw8vTy87kesldggk,3582
-wolfhece/wolf_texture.py,sha256=KlT8g4dBmH819n8mqQ8pCHLGST1C5bd4OaR_et5wsUM,18092
+wolfhece/wolf_texture.py,sha256=_YMMz3w1re70rrpO_AcFlb7QC4R3_631Hgnl5BRNH1o,20832
 wolfhece/wolf_tiles.py,sha256=v-HohqaWuMYdn75XLnA22dlloAG90iwnIqrgnB0ASQ4,10488
 wolfhece/wolf_vrt.py,sha256=wbxXVN7TL9zgdyF79S-4e3pje6wJEAgBEfF_Y8kkzxs,14271
 wolfhece/wolf_zi_db.py,sha256=baE0niMCzybWGSvPJc5FNxo9ZxsGfU4p-FmfiavFHAs,12967
@@ -86,7 +86,7 @@ wolfhece/apps/curvedigitizer.py,sha256=lEJJwgAfulrrWQc-U6ij6sj59hWN3SZl4Yu1kQxVz
 wolfhece/apps/hydrometry.py,sha256=lhhJsFeb4zGL4bNQTs0co85OQ_6ssL1Oy0OUJCzhfYE,656
 wolfhece/apps/isocurrent.py,sha256=dagmGR8ja9QQ1gwz_8fU-N052hIw-W0mWGVkzLu6C7I,4247
 wolfhece/apps/splashscreen.py,sha256=eCPAUYscZPWDYKBHDBWum_VIcE7WXOCBe1GLHL3KUmU,3088
-wolfhece/apps/version.py,sha256=K1wI1QprwJhkLzJfrbY1MD9huUZViybAZpuclY2ssps,388
+wolfhece/apps/version.py,sha256=0IImrhN7acakKZi7KU7SSwA22Tx6X_NNUXIqvorewWc,388
 wolfhece/apps/wolf.py,sha256=j_CgvsL8rwixbVvVD5Z0s7m7cHZ86gmFLojKGuetMls,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -333,8 +333,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=8PlMYrb_8jI8h9F0_EagpM
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=ORy7fz4dcp691qKzaOZHrRLZ0uXNhL-LIHxmpDGL6BI,5007
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.2.14.dist-info/METADATA,sha256=Y7UYL2Y3HjkDspeALQzelJ9yNiWX4bx42gHbYLXjrJA,2731
-wolfhece-2.2.14.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-wolfhece-2.2.14.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
-wolfhece-2.2.14.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.14.dist-info/RECORD,,
+wolfhece-2.2.15.dist-info/METADATA,sha256=0ZU3v8YJGzebmgGIryaoqn00Mx_VoXPxCjdHy77z3pc,2731
+wolfhece-2.2.15.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+wolfhece-2.2.15.dist-info/entry_points.txt,sha256=ZZ-aSfbpdcmo-wo84lRFzBN7LaSnD1XRGSaAKVX-Gpc,522
+wolfhece-2.2.15.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.15.dist-info/RECORD,,

{wolfhece-2.2.14.dist-info → wolfhece-2.2.15.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.3.1)
 Root-Is-Purelib: true
 Tag: py3-none-any