wolfhece 2.2.38__py3-none-any.whl → 2.2.40__py3-none-any.whl

wolfhece/PyPalette.py

@@ -653,7 +653,6 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.colors[2, :] = [255, 0, 0, 255]   # Rouge
         self.fill_segmentdata()
 
-
     def set_values_colors(self,
                           values: typing.Union[list[float], np.ndarray],
                           colors: typing.Union[list[tuple[int]], np.ndarray]):
@@ -698,6 +697,16 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
 
         self.fill_segmentdata()
 
+    def set_values(self,
+                   values: typing.Union[list[float], np.ndarray]):
+        """ Mise à jour des valeurs de la palette """
+
+        assert len(values) == self.nb, "Length of values must match the number of colors"
+
+        self.values = np.asarray(values, dtype=np.float64)
+
+        self.fill_segmentdata()
+
     def defaultgray(self):
         """Palette grise par défaut dans WOLF"""
 
@@ -882,7 +891,8 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.nb = 2
         self.values = np.asarray([np.min(array), np.max(array)], dtype=np.float64)
         self.colors = np.asarray([[255, 255, 255, 255], [0, 0, 255, 255]], dtype=np.int32)
-        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
+        self.colorsflt = self.colors.astype(float)/255.
+        # self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
 
         self.fill_segmentdata()
 
@@ -892,7 +902,8 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.nb = 2
         self.values = np.asarray([np.min(array), np.max(array)], dtype=np.float64)
         self.colors = np.asarray([[255, 255, 255, 255], [255, 0, 0, 255]], dtype=np.int32)
-        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
+        self.colorsflt = self.colors.astype(float)/255.
+        # self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
 
         self.fill_segmentdata()
 
@@ -902,6 +913,17 @@ class wolfpalette(wx.Frame, LinearSegmentedColormap):
         self.nb = 2
         self.values = np.asarray([0., 1.], dtype=np.float64)
         self.colors = np.asarray([[255, 255, 255, 255], [0, 0, 255, 255]], dtype=np.int32)
-        self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
+        self.colorsflt = self.colors.astype(float)/255.
+        # self.colorsflt = np.asarray([[0., 0., 0., 1.], [1., 1., 1., 1.]], dtype=np.float64)
+
+        self.fill_segmentdata()
+
+    def defaultblue3(self):
+        """Remplissage des valeurs de palette sur base d'une équirépartition de valeurs"""
+
+        self.nb = 3
+        self.values = np.asarray([0., 1., 10.], dtype=np.float64)
+        self.colors = np.asarray([[255, 255, 255, 255], [50, 130, 246, 255], [0, 0, 255, 255]], dtype=np.int32)
+        self.colorsflt = self.colors.astype(float)/255.
 
         self.fill_segmentdata()

wolfhece/PyParams.py

@@ -846,6 +846,39 @@ class Wolf_Param(wx.Frame):
                 dlg = wx.MessageDialog(None,'Nothing to do!')
                 dlg.ShowModal()
 
+    def compare_active_to_default(self, remove_from_active_if_same:bool = True):
+        """
+        Compare active parameters to default parameters and remove those that are the same.
+
+        :param remove_from_active_if_same: If True, remove parameters from active if they are the same as default.
+        """
+
+        for group in self.myparams_default.keys():
+            for param_name in self.myparams_default[group].keys():
+                if self.is_in_active(group, param_name):
+
+                    val_default = self.myparams_default[group][param_name][key_Param.VALUE]
+                    val_active = self.myparams[group][param_name][key_Param.VALUE]
+
+                    if val_active == val_default:
+                        if remove_from_active_if_same:
+                            # Remove from active parameters
+                            del self.myparams[group][param_name]
+                            # # Remove from property grid
+                            # if self._is_in_propperty_page(self.page_active, group, param_name):
+                            #     self.prop.DeleteProperty(group + param_name)
+                        else:
+                            logging.debug(_('Parameter {} is the same as default and will not be removed'.format(param_name)))
+
+        # Iterate through the groups and remove empty ones
+        groups_to_remove = []
+        for group in self.myparams.keys():
+            if not self.myparams[group]:
+                groups_to_remove.append(group)
+
+        for group in groups_to_remove:
+            del self.myparams[group]
+
     @property
     def page_active(self) -> pg.PropertyGridPage:
         """ Return the active page """

wolfhece/PyPictures.py

@@ -332,7 +332,7 @@ class PictureCollection(Zones):
 
         df = pd.read_excel(excel_file, sheet_name=sheet_name)
 
-        for _, row in df.iterrows():
+        for __, row in df.iterrows():
             picture = row['Picture']
             x = row.get('X', None)
             y = row.get('Y', None)
@@ -405,7 +405,7 @@ class PictureCollection(Zones):
                     name_column = column
                     break
 
-        for _, row in gdf.iterrows():
+        for __, row in gdf.iterrows():
             picture_path = row[name_column]
             if not isinstance(picture_path, str):
                 logging.error(f"Invalid picture path in shapefile: {picture_path}")

wolfhece/PyVertex.py

@@ -1011,6 +1011,18 @@ class cloud_vertices(Element_To_Draw):
             self._updatebounds(newcloud=cloud)
         pass
 
+    def remove_vertex(self, id: int):
+        """ Remove a vertex from the cloud
+
+        :param id: id of the vertex to remove
+        """
+
+        if id in self.myvertices:
+            del self.myvertices[id]
+            self._updatebounds()
+        else:
+            logging.warning(_('Vertex with id {} not found in the cloud').format(id))
+
     def add_vertices(self, vertices:list[wolfvertex]):
         """ Add a list of vertices to the cloud """
 
@@ -1109,6 +1121,19 @@ class cloud_vertices(Element_To_Draw):
 
                     text.paint()
 
+    def reset_listogl(self):
+        """
+        Reset the OpenGL list
+
+        """
+
+        if self.gllist != 0:
+            glDeleteLists(self.gllist, 1)
+            self.gllist = 0
+
+        self.forceupdategl = True
+        self.ongoing = False
+
     def plot(self, update:bool=False, *args, **kwargs):
         """
         OpenGL plot of the cloud of vertices

wolfhece/PyVertexvectors.py

@@ -877,11 +877,26 @@ class vectorproperties:
         added = '#TRUE#' if self.used else '#FALSE#'
         f.write(added+'\n')
 
+    @property
+    def image_path(self) -> Path:
+        """ Return the path of the attached image """
+        return Path(self.attachedimage)
+
+    @image_path.setter
+    def image_path(self, value:Path):
+        """ Set the path of the attached image """
+
+        if self.attachedimage != value:
+            self.unload_image()
+
+        self.attachedimage = Path(value)
+
     def load_unload_image(self):
         """ Load an attached image """
 
         if self.imagevisible:
             if self.attachedimage is not None:
+                self.attachedimage = Path(self.attachedimage)
                 if self.attachedimage.exists():
 
                     (xmin,xmax),(ymin,ymax) = self.parent.get_bounds_xx_yy()
@@ -911,9 +926,14 @@ class vectorproperties:
                 else:
                     logging.warning('Image not found : {}'.format(self.attachedimage))
         else:
-            if self.textureimage is not None:
-                self.textureimage.unload()
-                self.textureimage = None
+            self.unload_image()
+
+    def unload_image(self):
+        """ Unload the attached image """
+
+        if self.textureimage is not None:
+            self.textureimage.unload()
+            self.textureimage = None
 
     def fill_property(self, props:Wolf_Param = None, updateOGL:bool = True):
         """
@@ -2661,13 +2681,17 @@ class vector:
 
         if self.myprop.imagevisible and self.myprop.used:
 
-            if self.myprop.textureimage is None:
-                self.myprop.load_unload_image()
+            try:
 
-            if self.myprop.textureimage is not None:
-                self.myprop.textureimage.paint()
-            else:
-                logging.warning(_('No image texture available for plot'))
+                if self.myprop.textureimage is None:
+                    self.myprop.load_unload_image()
+
+                if self.myprop.textureimage is not None:
+                    self.myprop.textureimage.paint()
+                else:
+                    logging.warning(_('No image texture available for plot'))
+            except Exception as e:
+                logging.error(_('Error while plotting image texture: {}').format(e))
 
     def plot_matplotlib(self, ax:plt.Axes | tuple[Figure, Axes] = None):
         """
@@ -3314,8 +3338,8 @@ class vector:
         k1,cums1,lengthparts1=self.get_segment(s1,is3D,adim,True)
         k2,cums2,lengthparts2=self.get_segment(s2,is3D,adim,False)
 
-        pond1 = max((cums1-s1)/lengthparts1[k1],0.)
-        pond2 = min((cums2-s2)/lengthparts2[k2],1.)
+        pond1 = max((cums1-s1)/lengthparts1[k1],0.) if lengthparts1[k1] > 0. else 0.
+        pond2 = min((cums2-s2)/lengthparts2[k2],1.) if lengthparts2[k2] > 0. else 1.
 
         v1= wolfvertex(self.myvertices[k1].x*pond1+self.myvertices[k1+1].x*(1.-pond1),
                        self.myvertices[k1].y*pond1+self.myvertices[k1+1].y*(1.-pond1),
@@ -3892,6 +3916,8 @@ class vector:
         """ Permet de retrouver un vertex sur base de son index """
         if ndx>=0 and ndx < self.nbvertices:
             return self.myvertices[ndx]
+        elif ndx < 0 and abs(ndx) <= self.nbvertices:
+            return self.myvertices[ndx + self.nbvertices]
         else:
             logging.warning(_('Index out of range'))
 
@@ -3901,15 +3927,27 @@ class vector:
             self.myvertices[ndx] = value
             self._reset_listogl()
             self.reset_linestring()
+        elif ndx < 0 and abs(ndx) <= self.nbvertices:
+            self.myvertices[ndx + self.nbvertices] = value
+            self._reset_listogl()
+            self.reset_linestring()
         else:
             logging.warning(_('Index out of range'))
 
     def __delitem__(self, ndx:int):
-        """ Permet de supprimer un vertex sur base de son index """
+        """ Permet de supprimer un vertex sur base de son index.
+
+        Exemple:
+        del myvector[0]  # Supprime le premier vertex
+        """
         if ndx>=0 and ndx < self.nbvertices:
             self.myvertices.pop(ndx)
             self._reset_listogl()
             self.reset_linestring()
+        elif ndx < 0 and abs(ndx) <= self.nbvertices:
+            self.myvertices.pop(ndx + self.nbvertices)
+            self._reset_listogl()
+            self.reset_linestring()
         else:
             logging.warning(_('Index out of range'))
 
@@ -3976,6 +4014,25 @@ class vector:
         inside = [self.polygon.contains(Point(curxy)) for curxy in xy]
 
         return inside
+    
+    def get_first_point_inside(self, xy: cloud_vertices | np.ndarray):
+        """
+        Returns the first point (x, y) inside the polygon.
+
+        :param xy: Point cloud (cloud_vertices or np.ndarray)
+        :type xy: cloud_vertices | np.ndarray
+        :return: Coordinates (x, y) of the first point found inside, or None if none
+        :rtype: tuple[float, float] | None
+        """
+        self.prepare_shapely(True)
+        
+        if isinstance(xy, cloud_vertices):
+            xy = xy.get_xyz()[:, 0:2]
+
+        for curxy in xy:
+            if self.polygon.contains(Point(curxy)):
+                return float(curxy[0]), float(curxy[1])
+        return None
 
     def split_cloud(self, cloud_to_split:cloud_vertices):
         """ Split a cloud of vertices on the vector """
@@ -4033,7 +4090,7 @@ class vector:
     def area(self):
         """ Alias for surface """
         return self.surface
-
+       
     def interpolate_coordinates(self):
         """
         Interpole les valeurs Z des vertices sur base des seules valeurs connues,
@@ -4900,6 +4957,7 @@ class zone:
         # cs.set_zones(True)
 
         interp = Interpolators(banks, cs, ds)
+        interp.export_gltf()
 
         return interp
 
@@ -6327,6 +6385,7 @@ class Zones(wx.Frame, Element_To_Draw):
                  parent=None,
                  is2D=True,
                  idx: str = '',
+                 colname: str = None,
                  plotted: bool = True,
                  mapviewer=None,
                  need_for_wx: bool = False,
@@ -6433,7 +6492,7 @@ class Zones(wx.Frame, Element_To_Draw):
 
             elif self.filename.endswith('.shp'):
                 self.is2D=False
-                self.import_shapefile(self.filename, bbox=bbox)
+                self.import_shapefile(self.filename, bbox=bbox, colname=colname)
                 only_firstlast = True # We limit the number of vertices to the first and last ones to accelerate the process
 
             elif self.filename.endswith('.gpkg'):
@@ -6497,9 +6556,9 @@ class Zones(wx.Frame, Element_To_Draw):
             self.colorize_data(colors, filled=True)
 
         if plotted and self.has_OGLContext and not self.shared:
-            logging.info(_('Preparing OpenGL lists'))
+            logging.debug(_('Preparing OpenGL lists'))
             self.prep_listogl()
-            logging.info(_('OpenGL lists ready'))
+            logging.debug(_('OpenGL lists ready'))
 
     @property
     def mynames(self) -> list[str]:
@@ -6765,9 +6824,10 @@ class Zones(wx.Frame, Element_To_Draw):
 
         logging.info(_('Importing shapefile {}'.format(fn)))
         content = gpd.read_file(fn, bbox=bbox)
-
-        self.import_GeoDataFrame(content, colname=colname)
-
+        
+        self.import_GeoDataFrame(content=content, colname=colname)        
+    
+    
     def import_GeoDataFrame(self, content:gpd.GeoDataFrame,
                             bbox:Polygon = None, colname:str = None):
         """
@@ -6792,24 +6852,24 @@ class Zones(wx.Frame, Element_To_Draw):
             idx, row = row
             keys = list(row.keys())
             if colname in keys:
-                name = row[colname]
+                name = str(row[colname])
             elif 'NAME' in keys:
-                name = row['NAME']
+                name = str(row['NAME'])
             elif 'location' in keys:
-                name = row['location'] # tuilage gdal
+                name = str(row['location']) # tuilage gdal
             elif 'Communes' in keys:
-                name = row['Communes']
+                name = str(row['Communes'])
             elif 'name' in keys:
-                name = row['name']
+                name = str(row['name'])
             elif 'MAJ_NIV3T' in keys:
                 # WALOUS
-                name = row['MAJ_NIV3T']
+                name = str(row['MAJ_NIV3T'])
             elif 'NATUR_DESC' in keys:
-                name = row['NATUR_DESC']
+                name = str(row['NATUR_DESC'])
             elif 'mun_name_f' in keys:
-                name = row['mun_name_f'].replace('[','').replace(']','').replace("'",'')
+                name = str(row['mun_name_f']).replace('[','').replace(']','').replace("'",'')
             elif 'mun_name_fr' in keys:
-                name = row['mun_name_fr']
+                name = str(row['mun_name_fr'])
             else:
                 name = str(idx)
 
@@ -7306,6 +7366,12 @@ class Zones(wx.Frame, Element_To_Draw):
         if forceparent:
             addedzone.parent = self
 
+    def create_zone(self, name:str = '') -> zone:
+        """ Create a new zone and add it to the list of zones """
+        newzone = zone(name=name, parent=self, is2D=self.is2D)
+        self.myzones.append(newzone)
+        return newzone
+
     def find_minmax(self, update=False, only_firstlast:bool=False):
         """
         Trouve les bornes des vertices pour toutes les zones et tous les vecteurs

wolfhece/PyWMS.py

@@ -216,10 +216,14 @@ def getLifeWatch(cat:Literal['None'],
     wms=WebMapService(f'https://maps.elie.ucl.ac.be/cgi-bin/mapserv72?map=/maps_server/lifewatch/mapfiles/LW_Ecotopes/latest/{cat}.map&SERVICE=wms',
                         version='1.3.0', timeout=10)
 
-    ppkm = 300
+    # _p_ixel _p_er _k_ilo_m_etre
+    ppkm = 500
+
     if w is None and h is None:
+        # Bounding dimensions width in kilometres
         real_w = (xr-xl)/1000
         real_h = (yr-yl)/1000
+        # Size in pixels of the requested area.
         w = int(real_w * ppkm)
         h = int(real_h * ppkm)
     elif w is None:
@@ -235,6 +239,8 @@ def getLifeWatch(cat:Literal['None'],
         # w = int(real_w * ppkm)
         h = int(real_h * ppkm)
 
+    # If we ask for too many pixels, well, we reduce the number
+    # of pixels we ask for (keeping the aspect ratio)
     MAXSIZE = 2048
     if w > MAXSIZE:
         pond = w / MAXSIZE
@@ -250,6 +256,8 @@ def getLifeWatch(cat:Literal['None'],
                     #    styles=['default'],
                        srs='EPSG:31370',
                        bbox=(xl,yl,xr,yr),
+                       # Width/Height of map output, in pixels.
+                       # See: https://docs.geoserver.org/stable/en/user/services/wms/reference.html#getmap
                        size=(w,h),
                        format='image/png',
                        transparent=False)
@@ -540,41 +548,49 @@ def get_Alaro_legend(layer:str):
     """
     import requests
     from io import BytesIO
-    layers = ['10_m_u__wind_component',
-                         '10_m_v__wind_component',
-                         '2_m_Max_temp_since_ppp',
-                         '2_m_Min_temp_since_ppp',
-                         '2_m_dewpoint_temperature',
-                         '2_m_temperature',
-                         '2m_Relative_humidity',
-                         'Convective_rain',
-                         'Convective_snow',
-                         'Geopotential',
-                         'Inst_flx_Conv_Cld_Cover',
-                         'Inst_flx_High_Cld_Cover',
-                         'Inst_flx_Low_Cld_Cover',
-                         'Inst_flx_Medium_Cld_Cover',
-                         'Inst_flx_Tot_Cld_cover',
-                         'Large_scale_rain',
-                         'Large_scale_snow',
-                         'Mean_sea_level_pressure',
-                         'Relative_humidity',
-                         'Relative_humidity_isobaric',
-                         'SBL_Meridian_gust',
-                         'SBL_Zonal_gust',
-                         'Specific_humidity',
-                         'Surf_Solar_radiation',
-                         'Surf_Thermal_radiation',
-                         'Surface_CAPE',
-                         'Surface_Temperature',
-                         'Surface_orography',
-                         'Temperature',
-                         'Total_precipitation',
-                         'U-velocity',
-                         'V-velocity',
-                         'Vertical_velocity',
-                         'Wet_Bulb_Poten_Temper',
-                         'freezing_level_zeroDegC_isotherm']
+    # layers = ['10_m_u__wind_component',
+    #             '10_m_v__wind_component',
+    #             '2_m_Max_temp_since_ppp',
+    #             '2_m_Min_temp_since_ppp',
+    #             '2_m_dewpoint_temperature',
+    #             '2_m_temperature',
+    #             '2m_Relative_humidity',
+    #             'Convective_rain',
+    #             'Convective_snow',
+    #             'Geopotential',
+    #             'Inst_flx_Conv_Cld_Cover',
+    #             'Inst_flx_High_Cld_Cover',
+    #             'Inst_flx_Low_Cld_Cover',
+    #             'Inst_flx_Medium_Cld_Cover',
+    #             'Inst_flx_Tot_Cld_cover',
+    #             'Large_scale_rain',
+    #             'Large_scale_snow',
+    #             'Mean_sea_level_pressure',
+    #             'Relative_humidity',
+    #             'Relative_humidity_isobaric',
+    #             'SBL_Meridian_gust',
+    #             'SBL_Zonal_gust',
+    #             'Specific_humidity',
+    #             'Surf_Solar_radiation',
+    #             'Surf_Thermal_radiation',
+    #             'Surface_CAPE',
+    #             'Surface_Temperature',
+    #             'Surface_orography',
+    #             'Temperature',
+    #             'Total_precipitation',
+    #             'U-velocity',
+    #             'V-velocity',
+    #             'Vertical_velocity',
+    #             'Wet_Bulb_Poten_Temper',
+    #             'freezing_level_zeroDegC_isotherm']
+    layers = ['2_m_temperature',
+              'Surface_Temperature',
+                'Convective_rain',
+                'Convective_snow',
+                'Large_scale_rain',
+                'Large_scale_snow',
+                'Mean_sea_level_pressure',
+                'Total_precipitation',]
 
     layers_lowercase = [l.lower() for l in layers]
     if layer.lower() not in layers_lowercase:

wolfhece/acceptability/acceptability.py

@@ -5,7 +5,7 @@ Date: 2024
 Copyright (c) 2024 University of Liege. All rights reserved.
 
 This script and its content are protected by copyright law. Unauthorized
-copying or distribution of this file, via any medium, is strictly prohibited.
+copying or distribution of this file, via any medium, is strictly prohibited.batch_creation_and_interpolation
 """
 
 from .Parallels import parallel_gpd_clip, parallel_v2r, parallel_datamod
@@ -13,6 +13,7 @@ from .func import data_modification, compute_vulnerability, compute_vulnerabilit
 from .func import match_vulnerability2sim, compute_acceptability, shp_to_raster, clip_layer
 from .func import Accept_Manager, cleaning_directory, EXTENT, Vulnerability_csv, compute_code
 
+from ..PyTranslate import _
 import pandas as pd
 import os
 from osgeo import gdal
@@ -52,6 +53,7 @@ class steps_vulnerability(Enum):
     APPLY_MODIFS = 2
     MATCH_SIMUL = 3
     APPLY_SCENARIOSVULN = 4
+    APPLY_SCENARIOSVULN_BUG = 42
 
     @classmethod
     def get_list_names(cls):
@@ -215,7 +217,7 @@ def Base_data_creation(main_dir:str = 'Data',
 
             shp:gpd.GeoDataFrame = gpd.read_file(in_file)
 
-            nb_lines, _ = shp.shape
+            nb_lines, unused = shp.shape
             if nb_lines > 0:
                 shp["Path"]  = curlayer
                 shp["Vulne"] = vulnerability_csv.get_vulnerability_level(curlayer)
@@ -391,13 +393,18 @@ def Vulnerability(main_dir:str = 'Data',
     if 4 in steps or steps_vulnerability.APPLY_SCENARIOSVULN in steps:
         if os.path.exists(manager.OUT_VULN):
             existence=False
-            existence = manager.create_vrtIfExists(manager.OUT_VULN, manager.IN_CH_SA_SC, manager.OUT_VULN_VRT, name="vuln")
-            if existence == True :
-                logging.info("Scenarios have been applied to the vulnerability matrix see _scenarios")
+            existence, fail = manager.create_vrtIfExists(manager.OUT_VULN, manager.IN_CH_SA_SC, manager.OUT_VULN_VRT, name="vuln")
+            if existence == None:
+                logging.error(_(f"Error in MNT_ files type : {fail}. Please correct them (int8 and Null value = 127)."))
+                return done.append(steps_vulnerability.APPLY_SCENARIOSVULN_BUG)
+            
+            elif existence == True :
                 manager.translate_vrt2tif(manager.OUT_VULN_VRT, manager.OUT_VULN_S)
+                logging.info("Scenarios have been applied to the vulnerability matrix see _scenarios")
         else :
             logging.error(f"The baseline vulnerability does not exist ({manager.OUT_VULN}). Please, compute first the vulnerability without scenarios vuln_.")
         done.append(steps_vulnerability.APPLY_SCENARIOSVULN)
+        
     #Delete _scenario folder is no scenario
     if os.path.isdir(manager.OUT_WITHVULN) and not os.listdir(manager.OUT_WITHVULN):
             os.rmdir(manager.OUT_WITHVULN)
@@ -429,7 +436,7 @@ def Acceptability(main_dir:str = 'Vesdre',
         river_trace = manager.OUT_MASKED_RIVER
 
     if 5 in steps or steps_acceptability.COMPUTE_WITH_SCENARIOS in steps:
-        river_trace = manager.wich_river_trace()
+        river_trace = manager.wich_river_trace(True)
         change_vuln_files = [Path(a) for a in glob.glob(str(manager.IN_CH_SA_SC / "vuln_*.tif")) + glob.glob(str(manager.IN_CH_SA_SC / "vuln_*.tiff"))]
         if len(change_vuln_files) != 0:
             VulneToCompute.append(manager.OUT_VULN_Stif)
@@ -563,8 +570,8 @@ def Acceptability(main_dir:str = 'Vesdre',
             assert len(pond) == len(return_periods), "The number of ponderations is not equal to the number of return periods"
 
             # Initialize the combined acceptability matrix -- Ponderate mean of the local acceptability
-            comb = np.zeros(part_accept[return_periods[-1]].shape, dtype=np.float32)
-
+            comb = np.zeros(part_accept[return_periods[0]].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"