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

wolfhece/acceptability/func.py

@@ -186,7 +186,6 @@ class Accept_Manager():
 
         self.IN_DIR         = self.main_dir / "INPUT"
         self.IN_CH_VULN     = self.IN_DIR / "CHANGE_VULNE"
-        self.IN_CH_SA_SC    = self.IN_CH_VULN / str(Study_area).rsplit('.', 1)[0] / str(scenario)
         self.IN_DATABASE    = self.IN_DIR / "DATABASE"
         self.IN_STUDY_AREA  = self.IN_DIR / "STUDY_AREA"
         self.IN_CSV         = self.IN_DIR / "CSVs"
@@ -290,11 +289,17 @@ class Accept_Manager():
 
             self.scenario:str       = str(self._scenario)
 
+            
+            self.IN_SA_BASE         = self.IN_WATER_DEPTH / self.SA.stem / "Scenario_baseline"
+            self.IN_SA_BASE_INTERP  = self.IN_SA_BASE / "INTERP_WD"
+            
             self.IN_SCEN_DIR        = self.IN_WATER_DEPTH / self.SA.stem / self.scenario
-            self.IN_SA_Base         = self.IN_WATER_DEPTH / self.SA.stem / "Scenario_baseline"
             self.IN_SA_INTERP       = self.IN_SCEN_DIR / "INTERP_WD"
             self.IN_SA_EXTRACTED    = self.IN_SCEN_DIR / "EXTRACTED_LAST_STEP_WD"
-            self.IN_SA_DEM          = self.IN_SCEN_DIR / "DEM_FILES"
+            self.IN_SA_DEM          = self.IN_SCEN_DIR / "DEM_FILES"            
+            self.IN_CH_SA_SC        = self.IN_CH_VULN /self.SA.stem  / self.scenario
+            self.IN_CH_SA_SC_MNT_VRT = self.IN_CH_SA_SC / "__MNT_assembly.vrt"
+            self.IN_CH_SA_SC_MNT_tif = self.IN_CH_SA_SC / "MNTassembly"
 
             self.IN_RM_BUILD_DIR    = self.IN_SCEN_DIR / "REMOVED_BUILDINGS"
 
@@ -302,21 +307,26 @@ class Accept_Manager():
             self.TMP_RM_BUILD_DIR   = self.TMP_SCEN_DIR / "REMOVED_BUILDINGS"
             self.TMP_QFILES         = self.TMP_SCEN_DIR / "Q_FILES"
 
-            self.TMP_VULN           = self.TMP_SCEN_DIR / "Vulnerability.tiff"
-            self.TMP_CODE           = self.TMP_SCEN_DIR / "Vulnerability_Code.tiff"
+            self.TMP_VULN           = self.TMP_SCEN_DIR / "Vulnerability_baseline.tiff"
+            self.TMP_CODE           = self.TMP_SCEN_DIR / "Vulnerability_Code_baseline.tiff"
 
             self.OUT_SCEN_DIR       = self.OUT_STUDY_AREA / self.scenario
 
-            self.OUT_VULN           = self.OUT_SCEN_DIR / "Vulnerability.tiff"
-            self.OUT_VULN_VRT       = self.OUT_SCEN_DIR / "__vuln_assembly.vrt"
-            self.OUT_VULN_S         = self.OUT_SCEN_DIR / "Vulnerability_scenarios" #no .tif because wolf_vrt add it itself (see create_vrtIfExists below)
-            self.OUT_VULN_Stif      = self.OUT_SCEN_DIR / "Vulnerability_scenarios.tif"
-            self.OUT_CODE           = self.OUT_SCEN_DIR / "Vulnerability_Code.tiff"
-            self.OUT_MASKED_RIVER   = self.OUT_SCEN_DIR / "Masked_River_extent.tiff"
-            self.OUT_ACCEPT         = self.OUT_SCEN_DIR / "Acceptability.tiff"
-            self.OUT_ACCEPT_100M    = self.OUT_SCEN_DIR / "Acceptability_100m.tiff"
-            self.OUT_ACCEPT_Stif         = self.OUT_SCEN_DIR / "Acceptability_scenarios.tiff"
-            self.OUT_ACCEPT_100M_Stif    = self.OUT_SCEN_DIR / "Acceptability_scenarios_100m.tiff"
+            self.OUT_WITHVULN       = self.OUT_SCEN_DIR / "vuln_ scenarios"
+            self.OUT_VULN_VRT       = self.OUT_WITHVULN / "__vuln_assembly.vrt"
+            self.OUT_VULN_S         = self.OUT_WITHVULN / "Vulnerability_scenarios" 
+            self.OUT_VULN_Stif      = self.OUT_WITHVULN / "Vulnerability_scenarios.tif"
+            self.OUT_MASKED_RIVER_S = self.OUT_WITHVULN / "Masked_River_extent_scenarios.tiff"
+            self.OUT_ACCEPT_Stif           = self.OUT_WITHVULN / "Acceptability_scenarios.tiff"
+            self.OUT_ACCEPT_RESAMP_Stif    = self.OUT_WITHVULN / "Acceptability_scenarios_resampled.tiff"
+            
+            self.OUT_BASELINE       = self.OUT_SCEN_DIR / "baseline"
+            self.OUT_VULN           = self.OUT_BASELINE / "Vulnerability_baseline.tiff"
+            self.OUT_CODE           = self.OUT_BASELINE / "Vulnerability_Code_baseline.tiff"
+            self.OUT_MASKED_RIVER   = self.OUT_BASELINE / "Masked_River_extent_baseline.tiff"
+            self.OUT_ACCEPT         = self.OUT_BASELINE / "Acceptability_baseline.tiff"
+            self.OUT_ACCEPT_RESAMP  = self.OUT_BASELINE / "Acceptability_baseline_resampled.tiff"
+            
         else:
             self.scenario = None
 
@@ -330,12 +340,20 @@ class Accept_Manager():
             self.TMP_VULN          = None
             self.TMP_CODE          = None
 
-            self.OUT_SCEN_DIR      = None
-            self.OUT_VULN          = None
-            self.OUT_CODE          = None
-            self.OUT_MASKED_RIVER  = None
-            self.OUT_ACCEPT        = None
-            self.OUT_ACCEPT_100M   = None
+            self.OUT_SCEN_DIR       = None
+            self.OUT_WITHVULN       = None
+            self.OUT_VULN_VRT       = None
+            self.OUT_VULN_S         = None
+            self.OUT_VULN_Stif      = None
+            self.OUT_MASKED_RIVER_S = None
+            self.OUT_ACCEPT_Stif      = None
+            self.OUT_ACCEPT_RESAMP_Stif  = None
+            self.OUT_BASELINE       = None
+            self.OUT_VULN           = None
+            self.OUT_CODE           = None
+            self.OUT_MASKED_RIVER   = None
+            self.OUT_ACCEPT         = None
+            self.OUT_ACCEPT_RESAMP  = None
 
     @property
     def is_valid_inputs(self) -> bool:
@@ -437,17 +455,17 @@ class Accept_Manager():
         if self.IN_SA_INTERP.exists() :
             files = [Path(a) for a in glob.glob(str(self.IN_SA_INTERP / "*.tif"))]
         else :
-            logging.error("No _baseline")
+            logging.error("No such scenario")
         return files
 
     def get_sims_files_for_baseline(self) -> list[Path]:
         files = [] #to avoid NoneType
-        if self.IN_SA_INTERP.exists() :
-            logging.info("Getting the _baseline WATER_DEPTHS files.")
-            track = Path(str(self.IN_SA_INTERP / "*.tif"))
+        if self.IN_SA_BASE_INTERP.exists() :
+            logging.info("Getting the _baseline interpolated free surfaces files.")
+            track = Path(str(self.IN_SA_BASE_INTERP / "*.tif"))
             files = [Path(a) for a in glob.glob(str(track))]
         else :
-            logging.error("No _baseline WATER_DEPTHS files")
+            logging.error("No _baseline interpolated free surfaces files")
 
         return files
 
@@ -591,8 +609,8 @@ class Accept_Manager():
             return None
 
         if len(rt)<2:
-            logging.info("Need for more simulations")
-            return None
+            logging.info("There is only one simulation!")
+            return pd.DataFrame(1, columns=["Ponderation"], index=rt)
 
         else :
             pond = []
@@ -723,6 +741,9 @@ class Accept_Manager():
 
         if self.scenario is not None:
             self.OUT_SCEN_DIR.mkdir(parents=True, exist_ok=True)
+            self.OUT_WITHVULN.mkdir(parents=True, exist_ok=True)
+            self.OUT_BASELINE.mkdir(parents=True, exist_ok=True)
+            
 
         return True
 
@@ -938,11 +959,11 @@ class Accept_Manager():
     the search of a more specific word ('vuln', and not 'bath', 'mann', or 'inf').
     """
 
-    def tree_vuln_tif(folder_path):
+    def tree_name_tif(folder_path, name):
         """Find all .tiff files starting with 'vuln' in the directory and return paths"""
         folder = Path(folder_path)
-        vuln_tiff_files = {file for file in folder.rglob("*.tiff") if file.name.startswith("vuln")}
-        vuln_tif_files = {file for file in folder.rglob("*.tif") if file.name.startswith("vuln")}
+        vuln_tiff_files = {file for file in folder.rglob("*.tiff") if file.name.startswith(name)}
+        vuln_tif_files = {file for file in folder.rglob("*.tif") if file.name.startswith(name)}
 
         vuln_files = vuln_tiff_files.union(vuln_tif_files)
 
@@ -956,24 +977,24 @@ class Accept_Manager():
                     tiff_trees.append(curtree)
         return tiff_trees
 
-    def select_vuln_tif(self, path_baseline: Path, folder_path: Path) -> list[Path]:
+    def select_name_tif(self, path_baseline: Path, folder_path: Path, name) -> list[Path]:
         """
         Collects and appends all .tiff files starting with 'vuln' from folder_path into a list.
         """
         files = []
         #first element must be vulnerability_baseline
         files.append(path_baseline.as_posix())
-        tiff_trees = Accept_Manager.tree_vuln_tif(folder_path)
+        tiff_trees = Accept_Manager.tree_name_tif(folder_path, name)
 
         #only the 'final' path of the tree
         for tree in tiff_trees:
             files.append(tree[-1].as_posix())
         return files
 
-    def check_nodata(self):
+    def check_nodata(self, name):
             """ Check nodata in a path """
 
-            list_tif = Accept_Manager.select_vuln_tif(self, self.OUT_VULN, self.IN_CH_SA_SC)
+            list_tif = Accept_Manager.select_name_tif(self, self.OUT_VULN, self.IN_CH_SA_SC, name)
             for cur_lst in list_tif:
                 if "Vulnerability.tiff" not in cur_lst:
                     curarray:WolfArray = WolfArray(cur_lst)
@@ -983,24 +1004,25 @@ class Accept_Manager():
                         curarray.write_all()
                         logging.warning(_('nodata changed in favor of 99999. value for file {} !'.format(cur_lst)))
 
-    def create_vrtIfExists(self):
+    def create_vrtIfExists(self, fn_baseline, fn_scenario, fn_vrt, name):
         """ Create a vrt file from a path """
         logging.info(_('Checking nodata values...'))
-        self.check_nodata()
-        list_tif = Accept_Manager.select_vuln_tif(self, self.OUT_VULN, self.IN_CH_SA_SC)
+        self.check_nodata(name)
+        list_tif = Accept_Manager.select_name_tif(self, fn_baseline, fn_scenario, name)
         #création du fichier vrt - assembly/agglomération
         if len(list_tif)>1:
             logging.info(_('Creating .vrt from files (first based)...'))
-            create_vrt_from_diverged_files_first_based(list_tif, self.OUT_VULN_VRT)
+            create_vrt_from_diverged_files_first_based(list_tif, fn_vrt)
             return True
         else:
             return False
 
 
-    def translate_vrt2tif(self):
-        """ Translate vrt from OUTPUT > ... > Scenario to tif saved in the same folder """
-        if (self.OUT_VULN_VRT).exists():
-            translate_vrt2tif(self.OUT_VULN_VRT, self.OUT_VULN_S)
+    def translate_vrt2tif(self, fn_VRT, fn_vuln_s):
+        """ Translate vrt from OUTPUT > ... > Scenario to tif saved in the same folder, and delete the vrt file """
+        if (fn_VRT).exists():
+            translate_vrt2tif(fn_VRT, fn_vuln_s)
+            os.remove(fn_VRT)
 
     def copy_tif_files(self, files: list[Path], destination_dir: Path) -> None:
         destination_dir.mkdir(parents=True, exist_ok=True)
@@ -1016,7 +1038,20 @@ class Accept_Manager():
 
             dataset = None
 
-        logging.info("All .tif files have been copied to the destination directory.")
+        logging.info("All the existing .tif files have been copied to the destination directory.")
+    
+    def wich_river_trace(self):
+        """ Searches for existing riverbed traces: if none ending with '_scenarios' are found, it selects the baseline trace."""
+        trace = None
+        if os.path.exists(self.OUT_MASKED_RIVER):
+            trace = self.OUT_MASKED_RIVER
+        if os.path.exists(self.OUT_MASKED_RIVER_S):
+            trace = self.OUT_MASKED_RIVER_S
+        else :
+            logging.error("No Masked_River_extent files. Please provide them.")
+        return trace
+        
+        
 
 
 def clip_layer(layer:str,
@@ -1287,7 +1322,7 @@ def compute_vulnerability(manager:Accept_Manager):
         return array_vuln
 
     for i in tqdm(range(len(rasters_vuln)), 'Computing Vulnerability : '):
-        logging.info("Computing layer {} / {}".format(i, len(rasters_vuln)))
+        #logging.info("Computing layer {} / {}".format(i, len(rasters_vuln)))
 
         locvuln = vuln_csv.get_vulnerability_level(rasters_vuln[i].stem)
 
@@ -1378,7 +1413,7 @@ def compute_code(manager:Accept_Manager):
         return array_code
 
     for i in tqdm(range(len(rasters_code)), 'Computing Code : '):
-        logging.info("Computing layer {} / {}".format(i, len(rasters_code)))
+        #logging.info("Computing layer {} / {}".format(i, len(rasters_code)))
 
         loccode = vuln_csv.get_vulnerability_code(rasters_code[i].stem.removesuffix("_CODE"))
 
@@ -1481,7 +1516,7 @@ def match_vulnerability2sim(inRas:Path, outRas:Path, MODREC:Path):
     :param MODREC: the MODREC/simulation extent file
 
     """
-
+    
     inRas  = str(inRas)
     outRas = str(outRas)
     MODREC = str(MODREC)
@@ -1525,7 +1560,7 @@ def compute_acceptability(manager:Accept_Manager,
 
     """
 
-    logging.info(interval)
+    #logging.info(interval)
 
     points_accept = pd.read_csv(manager.POINTS_CSV)
 

wolfhece/apps/version.py

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

wolfhece/picc.py

@@ -64,10 +64,10 @@ class Picc_data(Element_To_Draw):
         if datafile.exists():
             self.zones = Zones(data_dir / self._filename_vector, bbox = bbox, mapviewer=self.mapviewer, colors= self._colors)
         else:
-            logging.error(_('File not found : {}').format(datafile))
+            logging.info(_('File not found : {}').format(datafile))
 
             if self.mapviewer is not None:
-                dlg = wx.SingleChoiceDialog(None, _('Would you like to select a PICC file or a GDB database ?'), _('Choose data source'), ['Shape file/GPKG', 'GDB database'], wx.CHOICEDLG_STYLE)
+                dlg = wx.SingleChoiceDialog(None, _('Would you like to select a Shape file or a GDB database ?'), _('Choose data source'), ['Shape file/GPKG', 'GDB database'], wx.CHOICEDLG_STYLE)
                 ret = dlg.ShowModal()
 
                 if ret == wx.ID_CANCEL:

wolfhece/scenario/config_manager.py

@@ -202,7 +202,7 @@ class Config_Manager_2D_GPU:
     Gestionnaire de configurations 2D - code GPU
     """
 
-    def __init__(self, workingdir:str = '', mapviewer:WolfMapViewer = None, python_venv:Path = None) -> None:
+    def __init__(self, workingdir:str = '', mapviewer:WolfMapViewer = None, python_venv:Path = None, create_ui_if_wx:bool = False) -> None:
         """
         Recherche de toutes les modélisation dans un répertoire et ses sous-répertoires
         """
@@ -235,6 +235,7 @@ class Config_Manager_2D_GPU:
 
         self._txtctrl = None
         self._ui  = None
+        self._create_ui_if_wx = create_ui_if_wx
 
         self._epsilon = 0.01
         self._filter_independent = True
@@ -287,7 +288,7 @@ class Config_Manager_2D_GPU:
             # la fenêtre est déjà ouverte
             self._ui.refill_data(self.configs)
         else:
-            if self.wx_exists:
+            if self.wx_exists and self._create_ui_if_wx:
                 self._ui = UI_Manager_2D_GPU(self.configs, parent=self)
 
 
@@ -1165,6 +1166,22 @@ class Config_Manager_2D_GPU:
             logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
 
 
+    def verify_bath_roof_deck(self, bathymetry:WolfArray, bridge_roof:WolfArray):
+        """ Verify bathymetry, roof and deck """
+
+        if bridge_roof is None:
+            return
+
+        # si la matrice de toit de pont est plus basse que la bathymétrie, on met à 99999
+        # la bathymétrie et le toit de pont.
+        # Ainsi, ces maille seront infranchissables.
+        # Cale peut être utile pour discrétiser les piles dans les données du toit, plutôt que de les
+        # laisser inclure dans un fichier bath_ séparé.
+        mask = bridge_roof.array.data < bathymetry.array.data
+        bridge_roof.array.data[mask] = 99999.
+        bathymetry.array.data[mask]  = 99999.
+
+
     def create_simulation(self,
                           dir:Path,
                           idx_hydros:list[int] = [-1],
@@ -1280,6 +1297,8 @@ class Config_Manager_2D_GPU:
         # applying Python scrpitps on ARRAYS
         self._apply_scripts_update_topo_maning_inf_roof(dir, bat, man, infiltration, roof)
 
+        self.verify_bath_roof_deck(bat, roof)
+
         # save arrays on disk
         bat.write_all(str(dir / '__bathymetry_after_scripts.tif'))
         man.write_all(str(dir / '__manning_after_scripts.tif'))
@@ -1398,12 +1417,12 @@ class Config_Manager_2D_GPU:
                 f.write(str(curdir.drive) + '\n')
                 f.write('cd {}\n'.format(str(curdir.parent)))
                 f.write("\n")
-                f.write("WOLFGPU_PARAMS=-quickrun " + str(curdir.name) + "\n")
+                f.write("set WOLFGPU_PARAMS=-quickrun " + str(curdir.name) + "\n")
                 f.write("\n")
                 f.write("where wolfgpu.exe\n")
                 f.write("IF %ERRORLEVEL%==0 (\n")
                 f.write("wolfgpu %WOLFGPU_PARAMS%\n")
-                f.write("goto :end\n")
+                f.write("goto :exit\n")
                 f.write(")\n")
                 f.write("\n")
                 f.write("echo -------------------------------\n")
@@ -1417,7 +1436,7 @@ class Config_Manager_2D_GPU:
                 f.write("echo -------------------------------\n")
                 f.write("pause\n")
                 f.write("python -m wolfgpu.cli %WOLFGPU_PARAMS%\n")
-                f.write(":end\n")
+                f.write(":exit\n")
 
             allsims.append(curdir / 'quickrun.bat')
 
@@ -2588,4 +2607,4 @@ class UI_Manager_2D_GPU():
                         newroot = self._treelist.AppendItem(root, k, data = v)
 
                         for curfile in v:
-                            self._treelist.AppendItem(newroot, curfile.name, data = curfile)
+                            self._treelist.AppendItem(newroot, curfile.name, data = curfile)

wolfhece/wolf_array.py

@@ -3335,9 +3335,16 @@ class SelectionData():
         else:
             destxy = self.myselection
 
-        destij = np.asarray([list(curarray.get_ij_from_xy(x, y)) for x, y in destxy])
+        if len(destxy) == 0:
+            logging.error(_('No selection to unmask'))
+            return
+
+        if destxy == 'all':
+            curarray.array.mask[:, :] = False
+        else:
+            destij = np.asarray([list(curarray.get_ij_from_xy(x, y)) for x, y in destxy])
 
-        curarray.array.mask[destij[:, 0], destij[:, 1]] = False
+            curarray.array.mask[destij[:, 0], destij[:, 1]] = False
 
         if resetplot:
             curarray.reset_plot()
@@ -5629,7 +5636,7 @@ class WolfArray(Element_To_Draw, header_wolf):
             - Float32
             - Float64
 
-        :param outdir: directory - If provided, the file will be savd as "outdir/idx+extent.tif" 
+        :param outdir: directory - If provided, the file will be savd as "outdir/idx+extent.tif"
                                    If not provided, we use the filename attribute
 
         :param extent: suffix to add to the filename before the extension '.tif' (only if outdir is provided)
@@ -5749,7 +5756,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         assert locarray.shape[1] == self.nby, _('Incompatible dimensions')
 
         if crop is not None :
-            logging.error(_('Cropping not yet implemented for numpy files'))
+            # logging.error(_('Cropping not yet implemented for numpy files'))
 
             imin, jmin = self.get_ij_from_xy(crop[0][0], crop[1][0])
             imax, jmax = self.get_ij_from_xy(crop[0][1], crop[1][1])
@@ -5795,6 +5802,7 @@ class WolfArray(Element_To_Draw, header_wolf):
         else:
             return
 
+        raster:gdal.Dataset
         if crop is not None :
             if not os.path.exists(fn):
                 logging.error(_('File not found'))
@@ -5812,12 +5820,35 @@ class WolfArray(Element_To_Draw, header_wolf):
                     logging.error(_('Crop must be a list or a numpy array with 4 values - xmin, xmax, ymin, ymax'))
                     return
 
-                raster:gdal.Dataset
-                raster = gdal.Open(fn)
-                geotr = raster.GetGeoTransform()
+                raster_in:gdal.Dataset
+                raster_in = gdal.Open(fn)
+
+                proj = raster_in.GetProjection()
+                # check if proj is epsg:31370
+                if 'Lambert 72' not in proj and "31370" not in proj:
+                    logging.error(_('{} projection is not Lambert 72 - EPSG:31370').format(fn))
+
+                    raster_in2 = gdal.Dataset()
+                    gdal.Warp(raster_in2, raster_in, dstSRS='EPSG:31370')
+
+                    # Close the raster_in
+                    raster_in.FlushCache()
+                    raster_in = None
+
+                    raster_in = raster_in2
+
+                    if raster_in is None:
+                        logging.error(_('Could not reproject the file {fn}'))
+                        return
+
+                geotr = raster_in.GetGeoTransform()
                 self.dx = geotr[1]
                 self.dy = abs(geotr[5])
 
+                ulx = geotr[0]
+                uly = geotr[3]
+                llx = ulx + geotr[1] * raster_in.RasterXSize
+                lly = uly + geotr[5] * raster_in.RasterYSize
 
                 newcrop = CropDialog(None)
 
@@ -5868,20 +5899,29 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                     fn_crop = fileDialog.GetPath()
 
+                if uly > lly:
+                    raster = gdal.Translate(fn_crop, fn, projWin=[xmin, ymax, xmax, ymin])
+                else:
+                    raster = gdal.Translate(fn_crop, fn, projWin=[xmin, ymin, xmax, ymax])
 
-                gdal.Translate(fn_crop, fn, projWin=[xmin, ymax, xmax, ymin])
                 fn  = fn_crop
             else:
                 from tempfile import NamedTemporaryFile
                 tmpfile = NamedTemporaryFile(suffix='.tif')
-                gdal.Translate(str(tmpfile.name), fn, projWin=[xmin, ymax, xmax, ymin])
+
+                if uly > lly:
+                    raster = gdal.Translate(str(tmpfile.name), fn, projWin=[xmin, ymax, xmax, ymin])
+                else:
+                    raster = gdal.Translate(str(tmpfile.name), fn, projWin=[xmin, ymin, xmax, ymax])
+
                 fn = str(tmpfile.name)
+        else:
+            raster = gdal.Open(fn)
 
-        raster:gdal.Dataset
-        raster = gdal.Open(fn)
 
-        # Projection
-        # proj = raster.GetProjection()
+        if raster is None:
+            logging.error(_('Could not open the file {fn}'))
+            return
 
         # Dimensions
         self.nbx = raster.RasterXSize
@@ -7936,41 +7976,51 @@ class WolfArray(Element_To_Draw, header_wolf):
             elif type(self.cropini) is list:
                 pass
             else:
-                newcrop = CropDialog(None)
+                if self.wx_exists:
+                    newcrop = CropDialog(None)
 
-                if self.mapviewer is not None:
-                    bounds = self.mapviewer.get_canvas_bounds()
+                    if self.mapviewer is not None:
+                        bounds = self.mapviewer.get_canvas_bounds()
 
-                    newcrop.dx.Value = str(self.dx)
-                    newcrop.dy.Value = str(self.dy)
+                        newcrop.dx.Value = str(self.dx)
+                        newcrop.dy.Value = str(self.dy)
 
-                    # newcrop.dx.Enable(False)
-                    # newcrop.dy.Enable(False)
+                        # newcrop.dx.Enable(False)
+                        # newcrop.dy.Enable(False)
 
-                    newcrop.ox.Value = str(float((bounds[0] // 50.) * 50.))
-                    newcrop.ex.Value = str(float((bounds[2] // 50.) * 50.))
-                    newcrop.oy.Value = str(float((bounds[1] // 50.) * 50.))
-                    newcrop.ey.Value = str(float((bounds[3] // 50.) * 50.))
+                        newcrop.ox.Value = str(float((bounds[0] // 50.) * 50.))
+                        newcrop.ex.Value = str(float((bounds[2] // 50.) * 50.))
+                        newcrop.oy.Value = str(float((bounds[1] // 50.) * 50.))
+                        newcrop.ey.Value = str(float((bounds[3] // 50.) * 50.))
 
-                badvalues = True
-                while badvalues:
-                    badvalues = False
+                    badvalues = True
+                    while badvalues:
+                        badvalues = False
 
-                    ret = newcrop.ShowModal()
-                    if ret == wx.ID_CANCEL:
-                        newcrop.Destroy()
-                        return
-                    else:
-                        self.cropini = [[float(newcrop.ox.Value), float(newcrop.ex.Value)],
-                                        [float(newcrop.oy.Value), float(newcrop.ey.Value)]]
-                        tmpdx = float(newcrop.dx.Value)
-                        tmpdy = float(newcrop.dy.Value)
+                        ret = newcrop.ShowModal()
+                        if ret == wx.ID_CANCEL:
+                            newcrop.Destroy()
+                            return
+                        else:
+                            self.cropini = [[float(newcrop.ox.Value), float(newcrop.ex.Value)],
+                                            [float(newcrop.oy.Value), float(newcrop.ey.Value)]]
+                            tmpdx = float(newcrop.dx.Value)
+                            tmpdy = float(newcrop.dy.Value)
+
+                        if self.dx != tmpdx or self.dy != tmpdy:
+                            if tmpdx / self.dx != tmpdy / self.dy:
+                                badvalues = True
+
+                    newcrop.Destroy()
+
+                    self.cropini = [[self.cropini[0][0] + self.dx/2., self.cropini[0][1] + self.dx/2.],
+                                    [self.cropini[1][0] + self.dy/2., self.cropini[1][1] + self.dy/2.]]
+                else:
+                    logging.warning(_('No crop defined and no wxPython available'))
+                    logging.info(_('Abort reading data !'))
+                    return
 
-                    if self.dx != tmpdx or self.dy != tmpdy:
-                        if tmpdx / self.dx != tmpdy / self.dy:
-                            badvalues = True
 
-                newcrop.Destroy()
 
             with open(self.filename, 'rb') as f:
                 if self.wolftype == WOLF_ARRAY_FULL_SINGLE or self.wolftype == WOLF_ARRAY_FULL_SINGLE_3D:
@@ -8007,6 +8057,10 @@ class WolfArray(Element_To_Draw, header_wolf):
 
                     self.array = ma.masked_array(locarray, dtype=np.float32)
 
+                else:
+                    logging.warning(_('Unsupported wolftype for cropping'))
+                    return
+
             if self.filename.endswith('.flt'):
                 # fichier .flt --> miroir "horizontal"
                 self.array = np.fliplr(self.array)

wolfhece/wolf_texture.py

@@ -26,7 +26,7 @@ import math
 import numpy as np
 
 from .PyTranslate import _
-from .PyWMS import getIGNFrance, getWalonmap
+from .PyWMS import getIGNFrance, getWalonmap, getVlaanderen
 from .textpillow import Font_Priority, Text_Image,Text_Infos
 from .drawing_obj import Element_To_Draw
 
@@ -250,8 +250,10 @@ class imagetexture(Element_To_Draw):
     France: bool
     epsg: str
 
-    def __init__(self, which: str, label: str, cat: str, subc: str, mapviewer, xmin, xmax, ymin, ymax, width=1000,
-                 height=1000, France=False, epsg='31370') -> None:
+    def __init__(self, which: str, label: str, cat: str, subc: str, mapviewer,
+                 xmin:float, xmax:float, ymin:float, ymax:float,
+                 width:int = 1000, height:int = 1000,
+                 France:bool = False, epsg='31370', Vlaanderen:bool = False) -> None:
 
         super().__init__(label+cat+subc, plotted=False, mapviewer=mapviewer, need_for_wx=False)
 
@@ -261,6 +263,8 @@ class imagetexture(Element_To_Draw):
             logging.error(_('Opengl setcurrent -- Do you have a active canvas ?'))
 
         self.France = France
+        self.Vlaanderen = Vlaanderen
+
         self.epsg = epsg
 
         self.xmin = xmin
@@ -297,6 +301,11 @@ class imagetexture(Element_To_Draw):
                 mybytes = getIGNFrance(self.category, self.epsg,
                                        self.xmin, self.ymin, self.xmax, self.ymax,
                                        self.width, self.height, False)
+
+            elif self.Vlaanderen:
+                mybytes = getVlaanderen(self.category,
+                                       self.xmin, self.ymin, self.xmax, self.ymax,
+                                       self.width, self.height, False)
             else:
                 mybytes = getWalonmap(self.category + '/' + self.subcategory,
                                       self.xmin, self.ymin, self.xmax, self.ymax,

wolfhece/wolf_tiles.py

@@ -91,6 +91,8 @@ class Tiles(Zones):
             # pas de comparaison car répertoire source et comp identique
 
             # récupération du fichier .tif avec le nom associé au vecteur
+            if boundname.endswith('.tif'):
+                boundname = boundname[:-4]
             file = glob.glob(join(self.linked_data_dir,'*{}*.tif').format(boundname))
 
             if len(file)>0:

{wolfhece-2.1.107.dist-info → wolfhece-2.1.108.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: wolfhece
-Version: 2.1.107
+Version: 2.1.108
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: Copyright (c) 2024 University of Liege. All rights reserved.
 Project-URL: Homepage, https://uee.uliege.be/hece