wolfhece 2.1.28__py3-none-any.whl → 2.1.30__py3-none-any.whl

wolfhece/PyDraw.py

@@ -7489,9 +7489,9 @@ class WolfMapViewer(wx.Frame):
             self._set_active_bc()
 
             #Print info in the status bar
-            txt  = 'Dx : {:4f} ; Dy : {:4f}'.format(self.active_array.dx, self.active_array.dy)
-            txt += ' ; Xmin : {:4f} ; Ymin : {:4f}'.format(self.active_array.origx, self.active_array.origy)
-            txt += ' ; Xmax : {:4f} ; Ymax : {:4f}'.format(self.active_array.origx + self.active_array.dx * float(self.active_array.nbx),
+            txt  = 'Dx : {:.4f} ; Dy : {:.4f}'.format(self.active_array.dx, self.active_array.dy)
+            txt += ' ; Xmin : {:.4f} ; Ymin : {:.4f}'.format(self.active_array.origx, self.active_array.origy)
+            txt += ' ; Xmax : {:.4f} ; Ymax : {:.4f}'.format(self.active_array.origx + self.active_array.dx * float(self.active_array.nbx),
                                                            self.active_array.origy + self.active_array.dy * float(self.active_array.nby))
             txt += ' ; Nx : {:d} ; Ny : {:d}'.format(self.active_array.nbx, self.active_array.nby)
 

wolfhece/PyPalette.py

@@ -333,6 +333,14 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
             self.nb = i
             self.values=self.values[0:i]
             self.colors=self.colors[0:i,:]
+        else:
+            self.nb = i
+            oldvalues = self.values
+            oldcolors = self.colors
+            self.values = np.zeros(self.nb , dtype=float)
+            self.colors = np.zeros((self.nb,4) , dtype=int)
+            self.values[0:len(oldvalues)] = oldvalues
+            self.colors[0:len(oldcolors),:] = oldcolors
 
         update = False
 

wolfhece/acceptability/acceptability.py

@@ -1,6 +1,6 @@
 from .Parallels import parallel_gpd_clip, parallel_v2r, parallel_datamod 
 from .func import data_modification, compute_vulnerability, compute_vulnerability4scenario
-from .func import match_vulnerability2sim, compute_acceptability, shp_to_raster
+from .func import match_vulnerability2sim, compute_acceptability, shp_to_raster, clip_layer
 from .func import Accept_Manager, cleaning_directory, EXTENT, Vulnerability_csv, compute_code
 
 import pandas as pd
@@ -38,6 +38,14 @@ class steps_vulnerability(Enum):
     APPLY_MODIFS = 2
     MATCH_SIMUL = 3
 
+class steps_acceptability(Enum):
+    """ 
+    Enum for the steps in the acceptability computation
+    """
+    COMPUTE_LOCAL_ACCEPT = 1
+    LOAD_FROM_FILES      = 2
+    COMPUTE_MEAN_ACCEPT  = 3
+
 def Base_data_creation(main_dir:str = 'Data', 
                        Original_gdb:str = 'GT_Resilence_dataRisques202010.gdb', 
                        Study_area:str = 'Bassin_Vesdre.shp', 
@@ -47,7 +55,7 @@ def Base_data_creation(main_dir:str = 'Data',
                        resolution:float = 1.,
                        number_procs:int = 8,
                        steps:list[int] | list[steps_base_data_creation] = [1,2,3,4,5,6,7],
-                       Vulnerability_csv:str = 'Vulnerability.csv'):
+                       Vuln_csv:str = 'Vulnerability.csv'):
     """
     Create the databse.
 
@@ -79,13 +87,12 @@ def Base_data_creation(main_dir:str = 'Data',
                            CaPa_Walloon=CaPa_Walloon,
                            PICC_Walloon=PICC_Walloon,
                            CE_IGN_top10v=CE_IGN_top10v,
-                           Vulnerability_csv=Vulnerability_csv)
+                           Vuln_csv=Vuln_csv)
 
     if not manager.check_before_database_creation():
         logging.error("The necessary files are missing - Verify logs for more information")
         return
     
-    manager.change_dir()
     done = []
 
     if 1 in steps or 6 in steps or steps_base_data_creation.PREPROCESS_VULNCODE in steps or steps_base_data_creation.CLIP_GDB in steps:
@@ -146,7 +153,9 @@ def Base_data_creation(main_dir:str = 'Data',
     if 5 in steps or steps_base_data_creation.RASTERIZE_IGN in steps:
         # ********************************************************************************************************************
         # Step 5 : Rasaterize the IGN data "Course d'eau" to get the riverbed mask
-        shp_to_raster(manager.CE_IGN_TOP10V, manager.SA_MASKED_RIVER, resolution)
+        LAYER_IGN = "CE_IGN_TOP10V"
+        clip_layer(layer=LAYER_IGN, file_path=manager.CE_IGN_TOP10V, Study_Area=manager.SA, output_dir=manager.TMP_IGNCE)
+        shp_to_raster(manager.TMP_IGNCE / (LAYER_IGN + '.gpkg'), manager.SA_MASKED_RIVER, resolution, manager=manager)
 
         done.append(steps_base_data_creation.RASTERIZE_IGN)
         
@@ -204,19 +213,17 @@ def Base_data_creation(main_dir:str = 'Data',
                            Study_area, 
                            resolution, 
                            number_procs=number_procs,
-                           Vulnerability_csv=Vulnerability_csv)
+                           Vuln_csv=Vuln_csv)
 
         done.append(steps_base_data_creation.DATABASE_TO_RASTER)
 
-    manager.restore_dir()
-
     return done
 
 def Database_to_raster(main_dir:str = 'Data',
                        Study_area:str = 'Bassin_Vesdre.shp',
                        resolution:float = 1.,
                        number_procs:int = 16,
-                       Vulnerability_csv:str = 'Vulnerability.csv'):
+                       Vuln_csv:str = 'Vulnerability.csv'):
     """ 
     Convert the vector database to raster database based on their vulnerability values 
     
@@ -235,7 +242,7 @@ def Database_to_raster(main_dir:str = 'Data',
     The parallel processing is safe as each layer is processed independently.
     """
 
-    manager = Accept_Manager(main_dir, Study_area, Vulnerability_csv=Vulnerability_csv)
+    manager = Accept_Manager(main_dir, Study_area, Vuln_csv=Vuln_csv)
 
     resolution = float(resolution)
 
@@ -243,22 +250,18 @@ def Database_to_raster(main_dir:str = 'Data',
         logging.error("The necessary files are missing - Verify logs for more information")
         return
 
-    manager.change_dir()
-
     logging.info("Convert vectors to raster based on their vulnerability values")
     
     attributes = ["Vulne", "Code"]
     for cur_attrib in attributes:
         parallel_v2r(manager, cur_attrib, resolution, number_procs, convert_to_sparse=True)
 
-    manager.restore_dir()
-
 def Vulnerability(main_dir:str = 'Data',
                   scenario:str = 'Scenario1',
                   Study_area:str = 'Bassin_Vesdre.shp',
                   resolution:float = 1.,
                   steps:list[int] | list[steps_vulnerability] = [1,10,11,2,3],
-                  Vulnerability_csv:str = 'Vulnerability.csv',
+                  Vuln_csv:str = 'Vulnerability.csv',
                   Intermediate_csv:str = 'Intermediate.csv'):
     """
     Compute the vulnerability for the study area and the scenario, if needed.
@@ -289,7 +292,7 @@ def Vulnerability(main_dir:str = 'Data',
     manager = Accept_Manager(main_dir, 
                              Study_area, 
                              scenario=scenario, 
-                             Vulnerability_csv=Vulnerability_csv,
+                             Vuln_csv=Vuln_csv,
                              Intermediate_csv=Intermediate_csv)
 
     if not manager.check_before_vulnerability():
@@ -298,7 +301,6 @@ def Vulnerability(main_dir:str = 'Data',
 
     logging.info("Starting VULNERABILITY computations at {} m resolution".format(resolution))
     
-    manager.change_dir()
     done = []	
     
     if 1 in steps or steps_vulnerability.CREATE_RASTERS in steps:
@@ -360,28 +362,26 @@ def Vulnerability(main_dir:str = 'Data',
 
         done.append(steps_vulnerability.MATCH_SIMUL)
 
-    manager.restore_dir()
-
     return done
 
 def Acceptability(main_dir:str = 'Vesdre',
                   scenario:str = 'Scenario1',
                   Study_area:str = 'Bassin_Vesdre.shp',
                   coeff_auto:bool = True,
-                  Ponderation_csv:str = 'Ponderation.csv'):
+                  Ponderation_csv:str = 'Ponderation.csv',
+                  resample_size:int = 100,
+                  steps:list[int] | list[steps_acceptability] = [1,2,3]):
     """ Compute acceptability for the scenario """
     
+    done = []
+
     manager = Accept_Manager(main_dir, 
                              Study_area, 
                              scenario=scenario,
                              Ponderation_csv=Ponderation_csv)
 
-    manager.change_dir()
-
     # Load the vulnerability raster **for the scenario**
     vulne = gdal.Open(str(manager.OUT_VULN))
-    # Convert to numpy array
-    vulne = vulne.GetRasterBand(1).ReadAsArray() 
 
     # Load the river mask
     riv = gdal.Open(str(manager.OUT_MASKED_RIVER))
@@ -390,8 +390,12 @@ def Acceptability(main_dir:str = 'Vesdre',
     geotrans = riv.GetGeoTransform()  
     proj = riv.GetProjection()  
 
+    assert vulne.GetGeoTransform() == riv.GetGeoTransform(), "The geotransform of the two rasters is different"
+    assert vulne.GetProjection() == riv.GetProjection(), "The projection of the two rasters is different"
+
     # Convert to numpy array
-    riv = riv.GetRasterBand(1).ReadAsArray()    
+    vulne = vulne.GetRasterBand(1).ReadAsArray() 
+    riv   = riv.GetRasterBand(1).ReadAsArray()    
 
     # Get the return periods available
     return_periods = manager.get_return_periods()
@@ -399,116 +403,140 @@ def Acceptability(main_dir:str = 'Vesdre',
     # Prepare the river bed filter
     # Useful as we iterate over the return periods
     # and the river bed is the same for all return periods
-    ij_riv = np.where(riv == 1)
+    ij_riv = np.argwhere(riv == 1)
     
-    # Compute acceptability for each return period
-    for curT in tqdm(return_periods):
-
-        # Load the **FILLED** modelled water depth for the return period
-        model_h = gdal.Open(str(manager.get_sim_file_for_return_period(curT)))
-        # Convert to numpy array
-        model_h = model_h.GetRasterBand(1).ReadAsArray()
-
-        # Set nan if the water depth is 0.
-        # 'nan' is a good choice as it will not be considered in the computation.
-        model_h[model_h == 0] = np.nan
-        # Set nan in the river bed
-        model_h[ij_riv] = np.nan
-
-        logging.info("Return period {}".format(curT))
-        # Compute the local acceptability for the return period
-        compute_acceptability(manager, model_h, vulne, curT, (geotrans, proj))
-
-    # At this point, the local acceptability for each return period is computed
-    # and stored in tiff files in the TEMP/SutyArea/scenario/Q_FILES directory
-    
-    # Get the list of Q files
-    qs = manager.get_q_files()
     # Initialize the dictionary to store the acceptability values
-    q_dict = {}
+    part_accept = {}
 
-    # Iterate over the return periods
-    for curT in return_periods:
-        logging.info("vm"+str(curT))
+    if 1 in steps or steps_acceptability.COMPUTE_LOCAL_ACCEPT in steps:
+        # Compute acceptability for each return period
+        for curT in tqdm(return_periods):
 
-        # We set the filename from the return period, not the "qs" list
-        q_filename = manager.TMP_QFILES / "Q{}.tif".format(curT)
-        
-        # Check if the file exists
-        assert q_filename.exists(), "The file {} does not exist".format(q_filename)
-        # Check if the file is in the "qs" list
-        assert q_filename in qs, "The file {} is not in the list of Q files".format(q_filename)
-
-        # Load the Q file for the return period
-        tmp_data = gdal.Open(str(q_filename))
-        # Convert to numpy array
-        q_dict["vm"+str(curT)] = tmp_data.GetRasterBand(1).ReadAsArray()
-
-        # Force the deletion of the variable, rather than waiting for the garbage collector
-        # May be useful if the files are large
-        del tmp_data
-
-    # Pointing the last return period, maybe 1000 but not always
-    array_t1000 = q_dict["vm{}".format(return_periods[-1])]
-    # Get the indices where the value is -99999
-    # We will force the same mask for all lower return periods
-    ij_t1000 = np.where(array_t1000 == -99999)
-
-    # Iterate over the return periods
-    for curT in return_periods:
-      
-      if curT != return_periods[-1]:
-        logging.info(curT)
-        
-        # Alias
-        tmp_array = q_dict["vm{}".format(curT)]
-        
-        # Set the -99999 values to 0
-        tmp_array[tmp_array == -99999] = 0.
-        # Set the masked values, for the last return period, to nan
-        tmp_array[ij_t1000] = np.nan
-
-    # # Load the ponderation file
-    # pond = pd.read_csv(dirsnames.PONDERATION_CSV)
-    # # Set the index to the interval, so we can use the interval as a key
-    # pond.set_index("Interval", inplace=True)
-
-    # Get ponderations for the return periods
-    if coeff_auto:
-        pond = manager.get_ponderations()
-        assert pond["Ponderation"].sum() > 0.999999 and pond["Ponderation"].sum()<1.0000001, "The sum of the ponderations is not equal to 1"
-
-    elif manager.is_valid_ponderation_csv:
-        pond = pd.read_csv(manager.PONDERATION_CSV)
-        pond.set_index("Interval", inplace=True)
-    else:
-        logging.error("The ponderation file is missing")
-        logging.info("Please provide the ponderation file or set 'coeff_auto' to True")
-        return
+            # Load the **FILLED** modelled water depth for the return period
+            model_h = gdal.Open(str(manager.get_sim_file_for_return_period(curT)))
+            # Convert to numpy array
+            model_h = model_h.GetRasterBand(1).ReadAsArray()
+
+            assert model_h.shape == vulne.shape, "The shape of the modelled water depth is different from the vulnerability raster"
+
+            # Set 0. if the water depth is 0.
+            model_h[model_h == 0] = 0
+            # Set 0. in the river bed
+            model_h[ij_riv[:,0], ij_riv[:,1]] = 0
+
+            assert model_h[ij_riv[0][0], ij_riv[0][1]] == 0, "The river bed is not set to 0 in the modelled water depth"
+            assert model_h.max() > 0, "The maximum water depth is 0"
+            if model_h.min() < 0:
+                logging.warning("The minimum water depth is negative - {} cells".format(np.count_nonzero(model_h<0)))
+                logging.warning("Setting the negative values to 0")
+                model_h[model_h < 0] = 0
+
+            logging.info("Return period {}".format(curT))
+
+            # Compute the local acceptability for the return period
+            part_accept[curT] = compute_acceptability(manager, model_h, vulne, curT, (geotrans, proj))
 
-    assert len(pond) == len(return_periods), "The number of ponderations is not equal to the number of return periods"
+        done.append(steps_acceptability.COMPUTE_LOCAL_ACCEPT)
 
-    # Initialize the combined acceptability matrix -- Ponderate mean of the local acceptability
-    comb = np.zeros(q_dict["vm{}".format(return_periods[-1])].shape)
+        # At this point, the local acceptability for each return period is computed
+        # and stored in tiff files in the TEMP/SutyArea/scenario/Q_FILES directory.
+        # The arrays are also stored in the part_accept dictionary.
+
+    if 2 in steps or steps_acceptability.LOAD_FROM_FILES in steps:
+        # Load/Reload the acceptability values from files
+
+        if 1 in steps or steps_acceptability.COMPUTE_LOCAL_ACCEPT in steps:
+            # We have computed/updted the acceptibility values.
+            # We do not need to reload them.
+            logging.warning("The acceptability values have been computed in step 1 - avoid reloading")
+            logging.info("If you want to reload the acceptability values, please remove step 1 from the list of steps")
+        else:
     
-    for curT in return_periods:
-         comb += q_dict["vm{}".format(curT)] * pond["Ponderation"][curT]
+            # Get the list of Q files
+            qs = manager.get_q_files()
+
+            # Iterate over the return periods
+            for curT in return_periods:
+                logging.info(curT)
+
+                # We set the filename from the return period, not the "qs" list
+                q_filename = manager.TMP_QFILES / "Q{}.tif".format(curT)
+                
+                # Check if the file exists
+                assert q_filename.exists(), "The file {} does not exist".format(q_filename)
+                # Check if the file is in the "qs" list
+                assert q_filename in qs, "The file {} is not in the list of Q files".format(q_filename)
+
+                # Load the Q file for the return period
+                tmp_data = gdal.Open(str(q_filename))
+                # Convert to numpy array
+                part_accept[curT] = tmp_data.GetRasterBand(1).ReadAsArray()
+
+        done.append(steps_acceptability.LOAD_FROM_FILES)
+
+    if 3 in steps or steps_acceptability.COMPUTE_MEAN_ACCEPT in steps:
+
+        assert len(part_accept) == len(return_periods), "The number of acceptability files is not equal to the number of return periods"
+
+        # Pointing the last return period, maybe 1000 but not always
+        array_tmax = part_accept[return_periods[-1]]
+
+        # Get ponderations for the return periods
+        if coeff_auto:
+            logging.info("Automatic ponderation")
+            pond = manager.get_ponderations()
+            assert pond["Ponderation"].sum() > 0.999999 and pond["Ponderation"].sum()<1.0000001, "The sum of the ponderations is not equal to 1"
+
+        elif manager.is_valid_ponderation_csv:
+            logging.info("Manual ponderation")
+            # Load the ponderation file
+            pond = pd.read_csv(manager.PONDERATION_CSV)
+            # Set the index to the interval, so we can use the interval as a key
+            pond.set_index("Interval", inplace=True)
+        
+        else:
+            logging.error("The ponderation file is missing")
+            logging.info("Please provide the ponderation file or set 'coeff_auto' to True")
+            return -1
 
-    y_pixels, x_pixels = comb.shape  # number of pixels in x
+        assert len(pond) == len(return_periods), "The number of ponderations is not equal to the number of return periods"
 
-    # Set up output GeoTIFF
-    driver = gdal.GetDriverByName('GTiff')
-    dataset = driver.Create(str(manager.OUT_ACCEPT), x_pixels, y_pixels, 1, gdal.GDT_Float32, options=["COMPRESS=LZW"])
-    dataset.GetRasterBand(1).WriteArray(comb.astype(np.float32))   
-    dataset.SetGeoTransform(geotrans)
-    dataset.SetProjection(proj)
-    dataset.FlushCache()
-    del(dataset)
+        # Initialize the combined acceptability matrix -- Ponderate mean of the local acceptability
+        comb = np.zeros(part_accept[return_periods[-1]].shape, dtype=np.float32)
+        
+        for curT in return_periods:
+            assert part_accept[curT].dtype == np.float32, "The dtype of the acceptability matrix is not np.float32"
+            assert part_accept[curT].shape == comb.shape, "The shape of the acceptability matrix is not the right one"
 
-    # Resample to 100m
-    Agg = gdal.Warp(str(manager.OUT_ACCEPT_100M), str(manager.OUT_ACCEPT), xRes=100, yRes=100, resampleAlg='Average')
-    del(Agg)
+            comb += part_accept[curT] * float(pond["Ponderation"][curT])
 
-    manager.restore_dir()
+        y_pixels, x_pixels = comb.shape  # number of pixels in x
 
-    return 0
+        # Set up output GeoTIFF
+        driver = gdal.GetDriverByName('GTiff')
+        dataset = driver.Create(str(manager.OUT_ACCEPT), 
+                                x_pixels, y_pixels, 
+                                1, 
+                                gdal.GDT_Float32, 
+                                options=["COMPRESS=LZW"])
+        
+        assert comb.dtype == np.float32, "The dtype of the combined acceptability matrix is not np.float32"
+
+        dataset.GetRasterBand(1).WriteArray(comb)   
+        dataset.SetGeoTransform(geotrans)
+        dataset.SetProjection(proj)
+        dataset.FlushCache()
+        dataset=None
+
+        # Resample to XXm
+        Agg = gdal.Warp(str(manager.OUT_ACCEPT_100M), 
+                        str(manager.OUT_ACCEPT), 
+                        xRes=resample_size, 
+                        yRes=resample_size, 
+                        resampleAlg='Average')
+        Agg.FlushCache()
+        Agg = None
+
+        done.append(steps_acceptability.COMPUTE_MEAN_ACCEPT)
+
+    return done