wolfhece 2.1.107__py3-none-any.whl → 2.1.108__py3-none-any.whl

wolfhece/PyDraw.py

@@ -4001,10 +4001,17 @@ class WolfMapViewer(wx.Frame):
                                '2006-2007': 'ORTHO_2006_2007',
                                '2009-2010': 'ORTHO_2009_2010',
                                '2012-2013': 'ORTHO_2012_2013',
-                               '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',
+                               '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',
+                               'Last one': 'ORTHO_LAST',
                                }}
         data_2021 = {'EAU': {'IDW': 'ZONES_INONDEES_IDW',
                              'Emprise': 'ZONES_INONDEES',
@@ -4030,9 +4037,14 @@ class WolfMapViewer(wx.Frame):
                         ToCheck=False, id='Orthos France')
 
         forelist = {'EAU': {'Aqualim': 'RES_LIMNI_DGARNE', 'Alea': 'ALEA_INOND', 'Lidaxes': 'LIDAXES'},
-                    'LIMITES': {'Secteurs Statistiques': 'LIMITES_QS_STATBEL'},
-                    'INSPIRE': {'Limites administratives': 'AU_wms'},
-                    'PLAN_REGLEMENT': {'Plan Percellaire': 'CADMAP_2021_PARCELLES'}}
+                    'LIMITES': {'Secteurs Statistiques': 'LIMITES_QS_STATBEL',
+                                'Limites administratives': 'LIMITES_ADMINISTRATIVES'},
+                    'R3C': {'Limites Communes': 'Municipalities'},
+                    # 'INSPIRE': {'Limites administratives': 'AU_wms'},
+                    'PLAN_REGLEMENT': {'Plan Parcellaire 2021': 'CADMAP_2021_PARCELLES',
+                                       'Plan Parcellaire 2022': 'CADMAP_2022_PARCELLES',
+                                       'Plan Parcellaire 2023': 'CADMAP_2023_PARCELLES',
+                                       'Plan Parcellaire 2024': 'CADMAP_2024_PARCELLES'}}
 
         for idx, (k, item) in enumerate(forelist.items()):
             for kdx, (m, subitem) in enumerate(item.items()):
@@ -4041,6 +4053,12 @@ class WolfMapViewer(wx.Frame):
                                                     self, xmin, xmax, ymin, ymax, -99999, 1024),
                                 ToCheck=False, id=m)
 
+        # self.add_object(which='wmsfore',
+        #                 newobj=imagetexture('Cadastre Flandres', 'Plan Parcellaire 2024 (Flandres)', 'Adpf', '',
+        #                                     self, xmin, xmax, ymin, ymax, -99999, 1024, Vlaanderen=True),
+        #                 ToCheck=False, id='Plan Parcellaire 2024 (Flandres)')
+
+
     def set_compare(self, ListArrays:list[WolfArray]=None, share_colormap:bool=True):
         """
         Comparison of 2 arrays
@@ -6713,7 +6731,7 @@ class WolfMapViewer(wx.Frame):
             autoscale = False
 
             from .scenario.config_manager import Config_Manager_2D_GPU
-            newmanager = Config_Manager_2D_GPU(mapviewer=self)
+            newmanager = Config_Manager_2D_GPU(mapviewer=self, create_ui_if_wx=True)
 
         elif itemlabel == _('Create acceptability manager...'):
             autoscale = False
@@ -8846,7 +8864,11 @@ class WolfMapViewer(wx.Frame):
         curobj = self.getobj_from_id(nameitem)
         myobj = self.treelist.GetItemData(myitem)
 
-        assert curobj is myobj, 'curobj is not myobj'
+        if curobj is not myobj:
+            logging.error(_('Bad association between object and tree item'))
+            logging.error(_('Do you have 2 objects with the same id ?'))
+            logging.error(_('It could be the case if you have drag/drop an object in the viewer...'))
+            logging.error(_('I will continue but it is not normal...'))
 
         self.treelist.SetToolTip(self.treelist.GetItemText(myitem))
 
@@ -10504,7 +10526,14 @@ class WolfMapViewer(wx.Frame):
 
                     newarray.nullify_border(width=1)
 
-                    self.add_object('array', newobj = newarray, id = self.active_array.idx + '_crop')
+                    #keys for arrays
+                    keys = self.get_list_keys(draw_type.ARRAYS, checked_state=False)
+                    new_key = self.active_array.idx + '_crop'
+
+                    while new_key in keys:
+                        new_key += '_'
+
+                    self.add_object('array', newobj = newarray, id = new_key)
 
                     self.Refresh()
 

wolfhece/PyGui.py

@@ -3751,4 +3751,4 @@ class Wolf2DGPUModel(GenMapManager):
         """ Append text to the information zone """
 
         if self.wx_exists:
-            self._txt_info.AppendText(text)
+            self._txt_info.AppendText(text)

wolfhece/PyVertexvectors.py

@@ -4663,6 +4663,8 @@ class Zones(wx.Frame, Element_To_Draw):
         for idx, row in content.iterrows():
             if 'NAME' in row.keys():
                 name = row['NAME']
+            elif 'location' in row.keys():
+                name = row['location'] # tuilage gdal
             elif 'name' in row.keys():
                 name = row['name']
             elif 'MAJ_NIV3T' in row.keys():
@@ -4794,11 +4796,21 @@ class Zones(wx.Frame, Element_To_Draw):
             content = gpd.read_file(fn, bbox=bbox, layer=curlayer)
 
             if len(content)>1000:
+                logging.warning(_('Number of elements in layer {} : {}'.format(curlayer, len(content))))
                 logging.warning(_('Layer {} contains more than 1000 elements -- it may take a while to import'.format(curlayer)))
 
+                if self.wx_exists:
+                    dlg = wx.MessageDialog(None, _('Layer {} contains more than 1000 elements -- it may take a while to import\n\nContinue ?'.format(curlayer)), _('Warning'), wx.OK | wx.CANCEL | wx.ICON_WARNING)
+                    ret = dlg.ShowModal()
+                    dlg.Destroy()
+                    if ret == wx.ID_CANCEL:
+                        return
+
             for idx, row in content.iterrows():
                 if 'NAME' in row.keys():
                     name = row['NAME']
+                elif 'CANU' in row.keys():
+                    name = row['CANU']
                 elif 'MAJ_NIV3T' in row.keys():
                     # WALOUS
                     name = row['MAJ_NIV3T']

wolfhece/PyWMS.py

@@ -42,8 +42,10 @@ def getWalonmap(cat:Literal['IMAGERIE/ORTHO_2021', 'ALEA', 'CADMAP', 'LIDAXES',
         wms=WebMapService('https://geoservices.wallonie.be/arcgis/services/'
                         + catloc+'/MapServer/WMSServer',version='1.3.0')
     except:
-        wms=WebMapService('http://ccff02.minfin.fgov.be/geoservices/arcgis/services/'
+        wms=WebMapService('https://eservices.minfin.fgov.be/arcgis/services/'
                         + catloc+'/MapServer/WMSServer',version='1.3.0')
+        # wms=WebMapService('http://ccff02.minfin.fgov.be/geoservices/arcgis/services/'
+        #                 + catloc+'/MapServer/WMSServer',version='1.3.0')
 
     ppkm = 300
     if w is None and h is None:
@@ -84,6 +86,9 @@ def getWalonmap(cat:Literal['IMAGERIE/ORTHO_2021', 'ALEA', 'CADMAP', 'LIDAXES',
         elif cat.find('CADMAP')>0:
             curcont=['0,1']
             curstyles=['default,default']
+        elif cat.find('LIMITES_ADMINISTRATIVES')>0:
+            curcont=['0,1,2,3']
+            curstyles=['default,default,default,default']
         elif cat.find('wms')>0:
             curcont=['1,2,3,4,5']
             curstyles=['default,default,default,default,default']
@@ -108,6 +113,61 @@ def getWalonmap(cat:Literal['IMAGERIE/ORTHO_2021', 'ALEA', 'CADMAP', 'LIDAXES',
         except:
             logging.warning(_('Impossible to get data from web services'))
 
+def getVlaanderen(cat:Literal['Adpf'],
+                xl:float,
+                yl:float,
+                xr:float,
+                yr:float,
+                w:int = None,
+                h:int = None,
+                tofile=True) -> BytesIO:
+
+    catloc=cat
+
+    try:
+        wms=WebMapService('https://geo.api.vlaanderen.be/'
+                        + catloc+'/wms',version='1.3.0')
+    except:
+        logging.warning(_('Impossible to get data from web services'))
+        return
+
+    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)
+
+    if tofile:
+        img=wms.getmap(layers=['0'],styles=['default'],srs='EPSG:31370',bbox=(xl,yl,xr,yr),size=(w,h),format='image/png',transparent=True)
+        out = open('aqualim.png', 'wb')
+        out.write(img.read())
+        out.close()
+        return BytesIO(b'1')
+    else:
+        mycontents=list(wms.contents)
+        curcont=['Adpf']
+        curstyles=['default']
+
+        try:
+            img=wms.getmap(layers=curcont,styles=curstyles,srs='EPSG:31370',bbox=(xl,yl,xr,yr),size=(w,h),format='image/png',transparent=True)
+            return BytesIO(img.read())
+        except:
+            logging.warning(_('Impossible to get data from web services'))
+
+
 def getIGNFrance(cat:str,epsg:str,xl,yl,xr,yr,w,h,tofile=True) -> BytesIO:
 
     if epsg!='EPSG:4326':

wolfhece/acceptability/acceptability.py

@@ -51,6 +51,7 @@ class steps_vulnerability(Enum):
     CREATE_RASTERS_CODE = 11
     APPLY_MODIFS = 2
     MATCH_SIMUL = 3
+    APPLY_SCENARIOSVULN = 4
 
     @classmethod
     def get_list_names(cls):
@@ -63,8 +64,9 @@ class steps_acceptability(Enum):
     COMPUTE_LOCAL_ACCEPT        = 1
     LOAD_FROM_FILES             = 2
     COMPUTE_MEAN_ACCEPT         = 3
-    COMPUTE_WITHOUT_SCENARIOS   = 4
+    COMPUTE_BASELINE_WITHOUT_SCENARIOS   = 4
     COMPUTE_WITH_SCENARIOS      = 5
+    RESAMPLING                  = 6
 
     @classmethod
     def get_list_names(cls):
@@ -106,12 +108,12 @@ def Base_data_creation(main_dir:str = 'Data',
     LAYER_BATIEMPRISE = "CONSTR_BATIEMPRISE"
 
     manager = Accept_Manager(main_dir,
-                           Study_area,
-                           Original_gdb=Original_gdb,
-                           CaPa_Walloon=CaPa_Walloon,
-                           PICC_Walloon=PICC_Walloon,
-                           CE_IGN_top10v=CE_IGN_top10v,
-                           Vuln_csv=Vuln_csv)
+                            Study_area,
+                            Original_gdb=Original_gdb,
+                            CaPa_Walloon=CaPa_Walloon,
+                            PICC_Walloon=PICC_Walloon,
+                            CE_IGN_top10v=CE_IGN_top10v,
+                            Vuln_csv=Vuln_csv)
 
     if not manager.check_before_database_creation():
         logging.error("The necessary files are missing - Verify logs for more information")
@@ -284,7 +286,7 @@ def Vulnerability(main_dir:str = 'Data',
                   scenario:str = 'Scenario1',
                   Study_area:str = 'Bassin_Vesdre.shp',
                   resolution:float = 1.,
-                  steps:list[int] | list[steps_vulnerability] = [1,10,11,2,3],
+                  steps:list[int] | list[steps_vulnerability] = [1,10,11,2,3,4],
                   Vuln_csv:str = 'Vulnerability.csv',
                   Intermediate_csv:str = 'Intermediate.csv'):
     """
@@ -310,6 +312,7 @@ def Vulnerability(main_dir:str = 'Data',
         - [1,2,3] : All steps are computed - Necessary for the first time
         - [2,3]   : Only the scenario and clipping steps are computed -- Useful for scenario changes
         - [3]     : Only the clipping step is computed -- Useful if simulation area changes but scenario is the same
+        - [4]     : Compute the vulnerability for vuln_ scenarios
 
     """
 
@@ -337,11 +340,11 @@ def Vulnerability(main_dir:str = 'Data',
         cleaning_directory(manager.TMP_SCEN_DIR)
 
         if 10 in steps or steps_vulnerability.CREATE_RASTERS_VULN in steps:
-            compute_vulnerability(manager) #global
+            compute_vulnerability(manager) 
             done.append(steps_vulnerability.CREATE_RASTERS_VULN)
 
         if 11 in steps or steps_vulnerability.CREATE_RASTERS_CODE in steps:
-            compute_code(manager) #global
+            compute_code(manager)
             done.append(steps_vulnerability.CREATE_RASTERS_CODE)
 
         done.append(steps_vulnerability.CREATE_RASTERS)
@@ -383,27 +386,30 @@ def Vulnerability(main_dir:str = 'Data',
         match_vulnerability2sim(manager.SA_MASKED_RIVER,    manager.OUT_MASKED_RIVER,   TMAX)
         match_vulnerability2sim(manager.SA_VULN,            manager.OUT_VULN,           TMAX)
         match_vulnerability2sim(manager.SA_CODE,            manager.OUT_CODE,           TMAX)
-                
-        # Scenarios including change in  vulnerability
-        existence=False
-        existence = manager.create_vrtIfExists()
-
-        if existence == True :
-            logging.info("Scenarios have been applied to the vulnerability matrix see _scenarios")
-            manager.translate_vrt2tif()
-            
         done.append(steps_vulnerability.MATCH_SIMUL)
-        
+           
+    if 4 in steps or steps_vulnerability.APPLY_SCENARIOSVULN in steps:
+        if os.path.exists(manager.OUT_VULN):
+            existence=False
+            existence = manager.create_vrtIfExists(manager.OUT_VULN, manager.IN_CH_SA_SC, manager.OUT_VULN_VRT, name="vuln")
+            if existence == True :
+                logging.info("Scenarios have been applied to the vulnerability matrix see _scenarios")
+                manager.translate_vrt2tif(manager.OUT_VULN_VRT, manager.OUT_VULN_S)
+        else :
+            logging.error(f"The baseline vulnerability does not exist ({manager.OUT_VULN}). Please, compute first the vulnerability without scenarios vuln_.")
+        done.append(steps_vulnerability.APPLY_SCENARIOSVULN)
+    #Delete _scenario folder is no scenario  
+    if os.path.isdir(manager.OUT_WITHVULN) and not os.listdir(manager.OUT_WITHVULN):
+            os.rmdir(manager.OUT_WITHVULN)
     return done
 
-
 def Acceptability(main_dir:str = 'Vesdre',
                   scenario:str = 'Scenario1',
                   Study_area:str = 'Bassin_Vesdre.shp',
                   coeff_auto:bool = True,
                   Ponderation_csv:str = 'Ponderation.csv',
                   resample_size:int = 100,
-                  steps:list[int] | list[steps_acceptability] = [1,2,3,4,5]): 
+                  steps:list[int] | list[steps_acceptability] = [1,2,3,4,5,6]): 
     """ Compute acceptability for the scenario """
 
     done = []
@@ -416,27 +422,27 @@ def Acceptability(main_dir:str = 'Vesdre',
     # Load the vulnerability raster **for the scenario**, and check if an assembly exists and is asked by the user 
     # Initialization of lists to read/ write according to the needed steps   
     VulneToCompute, PathsToSaveA, PathsToSaveA100 = [], [], []
-    if 4 in steps or steps_acceptability.COMPUTE_WITHOUT_SCENARIOS in steps: 
+    if 4 in steps or steps_acceptability.COMPUTE_BASELINE_WITHOUT_SCENARIOS in steps: 
         VulneToCompute.append(manager.OUT_VULN)
         PathsToSaveA.append(manager.OUT_ACCEPT)
-        PathsToSaveA100.append(manager.OUT_ACCEPT_100M)
+        PathsToSaveA100.append(manager.OUT_ACCEPT_RESAMP)
+        river_trace = manager.OUT_MASKED_RIVER
 
-        
     if 5 in steps or steps_acceptability.COMPUTE_WITH_SCENARIOS in steps: 
-        change_vuln_files = [Path(a) for a in glob.glob(str(manager.IN_CH_VULN / "*.tiff"))]
+        river_trace = manager.wich_river_trace()        
+        change_vuln_files = [Path(a) for a in glob.glob(str(manager.IN_CH_SA_SC / "vuln_*.tif")) + glob.glob(str(manager.IN_CH_SA_SC / "vuln_*.tiff"))]
         if len(change_vuln_files) != 0:
             VulneToCompute.append(manager.OUT_VULN_Stif)
             PathsToSaveA.append(manager.OUT_ACCEPT_Stif)
-            PathsToSaveA100.append(manager.OUT_ACCEPT_100M_Stif)
+            PathsToSaveA100.append(manager.OUT_ACCEPT_RESAMP_Stif)
         else : 
             logging.info("No vulnerability rasters in CHANGE_VULNE. The code goes on without them.")
-        
     for i in range(len(VulneToCompute)) :
         vulne = gdal.Open(str(VulneToCompute[i]))
         saveA = PathsToSaveA[i]
         saveA100 = PathsToSaveA100[i]
-        # Load the river mask
-        riv = gdal.Open(str(manager.OUT_MASKED_RIVER))
+        # Load the river mask     
+        riv = gdal.Open(str(river_trace))
 
         # Get the geotransform and projection for the output tiff
         geotrans = riv.GetGeoTransform()
@@ -462,8 +468,9 @@ def Acceptability(main_dir:str = 'Vesdre',
 
         if 1 in steps or steps_acceptability.COMPUTE_LOCAL_ACCEPT in steps:
             # Compute acceptability for each return period
+            message="Some adjustments have been done :"
+            message2=""
             for curT in tqdm(return_periods):
-
                 # Load the **FILLED** modelled water depth for the return period
                 model_h = gdal.Open(str(manager.get_sim_file_for_return_period(curT)))
                 # Convert to numpy array
@@ -479,15 +486,13 @@ def Acceptability(main_dir:str = 'Vesdre',
                 assert model_h[ij_riv[0][0], ij_riv[0][1]] == 0, "The river bed is not set to 0 in the modelled water depth"
                 assert model_h.max() > 0, "The maximum water depth is 0"
                 if model_h.min() < 0:
-                    logging.warning("The minimum water depth is negative - {} cells".format(np.count_nonzero(model_h<0)))
-                    logging.warning("Setting the negative values to 0")
+                    message2+= f"\nFor T{curT}, the minimum water depth is negative - {np.count_nonzero(model_h<0)} cells, these values were set to 0."
                     model_h[model_h < 0] = 0
-
-                logging.info("Return period {}".format(curT))
-
+                #logging.info("Return period {}".format(curT))
                 # Compute the local acceptability for the return period
                 part_accept[curT] = compute_acceptability(manager, model_h, vulne, curT, (geotrans, proj))
-
+            if message2 != "":
+                logging.error(message + message2)
             done.append(steps_acceptability.COMPUTE_LOCAL_ACCEPT)
 
             # At this point, the local acceptability for each return period is computed
@@ -500,8 +505,7 @@ def Acceptability(main_dir:str = 'Vesdre',
             if 1 in steps or steps_acceptability.COMPUTE_LOCAL_ACCEPT in steps:
                 # We have computed/updted the acceptibility values.
                 # We do not need to reload them.
-                logging.warning("The acceptability values have been computed in step 1 - avoid reloading")
-                logging.info("If you want to reload the acceptability values, please remove step 1 from the list of steps")
+                logging.warning("The acceptability values have been computed in step 1 – reloading is unnecessary. To avoid this, exclude step 1.")
             else:
 
                 # Get the list of Q files
@@ -509,7 +513,7 @@ def Acceptability(main_dir:str = 'Vesdre',
 
                 # Iterate over the return periods
                 for curT in return_periods:
-                    logging.info(curT)
+                    #logging.info(curT)
 
                     # We set the filename from the return period, not the "qs" list
                     q_filename = manager.TMP_QFILES / "Q{}.tif".format(curT)
@@ -580,16 +584,20 @@ def Acceptability(main_dir:str = 'Vesdre',
             dataset.SetProjection(proj)
             dataset.FlushCache()
             dataset=None
-
-            # Resample to XXm
-            Agg = gdal.Warp(str(saveA100),
-                            str(saveA),
-                            xRes=resample_size,
-                            yRes=resample_size,
-                            resampleAlg='Average')
-            Agg.FlushCache()
-            Agg = None
-
+        
         done.append(steps_acceptability.COMPUTE_MEAN_ACCEPT)
-
+        
+        if 6 in steps or steps_acceptability.RESAMPLING in steps:
+            if os.path.exists(manager.OUT_ACCEPT):
+                Agg = gdal.Warp(str(saveA100),
+                                str(saveA),
+                                xRes=resample_size,
+                                yRes=resample_size,
+                                resampleAlg='Average')
+                Agg.FlushCache()
+                Agg = None
+            else :
+                logging.error(f"The acceptability without resampling does not exist ({manager.OUT_ACCEPT}). Please, compute it first to agglomerate it afterwards.")
+        if os.path.isdir(manager.OUT_WITHVULN) and not os.listdir(manager.OUT_WITHVULN):
+            os.rmdir(manager.OUT_WITHVULN)
     return done