wolfhece 2.2.26__py3-none-any.whl → 2.2.28__py3-none-any.whl

wolfhece/report/simplesimgpu.py

@@ -19,106 +19,12 @@ from wolfgpu.simple_simulation import InfiltrationChronology, SimulationDuration
 from wolfgpu.simple_simulation import boundary_condition_2D, BoundaryConditionsTypes
 
 from .pdf import PDFViewer
+from .common import cm2pts, A4_rect, rect_cm, cm2inches, list_to_html, list_to_html_aligned, get_rect_from_text
 from ..wolf_array import WolfArray, header_wolf
 from ..PyTranslate import _
 from .. import __version__ as wolfhece_version
 from wolfgpu.version import __version__ as wolfgpu_version
 
-def cm2pts(cm):
-    """ Convert centimeters to points for PyMuPDF.
-
-    One point equals 1/72 inches.
-    """
-    return cm * 28.346456692913385  # 1 cm = 28.346456692913385 points = 72/2.54
-
-def A4_rect():
-    """ Return the A4 rectangle in PyMuPDF units.
-
-    (0, 0) is the top-left corner in PyMuPDF coordinates.
-    """
-    return pdf.Rect(0, 0, cm2pts(21), cm2pts(29.7))  # A4 size in points (PDF units)
-
-def rect_cm(x, y, width, height):
-    """ Create a rectangle in PyMuPDF units from centimeters.
-
-    (0, 0) is the top-left corner in PyMuPDF coordinates.
-    """
-    return pdf.Rect(cm2pts(x), cm2pts(y), cm2pts(x) + cm2pts(width), cm2pts(y) + cm2pts(height))
-
-def get_rect_from_text(text, width, fontsize=10, padding=5):
-    """ Get a rectangle that fits the text in PyMuPDF units.
-
-    :param text: The text to fit in the rectangle.
-    :param width: The width of the rectangle in centimeters.
-    :param fontsize: The font size in points.
-    :param padding: Padding around the text in points.
-    :return: A PyMuPDF rectangle that fits the text.
-    """
-    # Create a temporary PDF document to measure the text size
-    with NamedTemporaryFile(delete=True, suffix='.pdf') as temp_pdf:
-        doc = pdf.Document()
-        page = doc.new_page(A4_rect())
-        text_rect = page.insert_text((0, 0), text, fontsize=fontsize, width=cm2pts(width))
-        doc.save(temp_pdf.name)
-
-        # Get the size of the text rectangle
-        text_width = text_rect.width + padding * 2
-        text_height = text_rect.height + padding * 2
-        # Create a rectangle with the specified width and height
-        rect = pdf.Rect(0, 0, cm2pts(width), text_height)
-        # Adjust the rectangle to fit the text
-        rect.x0 -= padding
-        rect.y0 -= padding
-        rect.x1 += padding
-        rect.y1 += padding
-        return rect
-
-
-def list_to_html(list_items, font_size="10pt", font_family="Helvetica"):
-    # Génère le CSS
-    css = f"""
-    ul.custom-list {{
-        font-size: {font_size};
-        font-family: {font_family};
-        color: #2C3E50;
-        padding-left: 20px;
-    }}
-    li {{
-        margin-bottom: 5px;
-    }}
-    """
-
-    # Génère le HTML
-    html = "<ul class='custom-list'>\n"
-    for item in list_items:
-        html += f"  <li>{item}</li>\n"
-    html += "</ul>"
-
-    return html, css
-
-
-def list_to_html_aligned(list_items, font_size="10pt", font_family="Helvetica"):
-    # Génère le CSS
-    css = f"""
-    ul.custom-list {{
-        font-size: {font_size};
-        font-family: {font_family};
-        color: #2C3E50;
-        padding-left: 20px;
-    }}
-    li {{
-        margin-bottom: 5px;
-    }}
-    """
-
-    # Génère le HTML
-    html = "<div class='custom-list'>\n"
-    html = " - ".join(list_items)  # Join the items with a hyphen
-    html += "</div>"
-
-    return html, css
-
-
 class SimpleSimGPU_Report():
 
     def __init__(self, sim:SimpleSimulation | Path | str, **kwargs):

wolfhece/report/tools.py

@@ -376,34 +376,57 @@ class Analysis_Scenarios():
 
     def __init__(self, base_directory: Path | str, storage_directory: Path | str = None, name:str = ''):
 
+        # Default figure size for plots
+        self._fig_size = (20, 10)
+
+        # Name of the analysis scenarios instance
         self.name = name.strip() if name else 'Analysis_Scenarios'
+
+        # Base directory for the analysis scenarios
+        # Must contains the directories 'projets', 'rapports', 'vecteurs', 'nuages_de_points', 'images' and 'cache'
         self.base_directory = Path(base_directory)
+
+        # Storage directory for the analysis scenarios - Default is the base directory
         self.storage_directory = storage_directory if storage_directory is not None else self.base_directory
 
+        # Check if the base directory exists and contains the necessary directories
         self.check_directories()
+        # Fill the directories attribute with the paths of the analysis directories
         self.directories = get_directories_as_dict(self.base_directory)
 
+        # Initialize the scenarios directories
         self.scenarios_directories:dict[str:Path]
         self.scenarios_directories = {}
+        # List of scenario names
         self.scenarios = []
 
         self.current_scenario = None
-        self.report = None
+        self._return_periods = []
+
+        # RapidReport associated with the analysis scenarios
+        self.report:RapidReport = None
         self._report_name = 'analysis_report.docx'
         self._report_saved_once = False
-        self.mapviewer = None
-        self._background_images = None
 
-        self._polygons = {}
+        # Map viewer for the analysis scenarios
+        self.mapviewer:WolfMapViewer = None
 
-        self._return_periods = []
+        # Name of the WMS service
+        self._background_images:str = None
 
+        # Polygons associated with the analysis scenarios
+        self._polygons:dict[str, Polygons_Analyze] = {}
+
+        self._reference_polygon:Polygons_Analyze = None
+
+        # Modifications associated with the analysis scenarios
         self._modifications = {}
 
+        # MultiProjects associated with the analysis scenarios.
+        # One project contains multiple suimulations.
         self._multiprojects = None
-        self._cached_date = False
 
-        self._reference_polygon:Polygons_Analyze = None
+        # Landmarks and measures associated with the analysis
         self._landmarks:Zones = None
         self._landmarks_s_label = []
 
@@ -414,10 +437,32 @@ class Analysis_Scenarios():
         self._cloud:list[tuple[float, float, str]] = []  # List of tuples (s, z, label) for point clouds
 
         self._images = {}
-        self._zoom = {}
+
+        # Zoom (smin, smax, zmin, zmax) for the analysis
+        self._zoom:dict[str, tuple[float,float,float,float]] = {}
 
         logging.info(f"Analysis directories initialized: {self.directories}")
 
+    @property
+    def fig_size(self) -> tuple[float]:
+        """ Return the default figure size for plots.
+
+        :return: A tuple (width, height) representing the default figure size.
+        """
+        return self._fig_size
+
+    @fig_size.setter
+    def fig_size(self, size:tuple[float]) -> None:
+        """ Set the default figure size for plots.
+
+        :param size: A tuple (width, height) representing the default figure size.
+        """
+        if not isinstance(size, tuple) or len(size) != 2:
+            logging.error("Default figure size must be a tuple of (width, height).")
+            raise ValueError("Default figure size must be a tuple of (width, height).")
+        self._fig_size = size
+        logging.info(f"Default figure size set to {self._fig_size}.")
+
     def add_zoom(self, label:str, bounds:tuple[float]) -> None:
         """ Add a zoom level to the analysis.
 
@@ -669,7 +714,13 @@ class Analysis_Scenarios():
         logging.info(f"Landmark '{label}' added at coordinates ({x}, {y}).")
 
     def update_landmark(self, label: str, s_xy:float |tuple[float] = None, z: float = None) -> None:
-        """ Update a landmark in the analysis. """
+        """ Update a landmark in the analysis.
+
+        :param label: The label of the landmark to update.
+        :param s_xy: The s-coordinate or a tuple (s, xy) to update the landmark's position.
+        :param z: The z-coordinate to update the landmark's elevation (optional).
+        """
+
         if self._landmarks is None:
             logging.error("No landmarks have been added to the analysis.")
             raise ValueError("No landmarks have been added to the analysis.")
@@ -701,7 +752,12 @@ class Analysis_Scenarios():
                     self._landmarks_s_label[i] = (s_xy, z, label)
 
     def plot_cloud(self, ax: plt.Axes, bounds:tuple[float]) -> plt.Axes:
+        """ Trace the cloud of points on an axis Matplotlib
 
+        :param ax: axe Matplotlib
+        :param bounds: tuple (xmin, xmax, ymin, ymax) for the plot limits
+        :return: The Matplotlib Axes object with the cloud plotted.
+        """
         xmin, xmax, ymin, ymax = bounds
 
         used_cloud = [(s, z, label) for s, z, label in self._cloud if s >= xmin and s <= xmax]
@@ -713,7 +769,16 @@ class Analysis_Scenarios():
         return ax
 
     def plot_measures(self, ax:plt.Axes, bounds:tuple[float], style:dict = None) -> plt.Axes:
+        """ Trace les mesures sur un axe Matplotlib
+
+        :param ax: axe Matplotlib
+        :param bounds: tuple (xmin, xmax, ymin, ymax) for the plot limits
+        :param style: Optional style dictionary for the measures. Available properties:
+                      - 'color': The color of the line.
+                      - 'linestyle': The style of the line (e.g., '-', '--', '-.', ':').
 
+        :return: The Matplotlib Axes object with the measures plotted.
+        """
         xmin, xmax, ymin, ymax = bounds
         i=0
         for key, measure in self._projected_measures.items():
@@ -777,13 +842,17 @@ class Analysis_Scenarios():
                         bounds:tuple[float] | str,
                         operator:operators = operators.MEDIAN,
                         plot_annex:bool = True,
-                        save:bool = False) -> tuple[plt.Figure, plt.Axes]:
+                        save:bool = False,
+                        figsize:tuple[float] = None) -> tuple[plt.Figure, plt.Axes]:
         """ Plot the waterlines for a specific scenario.
 
         :param scenario: The name of the scenario to plot waterlines for or a list of scenarios for comparison.
         :param bounds: A tuple (xmin, xmax, ymin, ymax) representing the zoom bounds or a string label for a zoom level.
         :param operator: The operator to apply on the waterlines.
         :param save: If True, save the plot as an image file.
+        :param figsize: A tuple (width, height) representing the size of the figure. If None, uses the default figure size.
+        :param plot_annex: If True, plot the cloud of points, measures, and landmarks.
+        :return: A tuple (fig, ax) where fig is the matplotlib Figure and ax is the matplotlib Axes object.
         """
 
         if isinstance(bounds, str):
@@ -815,34 +884,49 @@ class Analysis_Scenarios():
                 raise ValueError("At least two scenarios are required to compare waterlines.")
 
             ref, sim = scenario[0]
+
+            if isinstance(ref, tuple):
+                full_name = ref[1]
             ref = _sanitize_scenario_name(ref)
 
             # plot topography / bed elevation for the reference scenario
             s, z = self.get_polygon(ref).get_s_values(stored_values_unk.TOPOGRAPHY, which_group=ref, operator=operator, which_sim=sim)
             fig, ax = plt.subplots(1, 1)
-            ax.plot(s, z, label=f"{ref} - {_('Bathymetry')}", color='black', linestyle='-', linewidth=2)
+            ax.plot(s, z, label=f"{full_name} - {_('Bathymetry')}", color='black', linestyle='-', linewidth=2)
 
             # plot water surface elevation for the reference scenario
             s, z = self.get_polygon(ref).get_s_values(stored_values_unk.WATERLEVEL, which_group=ref, operator=operator, which_sim=sim)
-            ax.plot(s, z, label=f"{ref} - {sim}", color='blue', linestyle='-', linewidth=2)
+            ax.plot(s, z, label=f"{full_name} - {sim}", color='blue', linestyle='-', linewidth=2)
 
             # plot topography / bed elevation for the simulation scenarios
             for cur_scenario in scenario[1:]:
                 scen_name, sim_name = cur_scenario
+
+                if isinstance(scen_name, tuple):
+                    full_name = scen_name[1]
                 scen_name = _sanitize_scenario_name(scen_name)
                 s, z = self.get_polygon(scen_name).get_s_values(stored_values_unk.TOPOGRAPHY, which_group=scen_name, operator=operator, which_sim=sim_name)
-                ax.plot(s, z, label=f"{scen_name} - {_('Bathymetry')}", linestyle='--', linewidth=1.5)
+                ax.plot(s, z, label=f"{full_name} - {_('Bathymetry')}", linestyle='--', linewidth=1.5)
 
             # plot water surface elevation for the simulation scenarios
             for cur_scenario in scenario[1:]:
                 scen_name, sim_name = cur_scenario
+                if isinstance(scen_name, tuple):
+                    full_name = scen_name[1]
                 scen_name = _sanitize_scenario_name(scen_name)
                 s, z = self.get_polygon(scen_name).get_s_values(stored_values_unk.WATERLEVEL, which_group=scen_name, operator=operator, which_sim=sim_name)
-                ax.plot(s, z, label=f"{scen_name} - {sim_name}", linestyle='--', linewidth=1.5)
+                ax.plot(s, z, label=f"{full_name} - {sim_name}", linestyle='--', linewidth=1.5)
 
             filename = self.directories[Directory_Analysis.IMAGES] / f"{self.name}_{ref}_{str(xmin)}_{str(xmax)}_waterlines_comparison.png"
 
-        fig.set_size_inches(20,10)#15
+        if figsize is not None:
+            if not isinstance(figsize, tuple) or len(figsize) != 2:
+                logging.error("Figure size must be a tuple of (width, height).")
+                raise ValueError("Figure size must be a tuple of (width, height).")
+            fig.set_size_inches(figsize)
+        else:
+            fig.set_size_inches(self.fig_size[0], self.fig_size[1])  # Use the default figure size
+
         ax.legend()
         #zoomA
         ax.set_xlim(xmin, xmax)
@@ -871,7 +955,8 @@ class Analysis_Scenarios():
                         bounds:tuple[float] | str,
                         operator:operators = operators.MEDIAN,
                         plot_annex:bool = True,
-                        save:bool = False) -> tuple[plt.Figure, plt.Axes]:
+                        save:bool = False,
+                        figsize:tuple[float] = None) -> tuple[plt.Figure, plt.Axes]:
         """ Plot the heads for a specific scenario.
 
         :param scenario: The name of the scenario to plot heads for or a list of scenarios for comparison.
@@ -879,6 +964,8 @@ class Analysis_Scenarios():
         :param operator: The operator to apply on the heads.
         :param plot_annex: If True, plot the cloud of points, measures, and landmarks.
         :param save: If True, save the plot as an image file.
+        :param figsize: A tuple (width, height) representing the figure size. If None, use the default figure size.
+        :return: A tuple (fig, ax) representing the figure and axes of the plot
         """
         if isinstance(bounds, str):
             # If bounds is a string, assume it's a label for a zoom level
@@ -914,7 +1001,14 @@ class Analysis_Scenarios():
                 ax.plot(s, z, label=f"{scen_name} - {sim_name}", linestyle='--', linewidth=1.5)
             filename = self.directories[Directory_Analysis.IMAGES] / f"{self.name}_{ref}_{str(xmin)}_{str(xmax)}_heads_comparison.png"
 
-        fig.set_size_inches(20, 10)
+        if figsize is not None:
+            if not isinstance(figsize, tuple) or len(figsize) != 2:
+                logging.error("Figure size must be a tuple of (width, height).")
+                raise ValueError("Figure size must be a tuple of (width, height).")
+            fig.set_size_inches(figsize)
+        else:
+            fig.set_size_inches(self.fig_size[0], self.fig_size[1])  # Use the default figure size
+
         ax.legend()
         #zoomA
         ax.set_xlim(xmin, xmax)
@@ -940,13 +1034,17 @@ class Analysis_Scenarios():
                         bounds:tuple[float] | str,
                         operator:operators = operators.MEDIAN,
                         plot_annex:bool = True,
-                        save:bool = False) -> tuple[plt.Figure, plt.Axes]:
+                        save:bool = False,
+                        figsize:tuple[float] = None) -> tuple[plt.Figure, plt.Axes]:
         """ Plot the Froude for a specific scenario.
 
         :param scenario: The name of the scenario to plot waterlines for or a list of scenarios for comparison.
         :param bounds: A tuple (xmin, xmax, ymin, ymax) representing the zoom bounds or a string label for a zoom level.
         :param operator: The operator to apply on the waterlines.
         :param save: If True, save the plot as an image file.
+        :param figsize: A tuple (width, height) representing the figure size. If None, use the default figure size.
+        :param plot_annex: If True, plot the cloud of points, measures, and landmarks.
+        :return: A tuple (fig, ax) representing the figure and axes of the plot
         """
 
         if isinstance(bounds, str):
@@ -963,6 +1061,8 @@ class Analysis_Scenarios():
 
         if isinstance(scenario, (str, tuple)):
 
+            if isinstance(scenario, tuple):
+                full_name = scenario[1]
             scenario = _sanitize_scenario_name(scenario)
 
             fig,ax = plt.subplots(1,1)
@@ -971,7 +1071,7 @@ class Analysis_Scenarios():
             for sim in self.list_sims_in_polygons(scenario):
                 # plot Froude number for the reference scenario
                 s, z = self.get_polygon(scenario).get_s_values(stored_values_unk.FROUDE, which_group=scenario, operator=operator, which_sim=sim)
-                ax.plot(s, z, label=f"{scenario} - {sim}", linestyle='-', linewidth=1.5)
+                ax.plot(s, z, label=f"{sim}", linestyle='-', linewidth=1.5)
 
             filename = self.directories[Directory_Analysis.IMAGES] / f"{self.name}_{scenario}_{str(xmin)}_{str(xmax)}_Froude.png"
 
@@ -985,22 +1085,34 @@ class Analysis_Scenarios():
             fig,ax = plt.subplots(1,1)
 
             ref, sim = scenario[0]
+
+            if isinstance(ref, tuple):
+                full_name = ref[1]
             ref = _sanitize_scenario_name(ref)
 
             # plot water surface elevation for the reference scenario
             s, z = self.get_polygon(ref).get_s_values(stored_values_unk.FROUDE, which_group=ref, operator=operator, which_sim=sim)
-            ax.plot(s, z, label=f"{ref} - {sim}", color='blue', linestyle='-', linewidth=2)
+            ax.plot(s, z, label=f"{full_name} - {sim}", color='blue', linestyle='-', linewidth=2)
 
             # plot water surface elevation for the simulation scenarios
             for cur_scenario in scenario[1:]:
                 scen_name, sim_name = cur_scenario
+                if isinstance(scen_name, tuple):
+                    full_name = scen_name[1]
                 scen_name = _sanitize_scenario_name(scen_name)
                 s, z = self.get_polygon(scen_name).get_s_values(stored_values_unk.FROUDE, which_group=scen_name, operator=operator, which_sim=sim_name)
-                ax.plot(s, z, label=f"{scen_name} - {sim_name}", linestyle='--', linewidth=1.5)
+                ax.plot(s, z, label=f"{full_name} - {sim_name}", linestyle='--', linewidth=1.5)
 
             filename = self.directories[Directory_Analysis.IMAGES] / f"{self.name}_{ref}_{str(xmin)}_{str(xmax)}_Froude_comparison.png"
 
-        fig.set_size_inches(20,10)#15
+        if figsize is not None:
+            if not isinstance(figsize, tuple) or len(figsize) != 2:
+                logging.error("Figure size must be a tuple of (width, height).")
+                raise ValueError("Figure size must be a tuple of (width, height).")
+            fig.set_size_inches(figsize)
+        else:
+            fig.set_size_inches(self.fig_size[0], self.fig_size[1])  # Use the default figure size
+
         ax.legend()
         #zoomA
         ax.set_xlim(xmin, xmax)
@@ -1724,6 +1836,8 @@ class Analysis_Scenarios():
 
         :param scenario_name: The name of the scenario to set as current.
         """
+
+        scenario_name = _sanitize_scenario_name(scenario_name)
         if scenario_name not in self.scenarios_directories:
             logging.error(f"Scenario '{scenario_name}' not found in the analysis.")
             raise ValueError(f"Scenario '{scenario_name}' not found in the analysis.")
@@ -1737,6 +1851,8 @@ class Analysis_Scenarios():
         :param scenario_name: The name of the scenario to get.
         :return: The path to the scenario directory.
         """
+
+        scenario_name = _sanitize_scenario_name(scenario_name)
         if scenario_name not in self.scenarios_directories:
             logging.error(f"Scenario '{scenario_name}' not found in the analysis.")
             raise KeyError(f"Scenario '{scenario_name}' not found in the analysis.")
@@ -1848,7 +1964,11 @@ L'attention est toutefois attirée sur le fait que cette approche pourrait ne pa
         return fig, ax
 
     def load_modifications(self, ad2viewer:bool = True):
-        """ Load modifications for scenarios from vecz files."""
+        """ Load modifications for scenarios from vecz files.
+
+        :param ad2viewer: If True, add the modifications to the map viewer.
+        :raises ValueError: If the MapViewer is not initialized.
+        """
 
         MODIF = 'bath_assembly.vecz'
 

wolfhece/scenario/config_manager.py

@@ -671,7 +671,13 @@ class Config_Manager_2D_GPU:
             ok &= (GPU_2D_file.PARAMETERS.value.name+GPU_2D_file.PARAMETERS.value.extension).lower() in [cur.name.lower() for cur in curdict[GPU_2D_file_extensions.JSON.value]]
 
             if ok:
-                json_data = json.load(open(curdict['path'] / (GPU_2D_file.PARAMETERS.value.name+GPU_2D_file.PARAMETERS.value.extension), 'r'))
+                try:
+                    json_data = json.load(open(curdict['path'] / (GPU_2D_file.PARAMETERS.value.name+GPU_2D_file.PARAMETERS.value.extension), 'r'))
+                except json.JSONDecodeError as e:
+                    logging.error(_('Error decoding JSON file: {}').format(e))
+                    curdict['missing'].append(GPU_2D_file_extensions.JSON.value)
+                    ok = False
+                    return
 
         else:
             curdict['missing'].append(GPU_2D_file_extensions.JSON.value)
@@ -1382,6 +1388,7 @@ class Config_Manager_2D_GPU:
                 logging.error(_('Infiltration .tif must be a full integer array ! -- The array will be ignored !'))
                 infiltration = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_INTEGER)
                 infiltration.array.data[:,:] = 0
+
         else:
             infiltration = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_INTEGER)
             infiltration.array.data[:,:] = 0
@@ -1494,6 +1501,20 @@ class Config_Manager_2D_GPU:
                     else:
                         cursim.qy = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
 
+
+            # check if infiltration array is strictly inside nap
+            if not np.all(cursim.nap[infiltration.array.data[infiltration.array.data > 0]] == 1):
+                logging.warning(_('Infiltration zones must be strictly inside the NAP !'))
+                logging.warning(_('Infiltration zones outside NAP will be set to 0 !'))
+
+                #count number of infiltration zones outside NAP
+                nb_outside = np.sum(infiltration.array.data[(infiltration.array.data > 0) & (cursim.nap == 0)])
+                logging.warning(_('Number of infiltration zones outside NAP: {}').format(nb_outside))
+                # index infiltration zones outside NAP
+                indices = list(set(infiltration.array.data[(infiltration.array.data > 0) & (cursim.nap == 0)]))
+                logging.warning(_('Indices of infiltration zones outside NAP: {}').format(indices))
+                infiltration.array.data[(infiltration.array.data > 0) & (cursim.nap == 0)] = 0
+
             cursim.infiltration_zones = np.asarray(infiltration.array.data, dtype=np.int32)
 
             if roof.nbnotnull == 0:

wolfhece/wolf_array.py

@@ -987,7 +987,7 @@ class header_wolf():
                     if "base_coord_y" in params['parameters'].keys() :
                         self.origy = float(params['parameters']["base_coord_y"])
 
-                self.nullvalue = 99999.
+                self.nullvalue = 0 if 'nap.npy' in filename.lower() else 99999.
             else:
 
                 self.dx = 1.
@@ -10459,7 +10459,9 @@ class WolfArray(Element_To_Draw, header_wolf):
                         Walonmap:bool=False,
                         cat:str='IMAGERIE/ORTHO_2022_ETE',
                         first_mask_data:bool=True,
-                        with_legend:bool=False):
+                        with_legend:bool=False,
+                        IGN:bool=False,
+                        Cartoweb:bool=False):
         """
         Plot the array - Matplotlib version
 
@@ -10555,6 +10557,51 @@ class WolfArray(Element_To_Draw, header_wolf):
             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)
+
+        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 vmin is None and vmax is not None:
             vmin = self.mypal.values[0]

{wolfhece-2.2.26.dist-info → wolfhece-2.2.28.dist-info}/METADATA

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

@@ -8,16 +8,16 @@ wolfhece/Model1D.py,sha256=snEmu8Uj2YGcp1ybPnly-4A389XRnuOujGduqInNcgw,477001
 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=3ZKNrXhdHYNjuFKV47l7vHFMcqWElQUxDuM8XX1R5zk,662179
+wolfhece/PyDraw.py,sha256=zK2k-KC1VpqYTTJIfO_CPEjHWBoQh1h2xXMafE4ECGY,662673
 wolfhece/PyGui.py,sha256=DqMTDsC9GthnMdYOXvkMKfl5pNciExVzxG4ogptWf6g,146010
 wolfhece/PyGuiHydrology.py,sha256=sKafpOopBg50L5llZCI_fZtbebVTDtxvoRI6-osUwhg,14745
 wolfhece/PyHydrographs.py,sha256=1P5XAURNqCvtSsMQXhOn1ihjTpr725sRsZdlCEhhk6M,3730
-wolfhece/PyPalette.py,sha256=k9b_95GYD0USQ8DS5zGXeZ577712U6772kmhEbJtlXw,35406
+wolfhece/PyPalette.py,sha256=SiRngKml2EXsq1jwQvqh5pBZiV1yS0CY7QrRJGSZD1s,36281
 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=V4YQDIN69yj1SZvYWxXXa3sUomyAeJq74c2xrHCkrhc,337191
+wolfhece/PyVertexvectors.py,sha256=57-4vU-C8KIIf3iPjDzmNNqSKsIM3SRhSbT4V_md5TM,336874
 wolfhece/PyWMS.py,sha256=-wU-oWS5il1z702gYd90xHx5O7PvGNr9nb693oue_cI,31412
 wolfhece/RatingCurve.py,sha256=bUjIrQjvIjkD4V-z8bZmA6pe1ILtYNM0-3fT6YUY1RU,22498
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
@@ -60,7 +60,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=zPyJhWFkbwYpPndfIDiul0rX2tdOjVhv3ZU1Nf77_X8,519285
+wolfhece/wolf_array.py,sha256=nkU6-pSin-OF5BvgDsdSg6aywsdCQdeNVXtFblriXsw,521716
 wolfhece/wolf_hist.py,sha256=fTEb60Q4TEwobdZsRU4CFXAId1eOKdWAqF8lnF1xEWc,3590
 wolfhece/wolf_texture.py,sha256=8BcVSezLEogTHYmtA4yfSPzaw6UpAeYYySVaAowIKtQ,20858
 wolfhece/wolf_tiles.py,sha256=v-HohqaWuMYdn75XLnA22dlloAG90iwnIqrgnB0ASQ4,10488
@@ -88,7 +88,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=ywl1rGt9d5UlGmLPuCEKV0NQSzDV2Zum80Gbo1pTZqs,388
+wolfhece/apps/version.py,sha256=pK3K0wU-fe8-W4tB4CsiRNctriME-0MPLh4L7BAsJEY,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
@@ -265,14 +265,16 @@ wolfhece/rem/REMMaker.py,sha256=zkiAo36MmusPhgv1qJmpDgtoTWbh_eJ6qJqtCfeC1M8,3148
 wolfhece/rem/RasterViz.py,sha256=fnyMfAJZDoS-rjagsNRGLndS-UYNUzMY4DgenjD3Y_4,29068
 wolfhece/rem/__init__.py,sha256=S2-J5uEGK_VaMFjRUYFIdSScJjZyuXH4RmMmnG3OG7I,19
 wolfhece/report/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wolfhece/report/common.py,sha256=7a6zQ-wLZ0ElUVodWCO08TyRBXrI7lnTrosJGcV5_tM,17619
+wolfhece/report/compare_arrays.py,sha256=JuaSfRV0VXVirLfdCJzP2XSLtfRi0R73-vhtTI6fneg,33232
 wolfhece/report/pdf.py,sha256=zrSSY1JPk59FxK9pFWQfhVKIQAoc_wjeTrXO3tSiEHo,1959
 wolfhece/report/reporting.py,sha256=JUEXovx_S4jpYkJEBU0AC-1Qw2OkkWyV3VAp6iOfSHc,19494
-wolfhece/report/simplesimgpu.py,sha256=kx9IMCr9afPwv9B3G5ADQfaIuHXuqTkgSjg-5bXVuqo,60738
-wolfhece/report/tools.py,sha256=8veLJr-vWmO56Y73c1fowCOum9IAiWYygC7gEZEBeFk,90875
+wolfhece/report/simplesimgpu.py,sha256=qwf8EZnSu_DEmxFNAxYLElvCgjEKcCm3_-tvX8wUvdk,57932
+wolfhece/report/tools.py,sha256=ZA4PfHQXgvDtTnrSZh-oSwhQT_cQtb49LuZB8VI7nyI,96852
 wolfhece/report/wolf_report.png,sha256=NoSV58LSwb-oxCcZScRiJno-kxDwRdm_bK-fiMsKJdA,592485
 wolfhece/scenario/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/scenario/check_scenario.py,sha256=d-LWa_FxmPxTSc_H1lDHwqLB6TCqj1IUrRJhatfPMMA,5623
-wolfhece/scenario/config_manager.py,sha256=6ZYyCdhjcQ9H-CCCm072vYzMHFifeIFo_R3Ht3dJaiU,114288
+wolfhece/scenario/config_manager.py,sha256=00xo6e-mLxZEK1atiHKfr2MSuJ_n6QgO3fQsHDYf3mI,115588
 wolfhece/scenario/imposebc_void.py,sha256=PqA_99hKcaqK5zsK6IRIc5Exgg3WVpgWU8xpwNL49zQ,5571
 wolfhece/scenario/update_void.py,sha256=Yb7TMIUx9Gzm9_6qRMJnF39Uqi17dIkMmscSXo2WaTs,10033
 wolfhece/shaders/fragment_shader_texture.glsl,sha256=w6h8d5mJqFaGbao0LGmjRcFFdcEQ3ICIl9JpuT71K5k,177
@@ -301,8 +303,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.26.dist-info/METADATA,sha256=F6COfsHmlgTZoUOckJarKwQJFDwXPD7t0Q6bK66pMgg,2729
-wolfhece-2.2.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-wolfhece-2.2.26.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
-wolfhece-2.2.26.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.2.26.dist-info/RECORD,,
+wolfhece-2.2.28.dist-info/METADATA,sha256=9fInjN6bCfzKHTXS3cFPY_au-O9JrPLujBu3zYKLADE,2729
+wolfhece-2.2.28.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+wolfhece-2.2.28.dist-info/entry_points.txt,sha256=Jr187pyvA3EeJiQLjZK9yo6mJX7IAn6ygZU9T8qF_gQ,658
+wolfhece-2.2.28.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.2.28.dist-info/RECORD,,