wolfhece 2.2.27__py3-none-any.whl → 2.2.29__py3-none-any.whl

wolfhece/report/simplesimgpu.py

@@ -11,6 +11,7 @@ from tempfile import NamedTemporaryFile
 from datetime import datetime as dt
 
 import matplotlib.pyplot as plt
+import matplotlib as mpl
 import seaborn as sns
 
 import pymupdf as pdf
@@ -19,111 +20,18 @@ 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):
         """ Initialize the Simple Simulation GPU Report Viewer """
 
+        self._summary = {}
         self._doc = None
 
         if isinstance(sim, Path):
@@ -132,6 +40,7 @@ class SimpleSimGPU_Report():
             except Exception as e:
                 logging.error(f"Failed to load simulation from path {sim}: {e}")
                 self._sim = None
+                self._summary['errors'] = e
                 return
         elif isinstance(sim, str):
             try:
@@ -139,6 +48,7 @@ class SimpleSimGPU_Report():
             except Exception as e:
                 logging.error(f"Failed to load simulation from string path {sim}: {e}")
                 self._sim = None
+                self._summary['errors'] = e
                 return
         elif not isinstance(sim, SimpleSimulation):
             try:
@@ -146,12 +56,12 @@ class SimpleSimGPU_Report():
             except Exception as e:
                 logging.error(f"Failed to set simulation: {e}")
                 self._sim = None
+                self._summary['errors'] = e
                 return
         else:
             logging.error("Invalid type for simulation. Must be SimpleSimulation, Path, or str.")
             return
 
-        self._summary = {}
         self._summary['warnings'] = self._summary_warnings()
         self._summary['errors'] = self._summary_errors()
 
@@ -366,9 +276,13 @@ class SimpleSimGPU_Report():
         # Plot the histogram of waterdepth adn add it to the PDF
         fig, ax = plt.subplots(figsize=(8, 6))
         # Plot the histogram of water depth
-        ax.hist(sim.h[sim.h > 0.], bins=100, density=True)
-        # ax.set_title('Histogram of Water Depth')
-        ax.set_xlim(0, np.max(sim.h[sim.h > 0.]) * 1.25)  # Set xlim to 110% of max value
+
+        h_min = np.min(sim.h[sim.nap == 1])
+        h_max = np.max(sim.h[sim.nap == 1])
+
+        if h_max > h_min:
+            ax.hist(sim.h[sim.h > 0.], bins=100, density=True)
+            ax.set_xlim(0, h_max)  # Set xlim to 110% of max value
         ax.set_xlabel('Water Depth [m]')
         ax.set_ylabel('Frequency')
 
@@ -395,7 +309,7 @@ class SimpleSimGPU_Report():
         ax.hist(sim.manning[sim.nap == 1], bins=100, density = True)
         # ax.set_title('Histogram of Manning Coefficient')
         ax.set_xlabel('Manning [$\\frac {s} {m^{1/3}} $]')
-        ax.set_xlim(0, np.max(sim.manning[sim.nap == 1]) * 1.25)  # Set xlim to 110% of max value
+        ax.set_xlim(0, np.max(sim.manning[sim.nap == 1]) * 1.1)  # Set xlim to 110% of max value
         ax.set_ylabel('Frequency')
 
         # set font size of the labels
@@ -865,15 +779,21 @@ class SimpleSimGPU_Report():
 
 class SimpleSimGPU_Report_wx(PDFViewer):
 
-    def __init__(self, sim:SimpleSimulation | Path | str, **kwargs):
+    def __init__(self, sim:SimpleSimulation | Path | str, show:bool=False, **kwargs):
         """ Initialize the Simple Simulation GPU Report Viewer """
 
+        mpl.use('Agg')  # Use a non-interactive backend for matplotlib
+
         super(SimpleSimGPU_Report_wx, self).__init__(None, **kwargs)
 
         self._report = SimpleSimGPU_Report(sim, **kwargs)
 
         if self._report._sim is None:
             logging.error("No simulation data available to create report.")
+            dlg = wx.MessageDialog(self, "No simulation data available to create report.\n\nPlease check the errors in the logs.",
+                                  "Error", wx.OK | wx.ICON_ERROR)
+            dlg.ShowModal()
+            dlg.Destroy()
             return
 
         self._report.create_report()
@@ -892,6 +812,11 @@ class SimpleSimGPU_Report_wx(PDFViewer):
 
         self.Bind(wx.EVT_CLOSE, self.on_close)
 
+        if show:
+            self.Show()
+
+        mpl.use('WxAgg')  # Reset matplotlib to use the WxAgg backend for other plots
+
     def on_close(self, event):
         """ Handle the close event of the frame """
 

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):
@@ -850,7 +919,14 @@ class Analysis_Scenarios():
 
             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)
@@ -879,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.
@@ -887,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
@@ -922,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)
@@ -948,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):
@@ -1015,7 +1105,14 @@ class Analysis_Scenarios():
 
             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)
@@ -1739,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.")
@@ -1752,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.")
@@ -1863,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'