wolfhece 2.2.1__py3-none-any.whl → 2.2.3__py3-none-any.whl

wolfhece/acceptability/func.py

@@ -15,6 +15,7 @@ from ..PyVertexvectors import Zones, zone, vector, wolfvertex, getIfromRGB
 from ..PyTranslate import _
 from ..scenario. config_manager import Config_Manager_2D_GPU
 
+import subprocess
 import geopandas as gpd
 import pandas as pd
 import numpy as np
@@ -94,6 +95,23 @@ def cleaning_directory(dir:Path):
         if item.is_file():
             os.remove(item)
 
+def empty_folder(folder):
+    """
+    Empties the content of a directory if it exists.
+    """
+    if os.path.exists(folder):
+        for files in os.listdir(folder):
+            fn = os.path.join(folder, files)
+            try:
+                if os.path.isfile(fn) or os.path.islink(fn):
+                    os.unlink(fn)  
+                elif os.path.isdir(fn):
+                    shutil.rmtree(fn)  
+            except Exception as e:
+                print(f"Error when deleting file {fn}: {e}")
+    else:
+        print("The folder does not exist.")
+        
 class Accept_Manager():
     """
     Structure to store the directories and names of the files.
@@ -608,10 +626,8 @@ class Accept_Manager():
             for i in range(1, len(rt)-1):
                 # Full formula
                 # pond.append((1./float(rt[i-1]) - 1./float(rt[i]))/2. + (1./float(rt[i]) - 1./float(rt[i+1]))/2.)
-
                 # More compact formula
                 pond.append((1./float(rt[i-1]) - 1./float(rt[i+1]))/2.)
-
             pond.append(1./float(rt[-1]) + (1./float(rt[-2]) - 1./float(rt[-1]))/2.)
 
             return pd.DataFrame(pond, columns=["Ponderation"], index=rt)
@@ -898,15 +914,15 @@ class Accept_Manager():
 
         if len(code) == 0:
             logging.error("The code rasters do not exist")
-            return ["The code rasters do not exist"]
+            return False
 
         if len(vuln) == 0:
             logging.error("The vulnerability rasters do not exist")
-            return ["The vulnerability rasters do not exist"]
+            return False
 
         if len(code) != len(vuln):
             logging.error("The number of code and vulnerability rasters do not match")
-            return ["The number of code and vulnerability rasters do not match"]
+            return False
 
         # we take a reference raster
         ref = gdal.Open(str(code[0]))
@@ -982,14 +998,18 @@ class Accept_Manager():
 
     def check_nodata(self, name, path_baseline):
             """ Check nodata in a path """
+            from ..wolf_array import WOLF_ARRAY_FULL_INTEGER8
             list_tif = Accept_Manager.select_name_tif(self, path_baseline, self.IN_CH_SA_SC, name)
             for cur_lst in list_tif:
                 curarray:WolfArray = WolfArray(cur_lst)
-                if curarray.nullvalue != 99999.:
-                    curarray.nullvalue = 99999.
-                    curarray.set_nullvalue_in_mask()
-                    curarray.write_all()
-                    logging.warning(_('nodata changed in favor of 99999. value for file {} !'.format(cur_lst)))
+                if curarray.wolftype != WOLF_ARRAY_FULL_INTEGER8:
+                    if curarray.nullvalue != 99999.:
+                        curarray.nullvalue = 99999.
+                        curarray.set_nullvalue_in_mask()
+                        curarray.write_all()
+                        logging.warning(_('nodata changed in favor of 99999. value for file {} !'.format(cur_lst)))
+                else:
+                    logging.info(_('nodata value is {} for file {} !'.format(curarray.nullvalue, cur_lst)))
 
     def create_vrtIfExists(self, fn_baseline, fn_scenario, fn_vrt, name):
         """ Create a vrt file from a path """
@@ -1037,9 +1057,73 @@ class Accept_Manager():
         else :
             logging.error("No Masked_River_extent files. Please provide them.")
         return trace
-
-
-
+    
+    # Interpolation
+    # -----------------------------
+    def batch_creation_and_interpolation(self, checked_paths, iftest):
+        """Creates a batch file to launch holes.exe from the selected simulations and launches it.
+                -Every files in EXTRACTED_LAST_STEP are interpolated for tests (iftest==True).
+                -Only the check simulations of the windows are interpolated for the GUI (iftest!=True)."""
+        path_LastSteps = Path(self.IN_SA_EXTRACTED)
+        C = None
+        D = None
+        for file in os.listdir(Path(self.IN_SA_DEM)):
+            file_path = Path(self.IN_SA_DEM) / file
+            if file_path.is_file() and file.startswith("MNT_") and file_path.suffix == ".bin":
+                if "mask" not in file:
+                    D = file_path
+                else:
+                    C = file_path      
+        if D == None:
+            return logging.error("DEM (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and CANNOT include the word 'mask'")
+            
+        if C == None:
+            return logging.error("DEM mask (.bin) not found in DEM_FILES. The file must begins by 'MNT_' and MUST include the word 'mask'")
+             
+        path_Interp =  Path(self.IN_SA_INTERP)
+        path_bat_file = os.path.join(self.IN_SCEN_DIR, "process_files.bat")
+        
+        if os.path.exists(path_bat_file):
+            logging.info(f"The file {path_bat_file} already exists and will be replaced.")
+            os.remove(path_bat_file)
+        path_code = os.path.join(self.IN_WATER_DEPTH, "holes.exe") 
+        A, B = [], []
+        if iftest == True:
+            #no checked box in the tests
+            path_Interp =  Path(self.IN_SA_INTERP)
+            path_LastSteps = Path(self.IN_SA_EXTRACTED)
+            A = [os.path.join(path_LastSteps,f) for f in os.listdir(path_LastSteps) if f.endswith('.bin') and not f.endswith('.bin.txt')]
+            B = [os.path.join(path_Interp, os.path.splitext(os.path.basename(f))[0]) for f in A]
+        
+        else : 
+            for path in checked_paths:
+                parts = path.name.split("sim_") 
+                A.extend([os.path.join(path_LastSteps, g) for g in os.listdir(path_LastSteps) if g.endswith(f"{parts[1]}.bin")])
+            B = [os.path.join(path_Interp, os.path.splitext(os.path.basename(f))[0]) for f in A]
+        if not A or not B or not C or not D:
+            return logging.error("Missing files.")
+        with open(path_bat_file, "w") as bat_file:
+            for a, b in zip(A, B):
+                line = f'"{path_code}" filling in="{a}" out="{b}" mask="{C}" dem="{D} avoid_last=1"\n'
+                bat_file.write(line)
+        
+        empty_folder(self.IN_SA_INTERP)
+        path_bat_file = os.path.join(self.IN_SCEN_DIR, "process_files.bat")
+        subprocess.run([path_bat_file], check=True)
+        
+        renamed_files = []
+        path_fichier=self.IN_SA_INTERP
+        for file in path_fichier.glob("*.tif"):
+            if "_h" in file.name:  
+                new_name = file.stem.split("_h")[0].replace(".bin", "") + ".tif"
+                file.rename(file.with_name(new_name))
+                renamed_files.append(new_name) 
+        #deleting the other
+        for file in path_fichier.glob("*.tif"):
+            if "_combl" in file.name or file.name not in renamed_files:
+                file.unlink()
+                
+        return True, renamed_files
 
 def clip_layer(layer:str,
              file_path:str,
@@ -1569,6 +1653,8 @@ def compute_acceptability(manager:Accept_Manager,
                       points_accept["h-1"][idx_pts],
                       points_accept["h-2.5"][idx_pts]]
 
+        accept_pts = list(accept_pts).copy()
+
         update_accept(accept, model_h, ij, bounds, accept_pts)
 
     if save_to_file:

wolfhece/apps/check_install.py

@@ -37,12 +37,12 @@ def main():
     else:
         ret += 'WolfGPU not installed\n Please install WolfGPU if needed\n\n'
 
-    try:
-        from ..libs import wolfpy
-        ret += 'Wolfpy accessible\n\n'
-    except ImportError as e:
-        ret += 'Wolfpy not accessible\n\n'
-        ret += 'Error : ' + str(e) + '\n\n'
+    # try:
+    #     from ..libs import wolfpy
+    #     ret += 'Wolfpy accessible\n\n'
+    # except ImportError as e:
+    #     ret += 'Wolfpy not accessible\n\n'
+    #     ret += 'Error : ' + str(e) + '\n\n'
 
     try:
         from ..PyGui import MapManager

wolfhece/apps/splashscreen.py

@@ -11,6 +11,11 @@ copying or distribution of this file, via any medium, is strictly prohibited.
 """
 This is a minimal wxPython SplashScreen
 """
+try:
+    from osgeo import gdal
+except ImportError as e:
+    print(f"Import Error: {e} - GDAL")
+    print("Please install GDAL for your Python version.")
 
 from os.path import dirname, join, exists
 import wx

wolfhece/apps/version.py

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

wolfhece/assets/__init__.py

@@ -0,0 +1 @@
+from . import _add_path

wolfhece/assets/speedometer.py

@@ -0,0 +1,135 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from matplotlib.colors import LinearSegmentedColormap
+
+
+
+class Semi_Circle_Gauge():
+
+    def __init__(self):
+        # Create a polar plot for the speedometer background
+        self.fig, self.ax = plt.subplots(figsize=(6, 3), subplot_kw={'projection': 'polar'})
+        self.ax.set_theta_zero_location('W')
+        self.ax.set_theta_direction(-1)
+
+    def plot_background(self):                
+        # Define the ranges for red, yellow, and green
+        theta = np.linspace(0, np.pi, 500)
+        # Create metallic gradient for green with highlights for a modern effect
+        green_cmap = LinearSegmentedColormap.from_list(
+            "metallic_green", ["#003300", "#00FF00", "#66FF66", "#00FF00", "#003300"]
+        )
+        green_colors = green_cmap(np.linspace(0, 1, 500))
+        self.ax.fill_between(theta, 0, 1, where=(theta <= np.pi/3), color=None, alpha=0.7, facecolor=green_colors)
+        # green_cmap = LinearSegmentedColormap.from_list("metallic_green", ["#006400", "#00FF00", "#006400"])
+        # green_colors = green_cmap(np.linspace(0, 1, 500))
+        # ax.fill_between(theta, 0, 1, where=(theta <= np.pi/3), color=None, alpha=0.7, facecolor=green_colors)
+
+        # Create metallic gradient for yellow
+        yellow_cmap = LinearSegmentedColormap.from_list("metallic_yellow", ["#FFD700", "#FFFF00", "#FFD700"])
+        yellow_colors = yellow_cmap(np.linspace(0, 1, 500))
+        self.ax.fill_between(theta, 0, 1, where=((theta > np.pi/3) & (theta <= 2*np.pi/3)), color=None, alpha=0.7, facecolor=yellow_colors)
+
+        # Create metallic gradient for red
+        red_cmap = LinearSegmentedColormap.from_list("metallic_red", ["#8B0000", "#FF0000", "#8B0000"])
+        red_colors = red_cmap(np.linspace(0, 1, 500))
+        self.ax.fill_between(theta, 0, 1, where=(theta > 2*np.pi/3), color=None, alpha=0.7, facecolor=red_colors)
+
+        # Remove polar grid and labels for a clean look
+        self.ax.grid(False)
+        self.ax.set_yticks([])
+        self.ax.set_xticks([])
+
+        self.ax.set_ylim(0, 1)
+        self.ax.set_xlim(0, np.pi)
+
+    def plot_needle(self, value, color='black'):
+        # Add a needle to indicate a specific value
+        width = 0.1  # Needle width
+        self.ax.fill([value, value-width, value, value+width, value], 
+                [0, .25, .9, .25, 0], color='black', linewidth=2, zorder=5)
+        self.ax.plot([value, value+width*.9, value], 
+                [.9, .25, 0], color='grey', linewidth=2, zorder=6)
+        self.ax.plot([value, value+width, value], 
+                [.9, .25, 0], color='white', linewidth=1, zorder=6)
+        # Plot a black semi-circle at the origin
+        semi_circle = plt.Circle((0, 0), 0.1, transform=self.ax.transData._b, color='black', zorder=7)
+        self.ax.add_artist(semi_circle)
+
+    def plot_text(self, text, value):
+        # Add text to the speedometer
+        # The text is above the speedometer in the center
+        # The value is the angle of the needle
+        self.ax.text(np.pi/2., 1.15, text, fontsize=12, ha='center', va='center', color='black')
+
+class Rectangular_Gauge():
+
+    def __init__(self, horizontal_or_vertical='vertical'):
+        # Create a rectangular plot for the speedometer background
+
+        if horizontal_or_vertical == 'horizontal':
+            self.fig, self.ax = plt.subplots(figsize=(6, 3))
+            self.direction = 'horizontal'
+        else:
+            # Default to vertical if not specified
+            self.fig, self.ax = plt.subplots(figsize=(3, 6))
+            self.direction = 'vertical'
+
+        self.ax.set_xlim(0, 1)
+        self.ax.set_ylim(0, 1)
+
+    def plot_background(self):
+        # Define the ranges for red, yellow, and green
+
+        if self.direction == 'horizontal':
+            # Horizontal speedometer
+            self.ax.fill_between([0, 1/3], 0, 1, color='green', alpha=0.7)
+            self.ax.fill_between([1/3, 2/3], 0, 1, color='yellow', alpha=0.7)
+            self.ax.fill_between([2/3, 1], 0, 1, color='red', alpha=0.7)
+        else:
+            # Vertical speedometer
+            self.ax.fill_between([0, 1], 0, 1/3, color='green', alpha=0.7)
+            self.ax.fill_between([0, 1], 1/3, 2/3, color='yellow', alpha=0.7)
+            self.ax.fill_between([0, 1], 2/3, 1, color='red', alpha=0.7)
+
+        # Remove grid and ticks for a clean look
+        self.ax.grid(False)
+        self.ax.set_xticks([])
+        self.ax.set_yticks([])
+
+    def plot_needle(self, value):
+        # Add a needle to indicate a specific value
+        width = 0.01  # Needle width
+
+        if self.direction == 'horizontal':
+            # Horizontal speedometer
+            self.ax.fill([value-width, value+width, value+width, value-width],
+                         [0.25, 0.25, 0.9, 0.9], color='black', linewidth=2)
+        else:
+            # Vertical speedometer
+            self.ax.fill([0, 1, 1, 0],
+                            [value-width, value-width, value+width, value+width], color='black', linewidth=2)
+
+    def plot_text(self, text, value):
+        # Add text to the speedometer
+        self.ax.text(0.5, 1.15, text, fontsize=12, ha='center', va='center', color='black')
+
+
+
+
+if __name__ == "__main__":
+    # Test the speedometer function
+    fig = Semi_Circle_Gauge()
+    import matplotlib.animation as animation
+
+    def update(frame):
+        fig.ax.clear()
+        fig.plot_background()  # Reinitialize the speedometer to clear previous needle
+        fig.plot_needle(frame)
+        fig.plot_text("Danger: {:.2f}".format(frame), frame)
+
+    # Create an animation with values ranging from 0 to π
+    ani = animation.FuncAnimation(fig.fig, update, frames=np.linspace(0, np.pi, 100), interval=50)
+
+    plt.show()
+    pass