wolfhece 2.1.28__py3-none-any.whl → 2.1.29__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
@@ -47,7 +47,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,7 +79,7 @@ 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")
@@ -146,7 +146,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,7 +206,7 @@ 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)
 
@@ -216,7 +218,7 @@ 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 +237,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)
 
@@ -258,7 +260,7 @@ def Vulnerability(main_dir:str = 'Data',
                   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 +291,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():
@@ -380,8 +382,6 @@ def Acceptability(main_dir:str = 'Vesdre',
 
     # 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,7 +390,11 @@ 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
+    vulne = vulne.GetRasterBand(1).ReadAsArray() 
     riv = riv.GetRasterBand(1).ReadAsArray()    
 
     # Get the return periods available

wolfhece/acceptability/func.py

@@ -135,7 +135,7 @@ class Accept_Manager():
                  CE_IGN_top10v:str = 'CE_IGN_TOP10V/CE_IGN_TOP10V.shp',
                  EPU_Stations:str = 'AJOUT_PDET_EPU_DG03_STATIONS.shp',
                  Ponderation_csv:str = 'Ponderation.csv',
-                 Vulnerability_csv:str = 'Vulnerability.csv',
+                 Vuln_csv:str = 'Vulnerability.csv',
                  Intermediate_csv:str = 'Intermediate.csv'
                                                          ) -> None:
 
@@ -171,7 +171,7 @@ class Accept_Manager():
         self.CE_IGN_TOP10V  = self.IN_DATABASE / self._ce_ign_top10v
         self.EPU_STATIONS   = self.IN_EPU_STATIONS / EPU_Stations
 
-        self.VULNERABILITY_CSV = self.IN_CSV / Vulnerability_csv
+        self.VULNERABILITY_CSV = self.IN_CSV / Vuln_csv
         self.POINTS_CSV        = self.IN_CSV / Intermediate_csv
         self.PONDERATION_CSV   = self.IN_CSV / Ponderation_csv
 
@@ -854,6 +854,53 @@ class Accept_Manager():
         else:
             return Modif_Type.COPY
 
+    def check_origin_shape(self) -> list[str]:
+
+        code = self.get_files_in_rasters_code()
+        vuln = self.get_files_in_rasters_vulne()
+
+        if len(code) == 0:
+            logging.error("The code rasters do not exist")
+            return False
+        
+        if len(vuln) == 0:
+            logging.error("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 False
+        
+        # we take a reference raster
+        ref = gdal.Open(str(code[0]))
+        band_ref = ref.GetRasterBand(1)
+        proj_ref = ref.GetProjection()
+        geo_ref  = ref.GetGeoTransform()
+        col_ref, row_ref = band_ref.XSize, band_ref.YSize
+
+        # we compare the reference raster with the others
+        diff = []
+        for cur in code + vuln + [self.SA_MASKED_RIVER]:
+            cur_ = gdal.Open(str(cur))
+            band_cur = cur_.GetRasterBand(1)
+            proj_cur = cur_.GetProjection()
+            geo_cur  = cur_.GetGeoTransform()
+            col_cur, row_cur = band_cur.XSize, band_cur.YSize
+
+            if geo_ref != geo_cur:
+                logging.error("The geotransforms do not match {}".format(cur))
+                diff.append(cur)
+
+            if proj_ref != proj_cur:
+                logging.error("The projections do not match {}".format(cur))
+                diff.append(cur)
+
+            if col_ref != col_cur or row_ref != row_cur:
+                logging.error("The dimensions do not match {}".format(cur))
+                diff.append(cur)
+            
+        return diff
+
 
 def clip_layer(layer:str,
              file_path:str,
@@ -1103,7 +1150,6 @@ def compute_vulnerability(manager:Accept_Manager):
     # Create a JIT function to update the arrays
     # Faster than the classical Python loop or Numpy
     @nb.jit(nopython=True, boundscheck=False, inline='always')
-    # @cuda.jit(device=True, inline=True)
     def update_arrays_jit(tmp_vuln, array_vuln):
         for i in range(tmp_vuln.shape[0]):
             for j in range(tmp_vuln.shape[1]):
@@ -1113,11 +1159,14 @@ def compute_vulnerability(manager:Accept_Manager):
         return array_vuln
 
     @nb.jit(nopython=True, boundscheck=False, inline='always')
-    # @cuda.jit(device=True, inline=True)
-    def update_arrays_jit_coo(row, col, locvuln, array_vuln):
-        for i,j in zip(row, col):
-            if locvuln >= array_vuln[i, j]:
-                array_vuln[i, j] = locvuln
+    def update_arrays_jit_csr(row, col, locvuln, array_vuln):
+        for k in range(len(row)-1):
+            i = k
+            j1 = row[k]
+            j2 = row[k+1]
+            for j in col[j1:j2]:
+                if locvuln >= array_vuln[i, j]:
+                    array_vuln[i, j] = locvuln
 
         return array_vuln
     
@@ -1135,7 +1184,7 @@ def compute_vulnerability(manager:Accept_Manager):
             ii = ij_npz['row']
             jj = ij_npz['col']
             # We use the jit
-            update_arrays_jit_coo(ii, jj, locvuln, array_vuln)
+            update_arrays_jit_csr(ii, jj, locvuln, array_vuln)
         
         else:
             ds  = gdal.OpenEx(str(rasters_vuln[i]), open_options=["SPARSE_OK=TRUE"])
@@ -1194,7 +1243,6 @@ def compute_code(manager:Accept_Manager):
     # Create a JIT function to update the arrays
     # Faster than the classical Python loop or Numpy
     @nb.jit(nopython=True, boundscheck=False, inline='always')
-    # @cuda.jit(device=True, inline=True)
     def update_arrays_jit(tmp_code, loccode, array_code):
         for i in range(tmp_code.shape[0]):
             for j in range(tmp_code.shape[1]):
@@ -1204,11 +1252,14 @@ def compute_code(manager:Accept_Manager):
         return array_code
 
     @nb.jit(nopython=True, boundscheck=False, inline='always')
-    # @cuda.jit(device=True, inline=True)
-    def update_arrays_jit_coo(row, col, loccode, array_code):
-        for i,j in zip(row, col):
-            if loccode >= array_code[i, j]:
-                array_code[i, j] = loccode
+    def update_arrays_jit_csr(row, col, loccode, array_code):
+        for k in range(len(row)-1):
+            i = k
+            j1 = row[k]
+            j2 = row[k+1]
+            for j in col[j1:j2]:
+                if loccode >= array_code[i, j]:
+                    array_code[i, j] = loccode
 
         return array_code
     
@@ -1222,7 +1273,7 @@ def compute_code(manager:Accept_Manager):
             ii = ij_npz['row']
             jj = ij_npz['col']
             # We use the jit
-            update_arrays_jit_coo(ii, jj, loccode, array_code)
+            update_arrays_jit_csr(ii, jj, loccode, array_code)
         
         else:
             ds  = gdal.OpenEx(str(rasters_code[i]), open_options=["SPARSE_OK=TRUE"])
@@ -1396,7 +1447,7 @@ def compute_acceptability(manager:Accept_Manager,
     dataset.FlushCache()
     dataset = None
 
-def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1.):
+def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1., manager:Accept_Manager = None):
     """
     Convert a vector layer to a raster tiff file.
 
@@ -1413,12 +1464,23 @@ def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1.):
     # Force the input to be a string
     vector_fn = str(vector_fn)
     raster_fn = str(raster_fn)
+    
+    if manager is None:
+        extent_fn = vector_fn
+        logging.warning("The extent file is not provided, the extent will be the same as the vector file")
+    else:
+        extent_fn = str(manager.SA)
+        logging.info("The extent file is provided")
 
     NoData_value = 0 # np.nan is not necessary a good idea
+
     # Open the data sources and read the extents
-    source_ds = ogr.Open(vector_fn)
+    source_ds:ogr.DataSource = ogr.Open(vector_fn)
     source_layer = source_ds.GetLayer()
-    x_min, x_max, y_min, y_max = source_layer.GetExtent()
+
+    extent_ds:ogr.DataSource = ogr.Open(extent_fn)
+    extent_layer = extent_ds.GetLayer()
+    x_min, x_max, y_min, y_max = extent_layer.GetExtent()
 
     x_min = float(int(x_min))
     x_max = float(np.ceil(x_max))
@@ -1459,6 +1521,8 @@ def vector_to_raster(layer:str,
     """
     Convert a vector layer to a raster tiff file
 
+    FIXME: Test de vulerability value and return immedialty if it is 1 if attribute == "Vulne"
+
     :param layer: the layer name in the GDB file
     :param vector_input: the path to the vector file
     :param extent: the path to the extent file
@@ -1524,11 +1588,31 @@ def vector_to_raster(layer:str,
                                  "ALL_TOUCHED=TRUE"])
     
     if convert_to_sparse:
+        SPARSITY_THRESHOLD = 0.02
         # Convert the raster to a npz containing the row and col of the non-null values
         array = band.ReadAsArray()
         ij = np.nonzero(array)
-        np.savez_compressed(Path(out_file).with_suffix('.npz'), row=ij[0].astype(np.int32), col=ij[1].astype(np.int32))
+
+        if len(ij[0]) < int(x_res * y_res * SPARSITY_THRESHOLD):
+            i,j = convert_to_csr(ij[0], ij[1], y_res)
+            np.savez_compressed(Path(out_file).with_suffix('.npz'), row=np.asarray(i, dtype=np.int32), col=np.asarray(j, dtype=np.int32))
+        else:
+            logging.info("The raster is not sparse enough to be converted to a CSR forma {}".format(layer))
 
     target_ds = None
 
     return 0
+
+@nb.jit(nopython=True, boundscheck=False, inline='always')
+def convert_to_csr(i_indices, j_indices, num_rows):
+    row_ptr = [0] * (num_rows + 1)
+    col_idx = []
+ 
+    for i in range(len(i_indices)):
+        row_ptr[i_indices[i] + 1] += 1
+        col_idx.append(j_indices[i])
+ 
+    for i in range(1, len(row_ptr)):
+        row_ptr[i] += row_ptr[i - 1]
+ 
+    return row_ptr, col_idx

wolfhece/apps/splashscreen.py

@@ -7,6 +7,13 @@ import wx
 import time
 from   wx.adv import SplashScreen as SplashScreen,SPLASH_CENTRE_ON_SCREEN,SPLASH_TIMEOUT,Sound
 
+# try:
+#     from ..libs import wolfogl
+# except:
+#     print("** WolfOGL not found **")
+#     print("Without WolfOGL, the application will not work !")
+#     print("Please reinstall 'wolfhece' package -- pip install wolfhece")
+
 class WolfLauncher(SplashScreen):
     """
     Wolf Splashcreen
@@ -15,10 +22,17 @@ class WolfLauncher(SplashScreen):
     done = False
 
     def __init__(self, parent=None, play_sound=True):
-
+        
         if self.done:
             return
 
+        # try:
+        #     wolfogl.init()
+        # except Exception as e:
+        #     print("Error initializing WolfOGL -- We must stop here !")
+        #     print("Please reinstall 'wolfhece' package -- pip install wolfhece")
+        #     exit()
+
         mydir=dirname(__file__)
         mybitmap = wx.Bitmap(name=join(mydir,".\\WolfPython2.png"), type=wx.BITMAP_TYPE_PNG)
 

wolfhece/apps/version.py

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