wolfhece 2.2.31__py3-none-any.whl → 2.2.33__py3-none-any.whl

wolfhece/PyVertexvectors.py

@@ -3589,6 +3589,32 @@ class vector:
         """ Alias for surface """
         return self.surface
 
+    def interpolate_coordinates(self):
+        """
+        Interpole les valeurs Z des vertices sur base des seules valeurs connues,
+        càd autre que infinity ou -99999 ou 99999.
+        """
+
+        sz = self.get_sz()
+        s = sz[0]
+        z = sz[1]
+
+        # Remove -99999 and empty values
+        valid_indices = np.where((z != -99999.) & (z != 99999.) & (z != '') & (np.isfinite(z)))[0]
+        if len(valid_indices) == 0:
+            logging.warning(_('No valid z values to interpolate'))
+            return
+
+        f = interp1d(s[valid_indices], z[valid_indices])
+
+        for k in range(self.nbvertices):
+            if k not in valid_indices:
+                z = f(s[k])
+                self.myvertices[k].z = z
+
+        self.update_lengths()
+        self._reset_listogl()
+
 class zone:
     """
     Objet de gestion d'informations vectorielles

wolfhece/Results2DGPU.py

@@ -274,9 +274,18 @@ class wolfres2DGPU(Wolfresults_2D):
                  idx: str = '',
                  plotted: bool = True,
                  mapviewer=None,
-                 store = None):
+                 store = None,
+                 load_from_cache:bool = True) -> None:
 
         fname = Path(fname)
+
+        # Test if fname is an url
+        if str(fname).startswith('http:') or str(fname).startswith('https:'):
+            from .pydownloader import download_gpu_simulation, DATADIR
+            ret = download_gpu_simulation(fname, DATADIR / fname.name, load_from_cache = load_from_cache)
+            assert isinstance(ret, ResultsStore), _("Download failed or did not return a ResultsStore instance")
+            fname = DATADIR / fname.name
+
         self._nap = None
 
         if not fname.name.lower() == 'simul_gpu_results':

wolfhece/analyze_poly.py

@@ -35,6 +35,14 @@ class Array_analysis_onepolygon():
         self._selected_cells = None
         self._values = None
 
+    @ property
+    def centroid(self) -> Point:
+        """ Get the centroid of the polygon as a Point object.
+
+        :return: Shapely Point object representing the centroid of the polygon
+        """
+        return self._polygon.centroid
+
     def values(self, which:Literal['Mean', 'Std', 'Median', 'Sum', 'Volume', 'Values', 'Area']) -> pd.DataFrame | float:
         """ Get the values as a pandas DataFrame
 
@@ -59,6 +67,25 @@ class Array_analysis_onepolygon():
         else:
             return self._values[which]
 
+    def as_vector(self, add_values:bool = True):
+        """ Return a copy of the polygon with the values as attributes. """
+
+        newvec = self._polygon.deepcopy()
+
+        if add_values:
+            if self._values is None:
+                self.compute_values()
+                self._add_area2velues()
+
+            if self._values is None:
+                raise ValueError("No values computed. Please call compute_values() first.")
+
+            for key, value in self._values.items():
+                newvec.add_value(key, value)
+
+        newvec.myname = self._polygon.myname
+        return newvec
+
     def select_cells(self, mode:Literal['polygon', 'buffer'] = 'polygon', **kwargs):
         """Select the cells inside the polygon.
 
@@ -127,8 +154,13 @@ class Array_analysis_onepolygon():
                 raise ValueError("No polygon provided. Please provide a polygon to select cells.")
 
             self._values['Area'] = self._polygon.area
+            centroid = self._polygon.centroid
+            self._values['X'] = centroid.x
+            self._values['Y'] = centroid.y
         else:
             self._values['Area'] = len(self._selected_cells) * self._wa.dx * self._wa.dy
+            self._values['X'] = np.mean(self._selected_cells[:, 0])
+            self._values['Y'] = np.mean(self._selected_cells[:, 1])
 
     @property
     def n_selected_cells(self) -> int:
@@ -278,6 +310,17 @@ class Array_analysis_polygons():
 
         self._active_categories = self.all_categories
 
+    def as_zone(self, add_values:bool = True) -> zone:
+        """ Convert the analysis to a zone of polygons """
+
+        ret_zone = zone(name=self._polygons.myname)
+        for name, poly in self._zone.items():
+            if name.split('___')[0] in self._active_categories:
+                if poly.has_values:
+                    ret_zone.add_vector(poly.as_vector(add_values), forceparent=True)
+
+        return ret_zone
+
     @property
     def _areas(self) -> list[float]:
         """ Get the areas of the polygons in the zone """
@@ -357,6 +400,36 @@ class Array_analysis_polygons():
         lst = [pol.values('Values') for key, pol in self._zone.items() if pol.has_values and key.split('___')[0] in self._active_categories]
         return pd.concat(lst, axis=1)
 
+    def get_geometries(self) -> pd.DataFrame:
+        """ Get the centroids of all polygons in the zone as a pandas DataFrame.
+
+        :return: pandas DataFrame with the centroids of the polygons
+        """
+        centroids = {key: {'Centroid' : poly.centroid, 'X': poly.centroid.x, 'Y' : poly.centroid.y, 'Geometry': poly._polygon.polygon} for key, poly in self._zone.items() if poly.has_values and key.split('___')[0] in self._active_categories}
+        return pd.DataFrame.from_dict(centroids, orient='index')
+
+    def get_geodataframe_with_values(self, epsg:int = 31370) -> 'gpd.GeoDataFrame':
+        """ Create a GeoDataFrame with the centroids and values of the polygons.
+
+        Values are added as a column named 'Values' as Numpy array."""
+
+        import geopandas as gpd
+
+        geom = self.get_geometries()
+        # Add values as numpy arrays to the DataFrame
+        geom['Values'] = None
+        geom['Values'] = geom['Values'].astype(object)
+
+        # Get values for each polygon and add them to the DataFrame
+        for key, poly in self._zone.items():
+            if poly.has_values and key.split('___')[0] in self._active_categories:
+                values = poly.values('Values')
+                geom.at[key, 'Values'] = values.to_numpy().ravel()
+
+        # Create a GeoDataFrame
+        gdf = gpd.GeoDataFrame(geom, geometry='Geometry', crs=f'EPSG:{epsg}')
+        return gdf
+
     @property
     def polygons(self) -> zone:
         """ Get the zone of polygons """
@@ -510,6 +583,40 @@ class Array_analysis_polygons():
 
         return fig
 
+    def clustering(self, n_clusters:int = 5, operator:Literal['Mean', 'Median', 'Sum', 'Volume', 'Area'] = 'Mean'):
+        """ Perform clustering on the polygons based on their values. """
+        from sklearn.cluster import KMeans
+        import geopandas as gpd
+
+        # Get the values of the polygons
+        values = self.values(operator)
+        geometries = self.get_geodataframe_with_values()
+
+        xy = geometries[['X', 'Y']].copy()
+
+        if values.empty:
+            raise ValueError("No values to cluster. Please compute values first.")
+
+        # Perform clustering
+        kmeans = KMeans(n_clusters=n_clusters)
+
+        kmeans.fit(xy[['X', 'Y']].values)
+        labels = kmeans.labels_
+        geometries['Cluster'] = labels
+
+        centroids = kmeans.cluster_centers_
+        cluster_centroids = [Point(xy) for xy in centroids]
+
+        # Find footprints of the clusters
+        footprints = []
+        for label in np.unique(labels):
+            geom_cluster = geometries[geometries['Cluster'] == label]
+            footprint = geom_cluster.geometry.unary_union.convex_hull
+            footprints.append(footprint)
+
+        return geometries, (cluster_centroids, footprints)
+
+
 class Array_analysis_zones():
     """ Class for values analysis of an array based on a Zones instance.
 
@@ -524,6 +631,16 @@ class Array_analysis_zones():
 
         self._polygons = {zone.myname: Array_analysis_polygons(self._wa, zone, buffer_size) for zone in self._zones.myzones if zone.used}
 
+    def as_zones(self, add_values:bool = True) -> Zones:
+        """ Convert the analysis to a Zones instance """
+
+        newzones = Zones(idx=self._zones.idx)
+        for name, pol in self._polygons.items():
+            newzones.add_zone(pol.as_zone(add_values), forceparent=True)
+
+        return newzones
+
+
     def __getitem__(self, key:str) -> Array_analysis_polygons:
         """ Get the zone by name """
         if key in self._polygons:
@@ -623,6 +740,46 @@ class Arrays_analysis_zones():
         self._active_categories = self.all_categories
         self._active_arrays = self.all_arrays
 
+    def __getitem__(self, key:str | tuple) -> Array_analysis_polygons:
+        """ Get the zone by name """
+        if isinstance(key, tuple):
+            if len(key) != 2:
+                raise ValueError("Key must be a tuple of (zone_name, array_name).")
+            zone_name, array_name = key
+            if zone_name not in self._polygons or array_name not in self._polygons[zone_name]:
+                raise KeyError(f"Zone {zone_name} or array {array_name} not found in zones.")
+            return self._polygons[zone_name][array_name]
+
+        elif isinstance(key, str):
+            if len(self._polygons) == 1:
+                # If there is only one zone, return the first array in that zone
+                zone_name = next(iter(self._polygons))
+                if key in self._polygons[zone_name]:
+                    return self._polygons[zone_name][key]
+                else:
+                    raise KeyError(f"Array {key} not found in the only zone available.")
+            else:
+                if key in self._polygons:
+                    return self._polygons[key]
+                else:
+                    raise KeyError(f"Zone {key} not found in zones.")
+
+    def as_zones(self, add_values:bool = True) -> Zones:
+        """ Convert the analysis to a Zones instance """
+
+        newzones = Zones(idx=self._zones.idx)
+        for name, dct in self._polygons.items():
+            for array_name, pols in dct.items():
+                if array_name not in self._active_arrays:
+                    continue
+
+                newzone = pols.as_zone(add_values)
+                newzone.myname = f"{array_name}"
+
+                newzones.add_zone(newzone, forceparent=True)
+
+        return newzones
+
     @property
     def _areas(self) -> dict[str, list[float]]:
         """ Get the areas of the polygons in the zones """
@@ -1173,8 +1330,8 @@ class Building_Waterdepth_analysis(Arrays_analysis_zones):
 
         if merge_zones:
             # copy all vectors in an unique zone
-            newz = Zones(idx='merged_zones')
-            merged_zone = zone(name='merged_zone')
+            newz = Zones(idx='all')
+            merged_zone = zone(name='all')
             newz.add_zone(merged_zone, forceparent= True)
 
             for z in zones.myzones:

wolfhece/apps/version.py

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

wolfhece/pydownloader.py

@@ -36,6 +36,11 @@ class DownloadFiles(Enum):
     VECFILES = ('vec', 'vec.extra')
     VECZFILES = ('vecz', 'vecz.extra')
     PROJECTFILES = ('proj',)
+    NUMPYFILES = ('npy',)
+    NPZFILES = ('npz',)
+    JSONFILES = ('json',)
+    TXTFILES = ('txt',)
+    CSVFILES = ('csv',)
 
 class DonwloadDirectories(Enum):
     """ Enum to define the directories for downloads. """
@@ -43,6 +48,7 @@ class DonwloadDirectories(Enum):
 
 
 GITLAB_EXAMPLE = 'https://gitlab.uliege.be/HECE/wolf_examples/-/raw/main'
+GITLAB_EXAMPLE_GPU = 'https://gitlab.uliege.be/HECE/wolfgpu_examples/-/raw/main'
 DATADIR = Path(__file__).parent / 'data' / 'downloads'
 
 def clean_url(url: str) -> str:
@@ -63,6 +69,10 @@ def clean_url(url: str) -> str:
     cleaned_url = re.sub(r'(?<!:)//+', '/', cleaned_url)
     # Convert Backslashes to forward slashes
     cleaned_url = cleaned_url.replace('\\', '/')
+
+    cleaned_url = cleaned_url.replace(':/', '://')
+    cleaned_url = cleaned_url.replace(':///', '://')
+
     # Ensure the URL starts with http:// or https://
     if not cleaned_url.startswith(('http://', 'https://', 'ftp://')):
         raise ValueError(f"Invalid URL: {url}. Must start with http://, https://, or ftp://")
@@ -171,6 +181,77 @@ def toys_dataset(dir:str, file:str, load_from_cache:bool = True):
     destination = DATADIR / dir / file
     return download_file(url, destination, load_from_cache=load_from_cache)
 
+def download_gpu_simulation(url:str, destination:str | Path, load_from_cache:bool = True):
+    """ Download a GPU simulation file from the WOLFHECE dataset.
+
+    :param url: The URL of the GPU simulation file to download.
+    :param destination: The path where the file will be saved.
+    :param load_from_cache: If True, will not download the file if it already exists.
+    :type url: str
+    :type destination: str | Path
+    :type load_from_cache: bool
+    """
+
+    url = str(url).strip()
+    url = clean_url(url)
+    destination = Path(destination)
+
+    files = ['NAP.npy', 'bathymetry.npy', 'bridge_roof.npy', 'bridge_deck.npy', 'h.npy', 'manning.npy', 'qx.npy', 'qy.npy', 'parameters.json']
+    dir_res = 'simul_gpu_results'
+    res_files = ['metadata.json', 'nap.npz', 'nb_results.txt', 'sim_times.csv']
+
+    try:
+        for file in files:
+            try:
+                download_file(f"{url}/{file}", destination / file, load_from_cache=load_from_cache)
+            except Exception as e:
+                logging.error(f"Error downloading file {file} from {url}: {e}")
+
+        url = url + '/' + dir_res
+        destination = destination / dir_res
+        for file in res_files:
+            try:
+                download_file(f"{url}/{file}", destination / file, load_from_cache=load_from_cache)
+            except Exception as e:
+                logging.error(f"Error downloading result file {file} from {url}: {e}")
+
+        with open(destination / 'nb_results.txt', 'r') as f:
+            nb_results = int(f.read().strip())
+
+        for i in range(1,nb_results+1):
+            # h_0000001.npz
+            # qx_0000001.npz
+            # qy_0000001.npz
+            for file in ['h', 'qx', 'qy']:
+                try:
+                    download_file(f"{url}/{file}_{i:07d}.npz", destination / f'{file}_{i:07d}.npz', load_from_cache=load_from_cache)
+                except Exception as e:
+                    logging.error(f"Error downloading result file {file}_{i:07d}.npz from {url}: {e}")
+
+        from wolfgpu.results_store import ResultsStore
+        rs = ResultsStore(destination)
+
+    except Exception as e:
+        logging.error(f"Error downloading GPU dataset {dir}: {e}")
+        rs = None
+
+    return rs
+
+def toys_gpu_dataset(dir:str, dirweb:str = None, load_from_cache:bool = True):
+    """ Download toy simulatoin files from the WOLFHECE dataset for GPU.
+
+    :param dir: The directory where the file will be saved.
+    :param dirweb: The directory of the files to download.
+    :type dir: str
+    :type dirweb: str
+    :return: The path to the downloaded file.
+    """
+
+    if dirweb is None:
+        dirweb = dir
+
+    return download_gpu_simulation(f"{GITLAB_EXAMPLE_GPU}/{dirweb}", DATADIR / dir, load_from_cache=load_from_cache)
+
 if __name__ == "__main__":
     # Example usage
     print(download_file(r'https:\\gitlab.uliege.be\HECE\wolf_examples\-\raw\main\Extract_part_array\extraction.vec'))
@@ -180,3 +261,4 @@ if __name__ == "__main__":
     print(download_file('https://gitlab.uliege.be/HECE/wolf_examples/-/raw/main/Array_Theux_Pepinster/mnt.tif'))
     print(download_file('https://gitlab.uliege.be/HECE/wolf_examples/-/raw/main/PICC/PICC_Vesdre.shp'))
     print(toys_dataset('Extract_part_array', 'extraction.vec'))
+    rs = toys_gpu_dataset('channel_w_archbridge_fully_man004')

wolfhece/wolf_array.py

@@ -10496,7 +10496,16 @@ class WolfArray(Element_To_Draw, header_wolf):
                         vmin:float=None, vmax:float=None,
                         figsize:tuple=None,
                         Walonmap:bool=False,
-                        cat:str='IMAGERIE/ORTHO_2022_ETE',
+                        cat:Literal['IMAGERIE/ORTHO_1971', 'IMAGERIE/ORTHO_1994_2000', 'IMAGERIE/ORTHO_2006_2007', 'IMAGERIE/ORTHO_2009_2010',
+                                    'IMAGERIE/ORTHO_2012_2013', 'IMAGERIE/ORTHO_2015', 'IMAGERIE/ORTHO_2016',
+                                    'IMAGERIE/ORTHO_2017', 'IMAGERIE/ORTHO_2018', 'IMAGERIE/ORTHO_2019',
+                                    'IMAGERIE/ORTHO_2020', 'IMAGERIE/ORTHO_2021', 'IMAGERIE/ORTHO_2022_PRINTEMPS',
+                                    'IMAGERIE/ORTHO_2022_ETE', 'IMAGERIE/ORTHO_2023_ETE', 'IMAGERIE/ORTHO_LAST',
+                                    'orthoimage_coverage', 'orthoimage_coverage_2016', 'orthoimage_coverage_2017',
+                                    'orthoimage_coverage_2018', 'orthoimage_coverage_2019',
+                                    'orthoimage_coverage_2020', 'orthoimage_coverage_2021',
+                                    'orthoimage_coverage_2022', 'crossborder', 'crossborder_grey',
+                                    'overlay', 'topo', 'topo_grey'] = 'IMAGERIE/ORTHO_LAST',
                         first_mask_data:bool=True,
                         with_legend:bool=False,
                         IGN:bool=False,
@@ -10548,6 +10557,19 @@ class WolfArray(Element_To_Draw, header_wolf):
             - `'IMAGERIE/ORTHO_2022_ETE'`
             - `'IMAGERIE/ORTHO_2023_ETE'`
             - `'IMAGERIE/ORTHO_LAST'`
+            - 'orthoimage_coverage'
+            - 'orthoimage_coverage_2016',
+            - 'orthoimage_coverage_2017',
+            - 'orthoimage_coverage_2018',
+            - 'orthoimage_coverage_2019',
+            - 'orthoimage_coverage_2020',
+            - 'orthoimage_coverage_2021',
+            - 'orthoimage_coverage_2022'
+            - 'crossborder',
+            - 'crossborder_grey',
+            - 'overlay',
+            - 'topo',
+            - 'topo_grey'
         :type cat: str, optional (Default value = `'IMAGERIE/ORTHO_2022_ETE'`)
         :param first_mask_data: If True, applies the mask to the data before plotting. Default is True.
         :type first_mask_data: bool, optional (Default value = True)
@@ -10557,6 +10579,17 @@ class WolfArray(Element_To_Draw, header_wolf):
         :rtype: tuple
         """
 
+        available_Walonmap = ['IMAGERIE/ORTHO_1971', 'IMAGERIE/ORTHO_1994_2000', 'IMAGERIE/ORTHO_2006_2007', 'IMAGERIE/ORTHO_2009_2010',
+                                    'IMAGERIE/ORTHO_2012_2013', 'IMAGERIE/ORTHO_2015', 'IMAGERIE/ORTHO_2016',
+                                    'IMAGERIE/ORTHO_2017', 'IMAGERIE/ORTHO_2018', 'IMAGERIE/ORTHO_2019',
+                                    'IMAGERIE/ORTHO_2020', 'IMAGERIE/ORTHO_2021', 'IMAGERIE/ORTHO_2022_PRINTEMPS',
+                                    'IMAGERIE/ORTHO_2022_ETE', 'IMAGERIE/ORTHO_2023_ETE', 'IMAGERIE/ORTHO_LAST']
+        available_IGN = ['orthoimage_coverage', 'orthoimage_coverage_2016', 'orthoimage_coverage_2017',
+                         'orthoimage_coverage_2018', 'orthoimage_coverage_2019',
+                         'orthoimage_coverage_2020', 'orthoimage_coverage_2021',
+                         'orthoimage_coverage_2022']
+        available_Cartoweb = ['crossborder', 'crossborder_grey', 'overlay', 'topo', 'topo_grey']
+
         if first_mask_data:
             self.mask_data(self.nullvalue)
 
@@ -10572,75 +10605,91 @@ class WolfArray(Element_To_Draw, header_wolf):
             from .PyWMS import getWalonmap
             from PIL import Image
 
-            try:
-                bounds = self.get_bounds()
+            if cat not in available_Walonmap:
+                logging.error(_('The category {} is not available in WalOnMap').format(cat))
+                logging.error(_('Available categories are: {}').format(', '.join(available_Walonmap)))
+            else:
+                try:
+                    bounds = self.get_bounds()
 
-                scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
 
-                if scale_xovery > 1.:
-                    # x is larger than y
-                    w = 2000
-                    h = int(2000 / scale_xovery)
-                else:
-                    # y is larger than x
-                    h = 2000
-                    w = int(2000 * scale_xovery)
+                    if scale_xovery > 1.:
+                        # x is larger than y
+                        w = 2000
+                        h = int(2000 / scale_xovery)
+                    else:
+                        # y is larger than x
+                        h = 2000
+                        w = int(2000 * scale_xovery)
+
+                    IO_image = getWalonmap(cat, bounds[0][0], bounds[1][0],
+                                        bounds[0][1], bounds[1][1],
+                                        w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
 
-                IO_image = getWalonmap(cat, bounds[0][0], bounds[1][0],
-                                       bounds[0][1], bounds[1][1],
-                                       w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
+                    image = Image.open(IO_image)
 
-                image = Image.open(IO_image)
+                    ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
+                except Exception as e:
+                    logging.error(_('Error while fetching the map image from WalOnMap'))
+                    logging.error(e)
 
-                ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
-            except Exception as e:
-                logging.error(_('Error while fetching the map image from WalOnMap'))
-                logging.error(e)
         elif IGN:
             from .PyWMS import getNGI
             from PIL import Image
-            try:
-                bounds = self.get_bounds()
-                scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
-                if scale_xovery > 1.:
-                    # x is larger than y
-                    w = 2000
-                    h = int(2000 / scale_xovery)
-                else:
-                    # y is larger than x
-                    h = 2000
-                    w = int(2000 * scale_xovery)
-                IO_image = getNGI(cat, bounds[0][0], bounds[1][0],
-                                  bounds[0][1], bounds[1][1],
-                                    w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
-                image = Image.open(IO_image)
-                ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
-            except Exception as e:
-                logging.error(_('Error while fetching the map image from IGN'))
-                logging.error(e)
+
+            if cat not in available_IGN:
+                logging.error(_('The category {} is not available in IGN').format(cat))
+                logging.error(_('Available categories are: {}').format(', '.join(available_IGN)))
+
+            else:
+                try:
+                    bounds = self.get_bounds()
+                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    if scale_xovery > 1.:
+                        # x is larger than y
+                        w = 2000
+                        h = int(2000 / scale_xovery)
+                    else:
+                        # y is larger than x
+                        h = 2000
+                        w = int(2000 * scale_xovery)
+                    IO_image = getNGI(cat, bounds[0][0], bounds[1][0],
+                                    bounds[0][1], bounds[1][1],
+                                        w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
+                    image = Image.open(IO_image)
+                    ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
+                except Exception as e:
+                    logging.error(_('Error while fetching the map image from IGN'))
+                    logging.error(e)
 
         elif Cartoweb:
             from .PyWMS import getCartoweb
             from PIL import Image
-            try:
-                bounds = self.get_bounds()
-                scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
-                if scale_xovery > 1.:
-                    # x is larger than y
-                    w = 2000
-                    h = int(2000 / scale_xovery)
-                else:
-                    # y is larger than x
-                    h = 2000
-                    w = int(2000 * scale_xovery)
-                IO_image = getCartoweb(cat, bounds[0][0], bounds[1][0],
-                                        bounds[0][1], bounds[1][1],
-                                        w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
-                image = Image.open(IO_image)
-                ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
-            except Exception as e:
-                logging.error(_('Error while fetching the map image from Cartoweb'))
-                logging.error(e)
+
+            if cat not in available_Cartoweb:
+                logging.error(_('The category {} is not available in Cartoweb').format(cat))
+                logging.error(_('Available categories are: {}').format(', '.join(available_Cartoweb)))
+            else:
+                try:
+                    bounds = self.get_bounds()
+                    scale_xovery = (bounds[0][1] - bounds[0][0]) / (bounds[1][1] - bounds[1][0])
+                    if scale_xovery > 1.:
+                        # x is larger than y
+                        w = 2000
+                        h = int(2000 / scale_xovery)
+                    else:
+                        # y is larger than x
+                        h = 2000
+                        w = int(2000 * scale_xovery)
+                    IO_image = getCartoweb(cat, bounds[0][0], bounds[1][0],
+                                            bounds[0][1], bounds[1][1],
+                                            w=w, h=h, tofile=False) # w=self.nbx, h=self.nby
+                    image = Image.open(IO_image)
+                    ax.imshow(image.transpose(Image.Transpose.FLIP_TOP_BOTTOM), extent=(bounds[0][0], bounds[0][1], bounds[1][0], bounds[1][1]), alpha=1, origin='lower')
+                except Exception as e:
+                    logging.error(_('Error while fetching the map image from Cartoweb'))
+                    logging.error(e)
 
         if vmin is None and vmax is not None:
             vmin = self.mypal.values[0]

{wolfhece-2.2.31.dist-info → wolfhece-2.2.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wolfhece
-Version: 2.2.31
+Version: 2.2.33
 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.31.dist-info → wolfhece-2.2.33.dist-info}/RECORD

@@ -17,16 +17,16 @@ wolfhece/PyParams.py,sha256=BgTAwxxq831rYEq_KLcFBX_upjiSUpVtfoQnCxCNWUI,100443
 wolfhece/PyPictures.py,sha256=m1kY0saW6Y9Q0bDCo47lW6XxDkBrbQG-Fd8uVn8G5ic,2514
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
 wolfhece/PyVertex.py,sha256=a56oY1NB45QnwARg96Tbnq-z-mhZKFkYOkFOO1lNtlk,51056
-wolfhece/PyVertexvectors.py,sha256=MXoqgHVRMvpUOngqpErwT68JwUJo9FhEl1H4HB10-Zk,352574
+wolfhece/PyVertexvectors.py,sha256=ljKJJuo1M9_RVryZiWKJZ8kB_4CuRZ1pOMeT8UeA6rM,353394
 wolfhece/PyWMS.py,sha256=XcSlav5icct2UwV7K2r7vpxa5rKZWiHkp732lI94HFI,31534
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
 wolfhece/RatingCurve_xml.py,sha256=cUjReVMHFKtakA2wVey5zz6lCgHlSr72y7ZfswZDvTM,33891
 wolfhece/ReadDataDCENN.py,sha256=vm-I4YMryvRldjXTvRYEUCxZsjb_tM7U9yj6OaPyD0k,1538
-wolfhece/Results2DGPU.py,sha256=GTu7PMuwfH-xH8J7sVr6zq2CTkGKF24fG1ujEW62PtM,31598
+wolfhece/Results2DGPU.py,sha256=ljMEKHGMbmIAZE6UmMmYDMFqFAwjzxxVUmZdHHb6aME,32106
 wolfhece/__init__.py,sha256=EnpZ2yDEXueP7GAKV0uA2vAwMiZFyBjDAFcL5Y7LzbM,1850
 wolfhece/_add_path.py,sha256=mAyu85CQHk0KgUI6ZizweeQiw1Gdyea9OEjGLC6lLA4,916
-wolfhece/analyze_poly.py,sha256=gJlQZ0vwDG_N98eMDtUsLng9kKu-HlJ8a4xER9ubfDc,54527
+wolfhece/analyze_poly.py,sha256=2uNdnRy828jR-aFNg9fx-8aHqXuRAg-hNQpvQ3g2qL8,60837
 wolfhece/analyze_vect.py,sha256=3lkMwaQ4KRddBVRvlP9PcM66wZwwC0eCmypP91AW-os,6015
 wolfhece/cli.py,sha256=h1tSMHALiftktreyugKcjbASXfpJUm9UYMeVxR-MtG4,6424
 wolfhece/color_constants.py,sha256=Snc5RX11Ydi756EkBp_83C7DiAQ_Z1aHD9jFIBsosAU,37121
@@ -51,7 +51,7 @@ wolfhece/pidcontroller.py,sha256=PHYenOdzfyPK2pXAhyRolCxMSMRd2AFza0eVMafpPHk,520
 wolfhece/pyGui1D.py,sha256=9g7OS3YiKsqy--6y0cBD7x2gaqTTYFXWkxImpgnTA20,121937
 wolfhece/pybridges.py,sha256=bFAqjL4ColeJtwvyCPGQ8VllWoq1RbVWXxFrdfrvqm8,65954
 wolfhece/pydike.py,sha256=dRb6qGkqoTXjf107KcajcIk1F_FuMPaOZLSwixT3dgA,11196
-wolfhece/pydownloader.py,sha256=7vcxzllphhQcH0nEI2NwX-HC0bKhOVpDkODq54oFMbU,7136
+wolfhece/pydownloader.py,sha256=sf8E_R_VgKG7TQJpW0Di3Obyp4d8WhIdfNBGRjsa738,10351
 wolfhece/pylogging.py,sha256=4TI8hgBB65z-zpvU5Rfa2jkPXPhJaqXjHVPwbcdzTNc,4528
 wolfhece/pypolygons_scen.py,sha256=NWaNeK0RSUeOkgukeogK9FLmQiDjGZ9yhqs9208fojM,46237
 wolfhece/pyshields.py,sha256=KMtUO5kD0lisKnJD1NsDz-qaY5DpFcmS4O3WkXtUSmo,27898
@@ -61,7 +61,7 @@ wolfhece/rain_SPWMI.py,sha256=qCfcmF7LajloOaCwnTrrSMzyME03YyilmRUOqrPrv3U,13846
 wolfhece/textpillow.py,sha256=map7HsGYML_o5NHRdFg2s_TVQed_lDnpYNDv27MM0Vw,14130
 wolfhece/tools2d_dll.py,sha256=TfvvmyZUqEZIH0uHwUCJf0bdmCks_AiidDt23Unsp5w,13550
 wolfhece/tools_mpl.py,sha256=gQ3Jg1iuZiecmMqa5Eli2ZLSkttu68VXL8YmMDBaEYU,564
-wolfhece/wolf_array.py,sha256=jin9_ntHASNcqMx0CPYFHMEIw-LaF6UnousSaQx3AxU,523441
+wolfhece/wolf_array.py,sha256=_di7NkNjiaKAO5FLqUgxr8XFoAdnOC5B-oLMpf_g270,526959
 wolfhece/wolf_hist.py,sha256=fTEb60Q4TEwobdZsRU4CFXAId1eOKdWAqF8lnF1xEWc,3590
 wolfhece/wolf_texture.py,sha256=f4psYah1vqyeQjXz2O46d6qeKuv_Lzowk39O9Fmh_2g,20969
 wolfhece/wolf_tiles.py,sha256=v-HohqaWuMYdn75XLnA22dlloAG90iwnIqrgnB0ASQ4,10488
@@ -89,7 +89,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=EdGDN9NhudIiP7c3gVqj7dp4MWFB8ySizM_tpMnsgpE,3091
-wolfhece/apps/version.py,sha256=5D9bE5dzDLfYPyBmgVoMOincHBhGAqYJzByZrRcBiy8,388
+wolfhece/apps/version.py,sha256=1i-0asUH6zmMJgbSbFf4H99faPoXlxUxEtZ2Ap3WZ74,388
 wolfhece/apps/wolf.py,sha256=mRnjYsUu4KIsRuamdQWAINFMuwN4eJgMo9erG-hkZ70,729
 wolfhece/apps/wolf2D.py,sha256=4z_OPQ3IgaLtjexjMKX9ppvqEYyjFLt1hcfFABy3-jU,703
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -308,8 +308,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=u4C7CXe_bUyGKx7c_Bi0x9
 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.31.dist-info/METADATA,sha256=FCE-JySySzwE8OSrK7O7_8IIPOg9RBfBVDS8sPiXfek,2729
-wolfhece-2.2.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wolfhece-2.2.31.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
-wolfhece-2.2.31.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.31.dist-info/RECORD,,
+wolfhece-2.2.33.dist-info/METADATA,sha256=e7XIIwS1G_1LrlL2gk4Ao3ljTeGKT8afnrJE6ugVjow,2729
+wolfhece-2.2.33.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wolfhece-2.2.33.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
+wolfhece-2.2.33.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.33.dist-info/RECORD,,