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

wolfhece/PyPalette.py

@@ -24,6 +24,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
     nb:int
     colors:np.array
     colorsflt:np.array
+    colorsuint8:np.array
 
     def __init__(self, parent=None, title=_('Colormap'),w=100,h=500,nseg=1024):
 
@@ -45,17 +46,32 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         LinearSegmentedColormap.__init__(self,'wolf',{},nseg)
         self.set_bounds()
 
+    @property
+    def colormin_uint8(self):
+        return self.colormin.astype(np.uint8)*255
+    
+    @property
+    def colormax_uint8(self):
+        return self.colormax.astype(np.uint8)*255
+
     def get_colors_f32(self):
 
         colors = self.colorsflt[:,:3].astype(np.float32)
 
         return colors
+    
+    def get_colors_uint8(self):
+            
+        colors = self.colorsflt[:,:3].astype(np.uint8) * 255
+
+        return colors
 
     def set_bounds(self):
         self.set_under(tuple(self.colormin))
         self.set_over(tuple(self.colormax))
 
-    def get_rgba(self,x):
+    def get_rgba(self, x:np.ndarray):
+        """Récupération de la couleur en fonction de la valeur x"""
 
         dval=self.values[-1]-self.values[0]
         if dval==0.:
@@ -63,23 +79,24 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         xloc = (x-self.values[0])/dval
 
         if self.interval_cst:
-            rgba = np.ones((xloc.shape[0],xloc.shape[1],4))
+            rgba = np.ones((xloc.shape[0],xloc.shape[1],4), dtype=np.uint8)
 
             ij = np.where(xloc<0.)
-            rgba[ij[0],ij[1]] = self.colormin
+            rgba[ij[0],ij[1]] = self.colormin_uint8
             ij = np.where(xloc>=1.)
-            rgba[ij[0],ij[1]] = self.colormax
+            rgba[ij[0],ij[1]] = self.colormax_uint8
 
             for i in range(self.nb-1):
                 val1 = (self.values[i]-self.values[0])/dval
                 val2 = (self.values[i+1]-self.values[0])/dval
-                c1   = self.colorsflt[i]
+                # c1   = self.colorsflt[i]
+                c1   = self.colorsuint8[i]
                 ij = np.where((xloc>=val1) & (xloc<val2))
                 rgba[ij[0],ij[1]] = c1
 
             return rgba
         else:
-            return self(xloc)
+            return self(xloc, bytes=True)
 
     def export_palette_matplotlib(self,name):
         cmaps = OrderedDict()
@@ -110,7 +127,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
 
         return self.nb,self.values,self._segmentdata,self.colorsflt
 
-    def distribute_values(self, minval=-99999, maxval=-99999, step=0, wx_permitted=True):
+    def distribute_values(self, minval:float=-99999, maxval:float=-99999, step=0, wx_permitted=True):
         """ Distribution des valeurs de la palette 
         
         :param minval: valeur minimale
@@ -460,8 +477,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
                     self.colors[curcol,1] = colors[curcol,1]
                     self.colors[curcol,2] = colors[curcol,2]
                     self.colors[curcol,3] = colors[curcol,3]
-
-
+        
         self.fill_segmentdata()
 
     def defaultgray(self):
@@ -469,7 +485,6 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         self.nb=2
         self.values = np.asarray([0.,1.])
         self.colors = np.asarray([[0,0,0,255],[255,255,255,255]],dtype=np.int32)
-        self.colorsflt = np.asarray([[0.,0.,0.,1.],[1.,1.,1.,1.]],dtype=np.float64)
 
         self.fill_segmentdata()
 
@@ -477,6 +492,7 @@ class wolfpalette(wx.Frame,LinearSegmentedColormap):
         """Mise à jour de la palatte de couleurs"""
 
         self.colorsflt = self.colors.astype(float)/255.
+        self.colorsuint8 = self.colors.astype(np.uint8)
 
         dval=self.values[-1]-self.values[0]
 

wolfhece/acceptability/Parallels.py

@@ -1,4 +1,5 @@
-from .func import gpd_clip, data_modification, vector_to_raster, Comp_Vulnerability, match_vuln_modrec, VulMod, shp_to_raster
+from .func import clip_layer, data_modification, vector_to_raster, compute_vulnerability, match_vulnerability2sim, compute_acceptability, shp_to_raster, Accept_Manager
+import geopandas as gpd
 import multiprocessing
 from functools import partial
 import os
@@ -7,7 +8,7 @@ from pathlib import Path
 def parallel_gpd_clip(layer:list[str], 
                       file_path:str, 
                       Study_Area:str, 
-                      output_gpkg:str, 
+                      output_dir:str, 
                       number_procs:int = 1):
     """ 
     Clip the layers to the study area.
@@ -19,31 +20,28 @@ def parallel_gpd_clip(layer:list[str],
     :param layer: List of layers to clip
     :param file_path: The path to the file
     :param Study_Area: The study area
-    :param output_gpkg: The output geopackage
+    :param output_dir: The output directory where the clipped layers are stored
     :param number_procs: The number of processors to use
 
     """
     file_path = str(file_path)
     Study_Area = str(Study_Area)
-    output_gpkg = str(output_gpkg)
+    output_dir = str(output_dir)
 
     if number_procs == 1:
 
         for curlayer in layer:
-            gpd_clip(curlayer, file_path, Study_Area, output_gpkg)
+            clip_layer(curlayer, file_path, Study_Area, output_dir)
 
     else:
         pool = multiprocessing.Pool(processes=number_procs)
-        prod_x=partial(gpd_clip,
+        prod_x=partial(clip_layer,
                     file_path=file_path,
                     Study_Area=Study_Area,
-                    geopackage=output_gpkg)
+                    output_dir=output_dir)
         result_list = pool.map(prod_x, layer)
-        print(result_list)
 
-def parallel_v2r(layers:list[str], 
-                 study_area_database:Path, 
-                 extent:Path, 
+def parallel_v2r(manager:Accept_Manager,
                  attribute:str, 
                  pixel:float,
                  number_procs:int = 1):
@@ -54,9 +52,7 @@ def parallel_v2r(layers:list[str],
 
     :remark: It is permitted to execute this function in multiprocessing because we write separate files.
 
-    :param layers: List of layers to convert to raster.
-    :param study_area_database: The Path to the study area
-    :param extent: The extent of the study area
+    :param manager: The Accept_Manager object
     :param attribute: The attribute to convert to raster
     :param pixel: The pixel size of the raster
     :param number_procs: The number of processors to use
@@ -64,18 +60,47 @@ def parallel_v2r(layers:list[str],
     """
     
     attribute = str(attribute)
+    layers = manager.get_layers_in_codevulne()
 
     if number_procs == 1:
         for curlayer in layers:
-            vector_to_raster(curlayer, study_area_database, extent, attribute, pixel)
+            vector_to_raster(curlayer, manager, attribute, pixel)
     else:
         pool = multiprocessing.Pool(processes=number_procs)
         prod_x=partial(vector_to_raster,
-                       vector_input=study_area_database,
-                       extent=extent, 
+                       manager=manager, 
                        attribute=attribute, 
-                       pixel_size=pixel) # prod_x has only one argument x (y is fixed to 10)
+                       pixel_size=pixel) 
+        
+        result_list = pool.map(prod_x, layers)
+
+def parallel_datamod(manager:Accept_Manager, 
+                     picc:gpd.GeoDataFrame,
+                     capa:gpd.GeoDataFrame,
+                     number_procs:int = 1):
+    """ 
+    Apply the data modification to the layers.
+
+    Process the layers in parallel.
+
+    :remark: It is permitted to execute this function in multiprocessing because we write separate files.
+
+    :param manager: The Accept_Manager object
+    :param number_procs: The number of processors to use
+
+    """
+    
+    layers = manager.get_layers_in_clipgdb()
+
+    if number_procs == 1:
+        for curlayer in layers:
+            data_modification(curlayer, manager, picc, capa)
+    else:
+        pool = multiprocessing.Pool(processes=number_procs)
+        prod_x=partial(data_modification,
+                          manager=manager,
+                          picc=picc, 
+                          capa=capa) 
         
         result_list = pool.map(prod_x, layers)
-        print(result_list)