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

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"])
@@ -1277,9 +1328,9 @@ def compute_vulnerability4scenario(manager:Accept_Manager):
             array_mod = gdal.Open(str(curfile))
             array_mod = np.array(array_mod.GetRasterBand(1).ReadAsArray())
 
-            ij = np.where(array_mod == 1)
-            array_vuln[ij] = 1
-            array_code[ij] = 1
+            ij = np.argwhere(array_mod == 1)
+            array_vuln[ij[:,0], ij[:,1]] = 1
+            array_code[ij[:,0], ij[:,1]] = 1
 
     dst_filename= str(manager.TMP_VULN)
     y_pixels, x_pixels = array_vuln.shape  # number of pixels in x
@@ -1331,11 +1382,20 @@ def match_vulnerability2sim(inRas:Path, outRas:Path, MODREC:Path):
     ds = gdal.Translate(outRas, ds, projWin = [minx, maxy, maxx, miny])
     ds = None
 
+
+@nb.jit(nopython=True, boundscheck=False, inline='always')
+def update_accept(accept, model_h, ij, bounds, loc_accept):
+    for idx in range(len(bounds)):
+        for i,j in ij:
+            if bounds[idx,0] < model_h[i,j] <= bounds[idx,1]:
+                accept[i,j] = loc_accept[idx]
+
 def compute_acceptability(manager:Accept_Manager,
            model_h:np.ndarray,
            vulnerability:np.ndarray,
            interval:int,
-           geo_projection):
+           geo_projection:tuple,
+           save_to_file:bool=True) -> np.ndarray:
 
     """
     Compute the local acceptability based on :
@@ -1343,7 +1403,7 @@ def compute_acceptability(manager:Accept_Manager,
         - the water depth
         - the matrices
 
-    :param dirsnames: the Dirs_Names object from the calling function
+    :param manager: the Accept_Manager object from the calling function
     :param model_h: the water depth matrix
     :param vulnerability: the vulnerability matrix
     :param interval: the return period
@@ -1353,50 +1413,50 @@ def compute_acceptability(manager:Accept_Manager,
 
     logging.info(interval)
 
-    Qfile = pd.read_csv(manager.POINTS_CSV)
+    points_accept = pd.read_csv(manager.POINTS_CSV)
 
-    Qfile = Qfile[Qfile["Interval"]==interval]
-    Qfile = Qfile.reset_index()
+    points_accept = points_accept[points_accept["Interval"]==interval]
+    points_accept = points_accept.reset_index()
 
-    x,y = vulnerability.shape
-    accept = np.zeros((x,y))
+    accept = np.zeros(vulnerability.shape, dtype=np.float32)
 
-    ij_1 = np.where(vulnerability == 1)
-    ij_2 = np.where(vulnerability == 2)
-    ij_3 = np.where(vulnerability == 3)
-    ij_4 = np.where(vulnerability == 4)
-    ij_5 = np.where(vulnerability == 5)
+    bounds = np.asarray([[0., 0.02], [0.02, 0.3], [0.3, 1], [1, 2.5], [2.5, 1000]], dtype=np.float32)
 
-    bounds = [(0., 0.02), (0.02, 0.3), (0.3, 1), (1, 2.5), (2.5, 1000)]
+    for i in range(1,6):
+        ij = np.argwhere(vulnerability == i)
 
-    accept_1 = [Qfile["h-0"][4], Qfile["h-0.02"][4], Qfile["h-0.3"][4], Qfile["h-1"][4], Qfile["h-2.5"][4]]
-    accept_2 = [Qfile["h-0"][3], Qfile["h-0.02"][3], Qfile["h-0.3"][3], Qfile["h-1"][3], Qfile["h-2.5"][3]]
-    accept_3 = [Qfile["h-0"][2], Qfile["h-0.02"][2], Qfile["h-0.3"][2], Qfile["h-1"][2], Qfile["h-2.5"][2]]
-    accept_4 = [Qfile["h-0"][1], Qfile["h-0.02"][1], Qfile["h-0.3"][1], Qfile["h-1"][1], Qfile["h-2.5"][1]]
-    accept_5 = [Qfile["h-0"][0], Qfile["h-0.02"][0], Qfile["h-0.3"][0], Qfile["h-1"][0], Qfile["h-2.5"][0]]
+        idx_pts = 5-i
+        accept_pts = [points_accept["h-0"][idx_pts], 
+                      points_accept["h-0.02"][idx_pts], 
+                      points_accept["h-0.3"][idx_pts], 
+                      points_accept["h-1"][idx_pts], 
+                      points_accept["h-2.5"][idx_pts]]
+        
+        update_accept(accept, model_h, ij, bounds, accept_pts)
 
-    accept[:,:] = -99999
-    for ij, loc_accept in zip([ij_1, ij_2, ij_3, ij_4, ij_5], [accept_1, accept_2, accept_3, accept_4, accept_5]):
-        if len(ij[0]) > 0:
-            for idx, (min_bound, max_bound) in enumerate(bounds):
-                loc_ij = np.where((model_h[ij] > min_bound) & (model_h[ij] <= max_bound))
-                accept[ij[0][loc_ij], ij[1][loc_ij]] = loc_accept[idx]
+    if save_to_file:
+        #save raster
+        dst_filename = str(manager.TMP_QFILES / "Q{}.tif".format(interval))
 
-    #save raster
-    dst_filename = str(manager.TMP_QFILES / "Q{}.tif".format(interval))
+        y_pixels, x_pixels = accept.shape  # number of pixels in x
+        driver = gdal.GetDriverByName('GTiff')
+        dataset = driver.Create(dst_filename, 
+                                x_pixels, y_pixels, 
+                                1, 
+                                gdal.GDT_Float32,  
+                                options=["COMPRESS=LZW"])
 
-    y_pixels, x_pixels = accept.shape  # number of pixels in x
-    driver = gdal.GetDriverByName('GTiff')
-    dataset = driver.Create(dst_filename, x_pixels, y_pixels, 1, gdal.GDT_Float32,  options=["COMPRESS=LZW"])
-    dataset.GetRasterBand(1).WriteArray(accept.astype(np.float32))
+        dataset.GetRasterBand(1).WriteArray(accept.astype(np.float32))
 
-    geotrans, proj = geo_projection
-    dataset.SetGeoTransform(geotrans)
-    dataset.SetProjection(proj)
-    dataset.FlushCache()
-    dataset = None
+        geotrans, proj = geo_projection
+        dataset.SetGeoTransform(geotrans)
+        dataset.SetProjection(proj)
+        dataset.FlushCache()
+        dataset = None
 
-def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1.):
+    return accept
+
+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 +1473,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 +1530,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 +1597,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 = 30
 
     def __str__(self):