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

wolfhece/acceptability/Parallels.py

@@ -44,7 +44,8 @@ def parallel_gpd_clip(layer:list[str],
 def parallel_v2r(manager:Accept_Manager,
                  attribute:str, 
                  pixel:float,
-                 number_procs:int = 1):
+                 number_procs:int = 1,
+                 convert_to_sparse:bool = False):
     """ 
     Convert the vector layers to raster.
 
@@ -63,14 +64,17 @@ def parallel_v2r(manager:Accept_Manager,
     layers = manager.get_layers_in_codevulne()
 
     if number_procs == 1:
+        result_list=[]
         for curlayer in layers:
-            vector_to_raster(curlayer, manager, attribute, pixel)
+            result_list.append(vector_to_raster(curlayer, manager, attribute, pixel,convert_to_sparse))
+
     else:
         pool = multiprocessing.Pool(processes=number_procs)
         prod_x=partial(vector_to_raster,
                        manager=manager, 
                        attribute=attribute, 
-                       pixel_size=pixel) 
+                       pixel_size=pixel,
+                       convert_to_sparse=convert_to_sparse) 
         
         result_list = pool.map(prod_x, layers)
 

wolfhece/acceptability/acceptability.py

@@ -1,5 +1,7 @@
 from .Parallels import parallel_gpd_clip, parallel_v2r, parallel_datamod 
-from .func import data_modification, compute_vulnerability, compute_vulnerability4scenario, match_vulnerability2sim, compute_acceptability, shp_to_raster, Accept_Manager, cleaning_directory, EXTENT, Vulnerability_csv
+from .func import data_modification, compute_vulnerability, compute_vulnerability4scenario
+from .func import match_vulnerability2sim, compute_acceptability, shp_to_raster
+from .func import Accept_Manager, cleaning_directory, EXTENT, Vulnerability_csv, compute_code
 
 import pandas as pd
 import os
@@ -31,6 +33,8 @@ class steps_vulnerability(Enum):
     Enum for the steps in the vulnerability computation
     """
     CREATE_RASTERS = 1
+    CREATE_RASTERS_VULN = 10
+    CREATE_RASTERS_CODE = 11
     APPLY_MODIFS = 2
     MATCH_SIMUL = 3
 
@@ -42,7 +46,8 @@ def Base_data_creation(main_dir:str = 'Data',
                        CE_IGN_top10v:str = 'CE_IGN_TOP10V/CE_IGN_TOP10V.shp',
                        resolution:float = 1.,
                        number_procs:int = 8,
-                       steps:list[int] | list[steps_base_data_creation] = [1,2,3,4,5,6,7]):
+                       steps:list[int] | list[steps_base_data_creation] = [1,2,3,4,5,6,7],
+                       Vulnerability_csv:str = 'Vulnerability.csv'):
     """
     Create the databse.
 
@@ -73,7 +78,8 @@ def Base_data_creation(main_dir:str = 'Data',
                            Original_gdb=Original_gdb,
                            CaPa_Walloon=CaPa_Walloon,
                            PICC_Walloon=PICC_Walloon,
-                           CE_IGN_top10v=CE_IGN_top10v)
+                           CE_IGN_top10v=CE_IGN_top10v,
+                           Vulnerability_csv=Vulnerability_csv)
 
     if not manager.check_before_database_creation():
         logging.error("The necessary files are missing - Verify logs for more information")
@@ -194,7 +200,11 @@ def Base_data_creation(main_dir:str = 'Data',
         cleaning_directory(manager.TMP_RASTERS_CODE)
         cleaning_directory(manager.TMP_RASTERS_VULNE)
         
-        Database_to_raster(main_dir, Study_area, resolution, number_procs=number_procs)
+        Database_to_raster(main_dir, 
+                           Study_area, 
+                           resolution, 
+                           number_procs=number_procs,
+                           Vulnerability_csv=Vulnerability_csv)
 
         done.append(steps_base_data_creation.DATABASE_TO_RASTER)
 
@@ -205,7 +215,8 @@ def Base_data_creation(main_dir:str = 'Data',
 def Database_to_raster(main_dir:str = 'Data',
                        Study_area:str = 'Bassin_Vesdre.shp',
                        resolution:float = 1.,
-                       number_procs:int = 16):
+                       number_procs:int = 16,
+                       Vulnerability_csv:str = 'Vulnerability.csv'):
     """ 
     Convert the vector database to raster database based on their vulnerability values 
     
@@ -224,7 +235,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)
+    manager = Accept_Manager(main_dir, Study_area, Vulnerability_csv=Vulnerability_csv)
 
     resolution = float(resolution)
 
@@ -238,7 +249,7 @@ def Database_to_raster(main_dir:str = 'Data',
     
     attributes = ["Vulne", "Code"]
     for cur_attrib in attributes:
-        parallel_v2r(manager, cur_attrib, resolution, number_procs)
+        parallel_v2r(manager, cur_attrib, resolution, number_procs, convert_to_sparse=True)
 
     manager.restore_dir()
 
@@ -246,7 +257,9 @@ 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,2,3]):
+                  steps:list[int] | list[steps_vulnerability] = [1,10,11,2,3],
+                  Vulnerability_csv:str = 'Vulnerability.csv',
+                  Intermediate_csv:str = 'Intermediate.csv'):
     """
     Compute the vulnerability for the study area and the scenario, if needed.
 
@@ -273,7 +286,11 @@ def Vulnerability(main_dir:str = 'Data',
 
     """
 
-    manager = Accept_Manager(main_dir, Study_area, scenario=scenario)
+    manager = Accept_Manager(main_dir, 
+                             Study_area, 
+                             scenario=scenario, 
+                             Vulnerability_csv=Vulnerability_csv,
+                             Intermediate_csv=Intermediate_csv)
 
     if not manager.check_before_vulnerability():
         logging.error("The necessary files are missing - Verify logs for more information")
@@ -292,7 +309,13 @@ def Vulnerability(main_dir:str = 'Data',
 
         cleaning_directory(manager.TMP_SCEN_DIR)
 
-        compute_vulnerability(manager)
+        if 10 in steps or steps_vulnerability.CREATE_RASTERS_VULN in steps:
+            compute_vulnerability(manager)
+            done.append(steps_vulnerability.CREATE_RASTERS_VULN)
+        
+        if 11 in steps or steps_vulnerability.CREATE_RASTERS_CODE in steps:
+            compute_code(manager)
+            done.append(steps_vulnerability.CREATE_RASTERS_CODE)
 
         done.append(steps_vulnerability.CREATE_RASTERS)
 
@@ -343,10 +366,15 @@ def Vulnerability(main_dir:str = 'Data',
 
 def Acceptability(main_dir:str = 'Vesdre',
                   scenario:str = 'Scenario1',
-                  Study_area:str = 'Bassin_Vesdre.shp'):
+                  Study_area:str = 'Bassin_Vesdre.shp',
+                  coeff_auto:bool = True,
+                  Ponderation_csv:str = 'Ponderation.csv'):
     """ Compute acceptability for the scenario """
     
-    manager = Accept_Manager(main_dir, Study_area, scenario=scenario)
+    manager = Accept_Manager(main_dir, 
+                             Study_area, 
+                             scenario=scenario,
+                             Ponderation_csv=Ponderation_csv)
 
     manager.change_dir()
 
@@ -446,10 +474,19 @@ def Acceptability(main_dir:str = 'Vesdre',
     # pond.set_index("Interval", inplace=True)
 
     # Get ponderations for the return periods
-    pond = manager.get_ponderations()
+    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
 
     assert len(pond) == len(return_periods), "The number of ponderations is not equal to the number of return periods"
-    assert pond["Ponderation"].sum() > 0.999999 and pond["Ponderation"].sum()<1.0000001, "The sum of the ponderations is not equal to 1"
 
     # Initialize the combined acceptability matrix -- Ponderate mean of the local acceptability
     comb = np.zeros(q_dict["vm{}".format(return_periods[-1])].shape)

wolfhece/acceptability/func.py

@@ -10,7 +10,6 @@ from tqdm import tqdm
 from pyogrio import list_layers, read_dataframe
 from enum import Enum   
 import numba as nb
-from numba import cuda
 
 ENGINE = 'pyogrio' # or 'Fiona -- Pyogrio is faster
 EXTENT = '.gpkg'
@@ -134,7 +133,10 @@ class Accept_Manager():
                  CaPa_Walloon:str = 'Cadastre_Walloon.gpkg',
                  PICC_Walloon:str = 'PICC_vDIFF.gdb',
                  CE_IGN_top10v:str = 'CE_IGN_TOP10V/CE_IGN_TOP10V.shp',
-                 EPU_Stations:str = 'AJOUT_PDET_EPU_DG03_STATIONS.shp'
+                 EPU_Stations:str = 'AJOUT_PDET_EPU_DG03_STATIONS.shp',
+                 Ponderation_csv:str = 'Ponderation.csv',
+                 Vulnerability_csv:str = 'Vulnerability.csv',
+                 Intermediate_csv:str = 'Intermediate.csv'
                                                          ) -> None:
 
         self.old_dir:Path    = Path(os.getcwd())
@@ -169,11 +171,11 @@ 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.POINTS_CSV        = self.IN_CSV / "Intermediate.csv"
-        # self.PONDERATION_CSV   = self.IN_CSV / "Ponderation.csv"
+        self.VULNERABILITY_CSV = self.IN_CSV / Vulnerability_csv
+        self.POINTS_CSV        = self.IN_CSV / Intermediate_csv
+        self.PONDERATION_CSV   = self.IN_CSV / Ponderation_csv
 
-        self._CSVs = [self.VULNERABILITY_CSV, self.POINTS_CSV] #, self.PONDERATION_CSV]
+        self._CSVs = [self.VULNERABILITY_CSV, self.POINTS_CSV] 
         self._GPKGs= [self.CAPA_WALLOON, self.PICC_WALLOON]
         self._GDBs = [self.ORIGINAL_GDB]
         self._SHPs = [self.CE_IGN_TOP10V, self.EPU_STATIONS]
@@ -1072,79 +1074,6 @@ def data_modification(layer:str,
         logging.error("skipped" + str(layer) + "due to no polygon in the study area")
         return "skipped" + str(layer) + "due to no polygon in the study area"
 
-def vector_to_raster(layer:str,
-                     manager:Accept_Manager,
-                     attribute:str,
-                     pixel_size:float):
-    """
-    Convert a vector layer to a raster tiff file
-
-    :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
-    :param attribute: the attribute to rasterize
-    :param pixel_size: the pixel size of the raster
-
-    """
-
-    old_dir = os.getcwd()
-
-    layer = str(layer)
-
-    vector_input = str(manager.TMP_CODEVULNE / (layer + EXTENT))
-    extent = str(manager.SA)
-    attribute = str(attribute)
-    pixel_size = float(pixel_size)
-
-    out_file = manager.TMP_RASTERS / attribute / (layer + ".tiff")
-
-    if out_file.exists():
-        os.remove(out_file)
-
-    out_file = str(out_file)
-
-    NoData_value = 0
-
-    extent_ds:ogr.DataSource = ogr.Open(extent)
-    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))
-    y_min = float(int(y_min))
-    y_max = float(np.ceil(y_max))
-
-    # Open the data sources and read the extents
-    source_ds:ogr.DataSource = ogr.Open(vector_input)
-    if source_ds is None:
-        logging.error(f"Could not open the data source {layer}")
-        return
-    source_layer = source_ds.GetLayer()
-
-    # Create the destination data source
-    x_res = int((x_max - x_min) / pixel_size)
-    y_res = int((y_max - y_min) / pixel_size)
-    target_ds:gdal.Driver = gdal.GetDriverByName('GTiff').Create(out_file,
-                                                     x_res, y_res, 1,
-                                                     gdal.GDT_Byte,
-                                                     options=["COMPRESS=LZW"])
-
-    target_ds.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size))
-    srs = osr.SpatialReference()
-    srs.ImportFromEPSG(31370)
-    target_ds.SetProjection(srs.ExportToWkt())
-
-    band = target_ds.GetRasterBand(1)
-    band.SetNoDataValue(NoData_value)
-
-    # Rasterize the areas
-    gdal.RasterizeLayer(target_ds, [1], 
-                        source_layer, 
-                        options=["ATTRIBUTE="+attribute, 
-                                 "ALL_TOUCHED=TRUE"])
-    target_ds = None
-
 def compute_vulnerability(manager:Accept_Manager):
     """
     Compute the vulnerability for the Study Area
@@ -1160,51 +1089,71 @@ def compute_vulnerability(manager:Accept_Manager):
 
     logging.info("Number of files",len(rasters_vuln))
 
-    ds:gdal.Dataset = gdal.Open(str(rasters_vuln[0]))
+    ds:gdal.Dataset = gdal.OpenEx(str(rasters_vuln[0]), gdal.GA_ReadOnly, open_options=["SPARSE_OK=TRUE"])
 
-    tmp_vuln = np.array(ds.GetRasterBand(1).ReadAsArray())
+    tmp_vuln = ds.GetRasterBand(1)
 
-    x, y = tmp_vuln.shape
+    # REMARK: The XSize and YSize are the number of columns and rows
+    col, row = tmp_vuln.XSize, tmp_vuln.YSize
 
     logging.info("Computing Vulnerability")
 
-    array_vuln = np.ones((x, y), dtype=np.int8)
-    array_code = np.ones((x, y), dtype=np.int8)
+    array_vuln = np.ones((row, col), dtype=np.int8)
 
     # 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, loccode, array_vuln, array_code):
+    def update_arrays_jit(tmp_vuln, array_vuln):
         for i in range(tmp_vuln.shape[0]):
             for j in range(tmp_vuln.shape[1]):
                 if tmp_vuln[i, j] >= array_vuln[i, j]:
                     array_vuln[i, j] = tmp_vuln[i, j]
-                    array_code[i, j] = loccode
 
-        return array_vuln, array_code
-        
-    for i in tqdm(range(len(rasters_vuln)), 'Computing Vulnerability : '):
-        logging.info("Computing layer {} / {}".format(i, len(rasters_vuln)))
-        ds  = gdal.Open(str(rasters_vuln[i]))
+        return array_vuln
 
-        tmp_vuln = ds.GetRasterBand(1).ReadAsArray()
-
-        loccode = vuln_csv.get_vulnerability_code(rasters_vuln[i].stem)
+    @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
 
-        # We use the jit
-        update_arrays_jit(tmp_vuln, loccode, array_vuln, array_code)
+        return array_vuln
+    
+    for i in tqdm(range(len(rasters_vuln)), 'Computing Vulnerability : '):
+        logging.info("Computing layer {} / {}".format(i, len(rasters_vuln)))
+        
+        locvuln = vuln_csv.get_vulnerability_level(rasters_vuln[i].stem)
 
-    # ij = np.where(array_vuln == 0)
-    # array_vuln[ij] = 1
-    # array_code[ij] = 1
+        if locvuln == 1:
+            logging.info("No need to apply the matrice, the vulnerability is 1 which is the lower value")
+            continue
+    
+        if rasters_vuln[i].with_suffix('.npz').exists():
+            ij_npz = np.load(rasters_vuln[i].with_suffix('.npz'))
+            ii = ij_npz['row']
+            jj = ij_npz['col']
+            # We use the jit
+            update_arrays_jit_coo(ii, jj, locvuln, array_vuln)
+        
+        else:
+            ds  = gdal.OpenEx(str(rasters_vuln[i]), open_options=["SPARSE_OK=TRUE"])
+            tmp_vuln = ds.GetRasterBand(1).ReadAsArray()
+            # We use the jit
+            update_arrays_jit(tmp_vuln, array_vuln)
 
     logging.info("Saving the computed vulnerability")
     dst_filename= str(manager.SA_VULN)
     y_pixels, x_pixels = array_vuln.shape  # number of pixels in x
 
     driver = gdal.GetDriverByName('GTiff')
-    dataset = driver.Create(dst_filename, x_pixels, y_pixels, gdal.GDT_Byte, 1, options=["COMPRESS=LZW"])
+    dataset = driver.Create(dst_filename, 
+                            x_pixels, y_pixels, 
+                            gdal.GDT_Byte, 
+                            1, 
+                            options=["COMPRESS=LZW"])
+    
     dataset.GetRasterBand(1).WriteArray(array_vuln.astype(np.int8))
     # follow code is adding GeoTranform and Projection
     geotrans = ds.GetGeoTransform()  # get GeoTranform from existed 'data0'
@@ -1214,11 +1163,83 @@ def compute_vulnerability(manager:Accept_Manager):
     dataset.FlushCache()
     dataset = None
 
+    logging.info("Computed Vulnerability for the Study Area - Done")
+
+def compute_code(manager:Accept_Manager):
+    """
+    Compute the code for the Study Area
+
+    This function **will not modify** the data by the removed buildings/scenarios.
+
+    :param dirsnames: the Dirs_Names object from the calling function
+    """
+
+    vuln_csv = Vulnerability_csv(manager.VULNERABILITY_CSV)
+
+    rasters_code = manager.get_files_in_rasters_code()
+
+    logging.info("Number of files",len(rasters_code))
+
+    ds:gdal.Dataset = gdal.OpenEx(str(rasters_code[0]), gdal.GA_ReadOnly, open_options=["SPARSE_OK=TRUE"])
+
+    tmp_code = ds.GetRasterBand(1)
+
+    # REMARK: The XSize and YSize are the number of columns and rows
+    col, row = tmp_code.XSize, tmp_code.YSize
+
+    logging.info("Computing Code")
+
+    array_code = np.ones((row, col), dtype=np.int8)
+
+    # 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]):
+                if tmp_code[i, j] >= array_code[i, j]:
+                    array_code[i, j] = loccode
+
+        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
+
+        return array_code
+    
+    for i in tqdm(range(len(rasters_code)), 'Computing Code : '):
+        logging.info("Computing layer {} / {}".format(i, len(rasters_code)))
+        
+        loccode = vuln_csv.get_vulnerability_code(rasters_code[i].stem)
+    
+        if rasters_code[i].with_suffix('.npz').exists():
+            ij_npz = np.load(rasters_code[i].with_suffix('.npz'))
+            ii = ij_npz['row']
+            jj = ij_npz['col']
+            # We use the jit
+            update_arrays_jit_coo(ii, jj, loccode, array_code)
+        
+        else:
+            ds  = gdal.OpenEx(str(rasters_code[i]), open_options=["SPARSE_OK=TRUE"])
+            tmp_code = ds.GetRasterBand(1).ReadAsArray()
+            # We use the jit
+            update_arrays_jit(tmp_code, loccode, array_code)
+
     logging.info("Saving the computed codes")
     dst_filename= str(manager.SA_CODE)
     y_pixels, x_pixels = array_code.shape  # number of pixels in x
     driver = gdal.GetDriverByName('GTiff')
-    dataset = driver.Create(dst_filename, x_pixels, y_pixels, gdal.GDT_Byte, 1, options=["COMPRESS=LZW"])
+    dataset = driver.Create(dst_filename, 
+                            x_pixels, y_pixels, 
+                            gdal.GDT_Byte, 
+                            1, 
+                            options=["COMPRESS=LZW"])
+    
     dataset.GetRasterBand(1).WriteArray(array_code.astype(np.int8))
     # follow code is adding GeoTranform and Projection
     geotrans = ds.GetGeoTransform()  # get GeoTranform from existed 'data0'
@@ -1228,7 +1249,7 @@ def compute_vulnerability(manager:Accept_Manager):
     dataset.FlushCache()
     dataset = None
 
-    logging.info("Computed Vulnerability for the Study Area - Done")
+    logging.info("Computed Code for the Study Area - Done")
 
 def compute_vulnerability4scenario(manager:Accept_Manager):
     """ Compute the vulnerability for the scenario
@@ -1284,7 +1305,7 @@ def compute_vulnerability4scenario(manager:Accept_Manager):
     dataset.FlushCache()
     dataset = None
 
-    logging.info("Computed Vulnerability for the scenario")
+    logging.info("Computed Vulnerability and code for the scenario")
 
 def match_vulnerability2sim(inRas:Path, outRas:Path, MODREC:Path):
     """
@@ -1408,8 +1429,12 @@ def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1.):
     x_res = int((x_max - x_min) / pixel_size)
     y_res = int((y_max - y_min) / pixel_size)
 
-    target_ds = gdal.GetDriverByName('GTiff').Create(raster_fn, x_res, y_res, 1, gdal.GDT_Byte,
-                                                     options=["COMPRESS=LZW"])
+    target_ds = gdal.GetDriverByName('GTiff').Create(raster_fn, 
+                                                     x_res, y_res, 
+                                                     1, 
+                                                     gdal.GDT_Byte,
+                                                     options=["COMPRESS=LZW", 
+                                                              'SPARSE_OK=TRUE'])
 
     target_ds.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size))
     srs = osr.SpatialReference()
@@ -1425,3 +1450,85 @@ def shp_to_raster(vector_fn:str, raster_fn:str, pixel_size:float = 1.):
                         options=["ALL_TOUCHED=TRUE"])
     target_ds = None
     vector_fn = raster_fn = None
+
+def vector_to_raster(layer:str,
+                     manager:Accept_Manager,
+                     attribute:str,
+                     pixel_size:float,
+                     convert_to_sparse:bool = True):
+    """
+    Convert a vector layer to a raster tiff file
+
+    :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
+    :param attribute: the attribute to rasterize
+    :param pixel_size: the pixel size of the raster
+
+    """
+
+    layer = str(layer)
+
+    vector_input = str(manager.TMP_CODEVULNE / (layer + EXTENT))
+    extent = str(manager.SA)
+    attribute = str(attribute)
+    pixel_size = float(pixel_size)
+
+    out_file = manager.TMP_RASTERS / attribute / (layer + ".tiff")
+
+    if out_file.exists():
+        os.remove(out_file)
+
+    out_file = str(out_file)
+
+    NoData_value = 0
+
+    extent_ds:ogr.DataSource = ogr.Open(extent)
+    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))
+    y_min = float(int(y_min))
+    y_max = float(np.ceil(y_max))
+
+    # Open the data sources and read the extents
+    source_ds:ogr.DataSource = ogr.Open(vector_input)
+    if source_ds is None:
+        logging.error(f"Could not open the data source {layer}")
+        return
+    source_layer = source_ds.GetLayer()
+
+    # Create the destination data source
+    x_res = int((x_max - x_min) / pixel_size)
+    y_res = int((y_max - y_min) / pixel_size)
+    target_ds:gdal.Driver = gdal.GetDriverByName('GTiff').Create(out_file,
+                                                     x_res, y_res, 1,
+                                                     gdal.GDT_Byte,
+                                                     options=["COMPRESS=DEFLATE",
+                                                              'SPARSE_OK=TRUE',])
+
+    target_ds.SetGeoTransform((x_min, pixel_size, 0, y_max, 0, -pixel_size))
+    srs = osr.SpatialReference()
+    srs.ImportFromEPSG(31370)
+    target_ds.SetProjection(srs.ExportToWkt())
+
+    band = target_ds.GetRasterBand(1)
+    band.SetNoDataValue(NoData_value)
+
+    # Rasterize the areas
+    gdal.RasterizeLayer(target_ds, [1], 
+                        source_layer, 
+                        options=["ATTRIBUTE="+attribute, 
+                                 "ALL_TOUCHED=TRUE"])
+    
+    if convert_to_sparse:
+        # 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))
+
+    target_ds = None
+
+    return 0

wolfhece/apps/version.py

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

wolfhece/wolf_array.py

@@ -4771,6 +4771,12 @@ class WolfArray(Element_To_Draw, header_wolf):
         elif arr.dtype == np.float64:
             arr_type = gdal.GDT_Float64
             nullvalue = self.nullvalue
+        elif arr.dtype == np.int8:
+            arr_type = gdal.GDT_Byte
+            nullvalue = int(self.nullvalue)
+        elif arr.dtype == np.int16:
+            arr_type = gdal.GDT_Int16
+            nullvalue = int(self.nullvalue)
         else:
             arr_type = gdal.GDT_Int32
             nullvalue = int(self.nullvalue)
@@ -5024,11 +5030,16 @@ class WolfArray(Element_To_Draw, header_wolf):
             elif self.array.dtype == np.int32:
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER
             elif self.array.dtype == np.uint8:
-                logging.warning(_('Conversion of uint8 to int8'))
+                logging.warning(_('***************************************************'))
+                logging.warning(_(' Conversion of uint8 to int8'))
+                logging.warning(_(' If you save this file, it will be converted to int8'))
+                logging.warning(_('***************************************************'))
                 self.array = self.array.astype(np.int8)
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER8
             elif self.array.dtype == np.int8:
                 self.wolftype = WOLF_ARRAY_FULL_INTEGER8
+            elif self.array.dtype == np.int16:
+                self.wolftype = WOLF_ARRAY_FULL_INTEGER16
 
         except:
             logging.warning(_('Error during importing tif file'))

{wolfhece-2.1.27.dist-info → wolfhece-2.1.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.1.27
+Version: 2.1.28
 Author-email: Pierre Archambeau <pierre.archambeau@uliege.be>
 License: AGPL-v3 License
 Project-URL: Homepage, https://uee.uliege.be/hece

{wolfhece-2.1.27.dist-info → wolfhece-2.1.28.dist-info}/RECORD

@@ -48,7 +48,7 @@ wolfhece/rain_SPWMI.py,sha256=YqsF-yFro3y_a6MfVRFfr-Rxi7NR1gl_i8VX7scmzes,13548
 wolfhece/test_Results2DGPU.py,sha256=NOJ_hFXrcLSQXS1dtsqXRQltqIZtDSHMz_EgAJ2_FHU,307
 wolfhece/textpillow.py,sha256=zEfLrKhfCDyMaVuQOUjHqz6MGKeQ4aewMxOsWi5-wKI,13832
 wolfhece/tools_mpl.py,sha256=q8Yc4aukPPiUcEzREvZRM_em67XqXaahdoaNt0DETfE,266
-wolfhece/wolf_array.py,sha256=fvZLKrQkglduI7m82C2c_cBPMhKwrBcHPKTNcB8DSEg,355054
+wolfhece/wolf_array.py,sha256=ViEJkKxOBLjiPFZy01wcC7q4djBQcgl5ptRXWAMfcJ0,355676
 wolfhece/wolf_hist.py,sha256=JpRXvzJLUP-RkSkvth3DQWglgTMFI2ZEUDb4RYOfeeI,3284
 wolfhece/wolf_texture.py,sha256=llQ7aV8scWXIkhpri9XjaPejzoBJsGfsln2ZnlRbFkU,16270
 wolfhece/wolf_tiles.py,sha256=F2JsJHdAP8fIffNJdG_J26bonCIRtIwMmxKFqdSCRDA,10088
@@ -56,13 +56,13 @@ wolfhece/wolf_vrt.py,sha256=un5CKzAUmzSsjLXK7YLnQEWz8FLoafXJs8oqUvS_-h0,10271
 wolfhece/wolf_zi_db.py,sha256=Ok0MxQYZMMLRJN1QY-HSplLhUzzb6gkXgBQ3ihhLQHk,12669
 wolfhece/wolfresults_2D.py,sha256=wF-wIyqpTrUJX_fT-QCVuNxLZCgUsqK9ptGz8izpyIQ,165590
 wolfhece/xyz_file.py,sha256=aQOcTHkHRhXHxL_WxTHwzygp6e47San7SHSpxKQU0dw,5457
-wolfhece/acceptability/Parallels.py,sha256=IFXTuxgf8y2S8RTRZXr5DvPLB8zQjyEIKYKc56FehVo,3520
+wolfhece/acceptability/Parallels.py,sha256=wpCdwkqR6PAFeRkV5TvSSL33Vf368j-bvYcl7D1Y-sc,3695
 wolfhece/acceptability/__init__.py,sha256=hfgoPKLDpX7drN1Vpvux-_5Lfyc_7feT2C2zQr5v-Os,258
-wolfhece/acceptability/acceptability.py,sha256=06xhkvHIB2xPsVl1e8X0i9UDnSD3Bhf8mVLopyLgsfk,20115
+wolfhece/acceptability/acceptability.py,sha256=pXGsV8Rga-YtILhfsE90PjVfsbRl_z7RXLB8537dSfA,21882
 wolfhece/acceptability/acceptability1.py,sha256=rf1Bu2JuyOPwMxvez7z5vCXrePAV486hyVM5g1f40g4,13045
 wolfhece/acceptability/acceptability_gui.py,sha256=zzbHd_e90fLhbgrdBlnWmBWBO8ZBwb8vikhl-2Rdy0M,12020
 wolfhece/acceptability/cli.py,sha256=pIh9hIbM5RQFh3EBQJB2jWJ8F2M4l-D6qGoewXROE1M,7102
-wolfhece/acceptability/func.py,sha256=WkiFQyHq6vYC9WI3m9Dr6Ub4lpfEJ3TtrQOmd3j5mjs,53966
+wolfhece/acceptability/func.py,sha256=E2zPgFRm3x5u6PDt6y8nUCyXL5eCHzbwHMIQoj8Bg8U,58238
 wolfhece/apps/ManageParams.py,sha256=heg5L4fMn0ettR7Bad_Q680o_JWnTbe3WFkL_9IziAk,312
 wolfhece/apps/Optimisation_hydro.py,sha256=mHazBazTUGyxPbHPXhaQim8vqIeOOuKPjH0B48VWduA,374
 wolfhece/apps/WolfPython.png,sha256=K3dcbeZUiJCFNwOAAlGMaRGLJ56yM8WD2I_0bk0xT1g,104622
@@ -73,7 +73,7 @@ wolfhece/apps/check_install.py,sha256=jrKR-njqnpIh6ZJqvP6KbDUPVCfwTNQj4glQhcyzs9
 wolfhece/apps/curvedigitizer.py,sha256=avWERHuVxPnJBOD_ibczwW_XG4vAenqWS8W1zjhBox8,4898
 wolfhece/apps/isocurrent.py,sha256=4XnNWPa8mYUK7V4zdDRFrHFIXNG2AN2og3TqWKKcqjY,3811
 wolfhece/apps/splashscreen.py,sha256=LkEVMK0eCc84NeCWD3CGja7fuQ_k1PrZdyqD3GQk_8c,2118
-wolfhece/apps/version.py,sha256=fCJirDzHsyPl2cZap4mimCySWPCBCEPVShHrl_tobLg,388
+wolfhece/apps/version.py,sha256=QLSk_f340_pnubYC3LzPucHpjfHthXJURv8frE1CoG0,388
 wolfhece/apps/wolf.py,sha256=gqfm-ZaUJqNsfCzmdtemSeqLw-GVdSVix-evg5WArJI,293
 wolfhece/apps/wolf2D.py,sha256=gWD9ee2-1pw_nUxjgRaJMuSe4kUT-RWhOeoTt_Lh1mM,267
 wolfhece/apps/wolf_logo.bmp,sha256=ruJ4MA51CpGO_AYUp_dB4SWKHelvhOvd7Q8NrVOjDJk,3126
@@ -279,8 +279,8 @@ wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=yGbU_JsF56jsmms0gh7mxa
 wolfhece/ui/wolf_times_selection_comparison_models.py,sha256=wCxGRnE3kzEkWlWA6-3X8ADOFux_B0a5QWJ2GnXTgJw,4709
 wolfhece/wintab/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/wintab/wintab.py,sha256=8A-JNONV6ujgsgG3lM5Uw-pVgglPATwKs86oBzzljoc,7179
-wolfhece-2.1.27.dist-info/METADATA,sha256=C3iPLvGGk5G130CzmuuSnygz-PX_Rn2ZtfJNQglil8M,2327
-wolfhece-2.1.27.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
-wolfhece-2.1.27.dist-info/entry_points.txt,sha256=MAG6NrF64fcxiVNb2g1JPYPGcn9C0HWtqqNurB83oX0,330
-wolfhece-2.1.27.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.1.27.dist-info/RECORD,,
+wolfhece-2.1.28.dist-info/METADATA,sha256=h_mkaZJwq29PG6UesnWcQYnBewET8t47eBJvEMI3WJQ,2327
+wolfhece-2.1.28.dist-info/WHEEL,sha256=YiKiUUeZQGmGJoR_0N1Y933DOBowq4AIvDe2-UIy8E4,91
+wolfhece-2.1.28.dist-info/entry_points.txt,sha256=MAG6NrF64fcxiVNb2g1JPYPGcn9C0HWtqqNurB83oX0,330
+wolfhece-2.1.28.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.1.28.dist-info/RECORD,,

{wolfhece-2.1.27.dist-info → wolfhece-2.1.28.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: setuptools (71.0.2)
 Root-Is-Purelib: true
 Tag: py3-none-any