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

wolfhece/acceptability/acceptability_gui.py

@@ -7,80 +7,36 @@ Copyright (c) 2025 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.
 """
-import wx
-import numpy as np
-import logging
-import subprocess
-import shutil
-import os
-import geopandas as gpd
-import pandas as pd
-import matplotlib.pyplot as plt
-from matplotlib.figure import Figure
 from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as FigureCanvas
 from matplotlib.backends.backend_wxagg import NavigationToolbar2WxAgg as NavigationToolbar2Wx
+from matplotlib.figure import Figure
+from osgeo import gdal, osr
 from pathlib import Path
 from scipy.ndimage import label
-from gettext import gettext as _
-import rasterio
 from shapely.geometry import Polygon
+import geopandas as gpd
+import logging
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+import pandas as pd
+import shutil
+import textwrap
+import wx
 
+from ..interpolating_raster import interpolating_raster
+from ..PyDraw import WolfMapViewer, draw_type
+from ..PyGui import MapManager
+from ..PyTranslate import _
+from ..Results2DGPU import wolfres2DGPU
+from ..scenario.config_manager import Config_Manager_2D_GPU
+from ..wolf_array import WolfArray, header_wolf
 from .acceptability import Base_data_creation, Database_to_raster, Vulnerability, Acceptability
 from .acceptability import steps_base_data_creation, steps_vulnerability, steps_acceptability
 from .func import Accept_Manager
-from ..wolf_array import WolfArray, header_wolf
-from ..scenario.config_manager import Config_Manager_2D_GPU
-from ..PyDraw import WolfMapViewer, draw_type
-from ..Results2DGPU import wolfres2DGPU
-from ..PyGui import MapManager
-
-BATHYMETRY_FOR_SIMULATION = "__bathymetry_after_scripts.tif"
-
-def nullvalue_for_hole(WA):
-    """
-    Sets the null value for a WolfArray to 0 (as per the convention in the interpolation routine).
-    """
-    WA.nullvalue = 0.
-    WA.set_nullvalue_in_mask()
-
-def read_export_z_bin(fn_read, fn_write, fn_laststep, type_extraction):
-    """
-    Reads the free surface altitude from a GPU simulation and exports it in binary format.
-    Inputs:
-        - fn_read_simu: the simulation file to read.
-        - fn_laststep: the folder EXTRACTED_LAST_STEP defined in acceptability.
-        - fn_write: the path to save the output in binary format.
-    """
 
-    if type_extraction == "last_step":
-        # fn_temp = os.path.join(fn_laststep, 'temp')
-        # os.makedirs(fn_temp, exist_ok=True)
-        wolfres2DGPU_test = wolfres2DGPU(fn_read)
-        #changer ici + vérifier si bien SF ou WD (comparer ;) )
-        wolfres2DGPU_test.read_oneresult(-1)
-        wd = wolfres2DGPU_test.get_h_for_block(1)
-        top = wolfres2DGPU_test.get_top_for_block(1)
-        nullvalue_for_hole(wd)
-        nullvalue_for_hole(top)
-        wd.array = wd.array + top.array
-        fn_write = fn_write.with_suffix('.bin')
-        wd.write_all(fn_write)
-        # shutil.rmtree(fn_temp)
-
-    if type_extraction == "danger_map":
-        # fn_temp = os.path.join(fn_laststep, 'temp')
-        # os.makedirs(fn_temp, exist_ok=True)
-        wolfres2DGPU_last = wolfres2DGPU(fn_read)
-        wolfres2DGPU_last.read_oneresult(-1)
-        danger_map_h = wolfres2DGPU(fn_read).danger_map_only_h(0,-1,1)
-        top = wolfres2DGPU_last.get_top_for_block(1)
-        nullvalue_for_hole(danger_map_h)
-        nullvalue_for_hole(top)
-        danger_map_h.array[danger_map_h.array != 0] += top.array[danger_map_h.array != 0]
-        fn_write = fn_write.with_suffix('.bin')
-        danger_map_h.write_all(fn_write)
-        # shutil.rmtree(fn_temp)
 
+BATHYMETRY_FOR_SIMULATION = "__bathymetry_after_scripts.tif"
 
 def riverbed_trace(fn_read_simu, fn_output, threshold, type_extraction):
     """
@@ -90,8 +46,6 @@ def riverbed_trace(fn_read_simu, fn_output, threshold, type_extraction):
         - fn_output: the location to save the riverbed trace as a .tiff file.
         - threshold: the water depth threshold above which the areas are considered riverbed.
     """
-
-
     if type_extraction == "last_step":
         wolfres2DGPU_test = wolfres2DGPU(fn_read_simu)
         wolfres2DGPU_test.read_oneresult(-1)
@@ -104,7 +58,7 @@ def riverbed_trace(fn_read_simu, fn_output, threshold, type_extraction):
         wd.write_all(Path(fn_output))
 
     if type_extraction=="danger_map":
-        wd = wolfres2DGPU(fn_read_simu) .danger_map_only_h(0,-1,1)
+        wd = wolfres2DGPU(fn_read_simu).danger_map_only_h(0,-1,1)
         wd.array[wd.array > 1000] = 0
         wd.array[wd.array > threshold] = 1
         wd.array[wd.array < threshold] = 0
@@ -130,103 +84,16 @@ def empty_folder(folder):
     else:
         print("The folder does not exist.")
 
-"""
-This script performs two main operations:
-
-1. Subtraction of two raster TIFF files:
-   - Identifies areas with building traces by subtracting the `bathymetry.tif` from simulations
-     (corresponding to 'MNT_muret_bati') from `MNT` (DEM).
-
-2. For the identified building areas (from step 1):
-   - Replace the values with those from the `MNT` (ground level), ensuring it reflects the terrain, not bathymetry values.
-
-Final Output:
-- The mask should highlight building traces with corresponding DEM (`MNT`) values ("ground") inside, and its name must start with "MNT_" and include "mask" in it.
-
-Note: the computations are perfomed with tifs .tif rasters but should be translated to .bin files in the acceptability routine
-"""
-
-#----------------------------------------------------------------------------------------------------------
-
-#1 - Soustraction bathymetry.tif (from simulations) - DEM (MNT, cfr "projet tuilage") ---------------------
-
-def soustraction(fn_a,fn_b,fn_result):
-    with rasterio.open(fn_a) as src_a, rasterio.open(fn_b) as src_b:
-        if (
-            src_a.width != src_b.width or
-            src_a.height != src_b.height or
-            src_a.transform != src_b.transform or
-            src_a.crs != src_b.crs
-        ):
-            logging.error(f"{fn_a} and {fn_b} do not have the same properties, please edit them.")
-
-
-        data_a = src_a.read(1)
-        data_b = src_b.read(1)
-
-        #(A - B)
-        data_diff = data_a - data_b
-        nodata_value = src_a.nodata if src_a.nodata == src_b.nodata else None
-        if nodata_value is not None:
-            data_diff[(data_a == nodata_value) | (data_b == nodata_value)] = nodata_value
-
-        data_diff[data_diff > 5000] = 0
-        labeled, n = label(data_diff)
-        # Remove small objects
-        threshold = 5
-        sizes = np.bincount(labeled.ravel())
-        idx_small = np.where(sizes <= threshold)[0]
-        data_diff[np.isin(labeled, idx_small)] = 0
-
-        out_meta = src_a.meta.copy()
-        out_meta.update({
-            "dtype": "float32",
-            "driver": "GTiff"
-        })
-
-    with rasterio.open(fn_result, "w", **out_meta) as dst:
-        dst.write(data_diff, 1)
-
-
-#2 - DEM (MNT) value in the buildings traces ------------------------------------------------------------------
-def mask_creation_data(mask_file, ground_file, output_file):
-    with rasterio.open(mask_file) as mask_src:
-        mask = mask_src.read(1).astype('float32')
-        mask_meta = mask_src.meta
-
-    indices = np.where(mask > 0)
-
-    with rasterio.open(ground_file) as bathy_src:
-        bathy = bathy_src.read(1)
-
-    mask[indices] = bathy[indices]
-    mask[mask <= 0] = 99999.
-
-    output_meta = mask_meta.copy()
-    output_meta.update({"dtype": 'float32'})
-
-    with rasterio.open(output_file, "w", **output_meta) as dst:
-        dst.write(mask, 1)
-
-    WA_mask = WolfArray(output_file)
-    WA_mask.write_all(Path(Path(output_file).parent / "MNT_computed_with_mask.bin"))
-
-def MNT_and_mask_creation_all(fn_bathy, fn_mtn_cropped, fn_where_buildings, fn_mask_final):
-    #couper_raster()
-    soustraction(fn_bathy, fn_mtn_cropped, fn_where_buildings)
-    mask_creation_data(fn_where_buildings, fn_mtn_cropped, fn_mask_final)
-
-#--------------------------------------------------------------------------------------------------------------
-
 def create_INPUT_TEMP_OUTPUT_forScenario(maindir, study_area, scenario, simu_gpu):
     """Creates folder for a new study area or/and scenario. The last argument simu_gpu is used when loading simulation (indicates path to the simulation folder),
     if not used, indicate None to ignore it."""
-    base_pathwd = Path(maindir) / "INPUT" / "WATER_DEPTH" / study_area.stem / scenario
+    study_area = Path(study_area).stem
+    base_pathwd = Path(maindir) / "INPUT" / "WATER_DEPTH" / study_area / scenario
     subfolders = ["DEM_FILES", "INTERP_WD", "EXTRACTED_LAST_STEP_WD"]
     os.makedirs(base_pathwd, exist_ok=True)
     for folder in subfolders:
         os.makedirs(os.path.join(base_pathwd, folder), exist_ok=True)
-    base_pathch = Path(maindir) / "INPUT" / "CHANGE_VULNE" / study_area.stem / scenario
+    base_pathch = Path(maindir) / "INPUT" / "CHANGE_VULNE" / study_area / scenario
     os.makedirs(base_pathch, exist_ok=True)
 
     if simu_gpu != None:
@@ -235,7 +102,7 @@ def create_INPUT_TEMP_OUTPUT_forScenario(maindir, study_area, scenario, simu_gpu
             create_shapefile_from_prop_tif(path_bat_gpu, Path(maindir) / "INPUT" / "STUDY_AREA" / f"{study_area}.shp")
             logging.info(_("Study area file created in INPUT/STUDY_AREA."))
         else :
-            logging.error(f"Error in the study area creation : no bathymetry.tif file in the given simulation folder {simu_gpu}. Please provide it in this folder and try again.")
+            logging.error(_(f"Error in the study area creation : no bathymetry.tif file in the given simulation folder {simu_gpu}. Please provide it in this folder and try again."))
 
     Accept_Manager(main_dir=maindir, Study_area=study_area, scenario=scenario)
     logging.info(_(f"Files created in INPUT, TEMP and OUTPUT for the study area named '{study_area}', and the scenario named '{scenario}'"))
@@ -243,32 +110,38 @@ def create_INPUT_TEMP_OUTPUT_forScenario(maindir, study_area, scenario, simu_gpu
 
 def get_transform_and_crs(tif_file):
     """
-    For TIFF file manipulation, reads the CRS and the transform, and returns them.
+    For TIFF file manipulation, reads the CRS and the geotransform, and returns them.
     """
-
-    with rasterio.open(tif_file) as src:
-        transform = src.transform
-        crs = src.crs
+    ds = gdal.Open(tif_file)
+    transform = ds.GetGeoTransform()
+    crs_wkt = ds.GetProjection()
+    crs = osr.SpatialReference()
+    crs.ImportFromWkt(crs_wkt)
     return transform, crs
 
 def create_shapefile_from_prop_tif(fn_tif, shapefile_path):
-    """
-    Creates a shapefile of the study area based on the extent of an input TIFF file.
-    Inputs:
-        - fn_tif: the path to the input TIFF file.
-        - shapefile_path: the location to save the output shapefile.
-    """
-    _,_,width,height,_,_ = get_header_info(fn_tif)
-    transform, crs = get_transform_and_crs(fn_tif)
-    top_left = transform * (0, 0)
-    bottom_left = transform * (0, height)
-    top_right = transform * (width, 0)
-    bottom_right = transform * (width, height)
+    unused, unused, width, height, unused, unused = get_header_info(fn_tif)
+    ds = gdal.Open(fn_tif)
+    width = ds.RasterXSize
+    height = ds.RasterYSize
+    gt = ds.GetGeoTransform()  
+
+    originX, pixelWidth, unused, originY, unused, pixelHeight = gt
+
+    top_left = (originX, originY)
+    top_right = (originX + width * pixelWidth, originY)
+    bottom_left = (originX, originY + height * pixelHeight)
+    bottom_right = (originX + width * pixelWidth, originY + height * pixelHeight)
 
     rectangle = Polygon([top_left, top_right, bottom_right, bottom_left, top_left])
-    gdf = gpd.GeoDataFrame({'geometry': [rectangle]})
-    gdf.set_crs(crs, allow_override=True, inplace=True)
+
+    sr = osr.SpatialReference()
+    sr.ImportFromWkt(ds.GetProjection())
+    crs_wkt = sr.ExportToWkt()
+
+    gdf = gpd.GeoDataFrame({'geometry': [rectangle]}, crs=crs_wkt)
     gdf.to_file(shapefile_path)
+    ds = None
 
 def get_header_info(fn):
     """
@@ -285,7 +158,6 @@ def get_header_comparison(list_fn):
     """
     Reads the headers from the files in list_fn and compares them. The result 'comp' is True if the headers are identical, and False otherwise.
     """
-
     header_infos = [get_header_info(fn) for fn in list_fn]
     variable_names = ["dx", "dy", "nbx", "nby", "X", "Y"]
     for idx, name in enumerate(variable_names):
@@ -296,7 +168,6 @@ def get_header_comparison(list_fn):
             comp = True
     return comp
 
-
 def display_info_header(self_dx, self_nbxy, self_O, fn):
     """
     Displays the header at the path 'fn', and update the values displayed in the acceptability window.
@@ -326,12 +197,47 @@ def update_info_header(self_dx, self_nbxy, self_O, fn):
             dx,dy,nbx,nby,X,Y = display_info_header(self_dx, self_nbxy, self_O, tif_list_fn[0])
             return dx,dy,nbx,nby,X,Y
         else:
-            logging.error("The interpolated files have different headers. Please fix it.")
+            logging.error(_("The interpolated files have different headers. Please fix it."))
             return False, False, False, False, False, False
     else :
         vanish_info_header(self_dx, self_nbxy, self_O)
         return False, False, False, False, False, False
 
+def create_vuln_file(tif_file, path_vuln):
+    src_ds = gdal.Open(str(tif_file))
+    driver = gdal.GetDriverByName("GTiff")
+
+    xsize = src_ds.RasterXSize
+    ysize = src_ds.RasterYSize
+    geotransform = src_ds.GetGeoTransform()
+    projection = src_ds.GetProjection()
+
+    # lire le raster source
+    src_band = src_ds.GetRasterBand(1)
+    src_data = src_band.ReadAsArray()
+    src_nodata = src_band.GetNoDataValue()
+
+    # préparer le tableau de sortie (1 partout)
+    data = np.ones((ysize, xsize), dtype=np.uint8)
+
+    # mettre 127 là où le raster source est nodata
+    if src_nodata is not None:
+        mask = src_data == src_nodata
+        data[mask] = 127
+
+    # créer le raster vuln_
+    output_file = path_vuln / tif_file.name.replace("bath_", "vuln_")
+    dst_ds = driver.Create(str(output_file), xsize, ysize, 1, gdal.GDT_Byte)
+    dst_ds.SetGeoTransform(geotransform)
+    dst_ds.SetProjection(projection)
+
+    band = dst_ds.GetRasterBand(1)
+    band.WriteArray(data)
+    band.SetNoDataValue(127)
+
+    dst_ds = None
+    src_ds = None
+    
 def search_for_modif_bath_and_copy(main_gpu, from_path, path_vuln):
     """
     When loading gpu simulations for last step extraction, search for modified bath_ topography file, according to
@@ -348,22 +254,30 @@ def search_for_modif_bath_and_copy(main_gpu, from_path, path_vuln):
         found_bath = True
     for tif_file in all_tif_bath:
         found_bath = True
-        with rasterio.open(tif_file) as src:
-            #vuln_ files
-            metadata = src.meta.copy()
-            metadata.update(dtype=rasterio.uint8, count=1, nodata=0)
-            data = np.ones((metadata['height'], metadata['width']), dtype=rasterio.uint8)
-            output_file = path_vuln / tif_file.name.replace('bath_', 'vuln_')
-            with rasterio.open(output_file, 'w', **metadata) as dst:
-                dst.write(data, 1)
-            #MNTmodifs_ files
-            metadata.update(dtype=rasterio.float32, count=1, nodata=0)
-            data = np.ones((metadata['height'], metadata['width']), dtype=rasterio.float32)
-            output_file = path_vuln / tif_file.name.replace('bath_', 'MNTmodifs_')
-            with rasterio.open(output_file, 'w', **metadata) as dst:
-                dst.write(data, 1)
-
-    return found_bath
+        src_ds = gdal.Open(str(tif_file))
+        driver = gdal.GetDriverByName("GTiff")
+
+        xsize = src_ds.RasterXSize
+        ysize = src_ds.RasterYSize
+        geotransform = src_ds.GetGeoTransform()
+        projection = src_ds.GetProjection()
+
+        # vuln_ file
+        create_vuln_file(tif_file,path_vuln)
+
+        # MNTmodifs_ file
+        output_file = path_vuln / tif_file.name.replace("bath_", "MNTmodifs_")
+        dst_ds = driver.Create(str(output_file), xsize, ysize, 1, gdal.GDT_Float32)
+        dst_ds.SetGeoTransform(geotransform)
+        dst_ds.SetProjection(projection)
+        data = np.ones((ysize, xsize), dtype=np.float32)
+        dst_ds.GetRasterBand(1).WriteArray(data)
+        dst_ds.GetRasterBand(1).SetNoDataValue(0)
+        dst_ds = None
+
+        src_ds = None
+
+        return found_bath
 
 def mapviewer_display(list_path, mapviewer=None):
     """ Load the output in the mapviewer on WOLF """
@@ -385,7 +299,6 @@ def mapviewer_display(list_path, mapviewer=None):
 
 class AcceptabilityGui(wx.Frame):
     """ The main frame for the vulnerability/acceptability computation """
-
     def __init__(self, parent=None, width=1024, height=500):
 
         super(wx.Frame, self).__init__(parent, title='Acceptability score manager', size=(width, height))
@@ -539,67 +452,78 @@ class AcceptabilityGui(wx.Frame):
         sizer_vert1 = wx.BoxSizer(wx.VERTICAL)
         sizer_hor_threads = wx.BoxSizer(wx.HORIZONTAL)
         sizer_hor1 = wx.BoxSizer(wx.HORIZONTAL)
-        sizer_hor1_1 = wx.BoxSizer(wx.HORIZONTAL)
         sizer_hor2 = wx.BoxSizer(wx.HORIZONTAL)
         sizer_hor3 = wx.BoxSizer(wx.HORIZONTAL)
         sizer_hor4 = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_hor5 = wx.BoxSizer(wx.HORIZONTAL)
         sizer_hor_scen = wx.BoxSizer(wx.HORIZONTAL)
 
         # 1st LINE - Loading acceptability folder
         panel = wx.Panel(self)
-        self._but_maindir = wx.Button(panel, label='Main Directory')
-        self._but_maindir.SetToolTip("To indicate where the main acceptability\n folder is located.")
+        self._but_maindir = wx.Button(panel, label=_('Main Directory'))
+        self._but_maindir.SetToolTip(_("To indicate where the main acceptability\n folder is located."))
         self._but_maindir.SetFont(wx.Font(9, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD))
         self._but_maindir.Bind(wx.EVT_BUTTON, self.OnMainDir)
 
         self._listbox_studyarea = wx.ListBox(panel, choices=[], style=wx.LB_SINGLE)
         self.layout_listbox(self._listbox_studyarea)
         self._listbox_studyarea.Bind(wx.EVT_LISTBOX, self.OnStudyArea)
-        self._listbox_studyarea.SetToolTip("Choose the study area existed in the folder.")
+        self._listbox_studyarea.SetToolTip(_("Choose the study area existed in the folder."))
 
         self._listbox_scenario = wx.ListBox(panel, choices=[], style=wx.LB_SINGLE)
         self.layout_listbox(self._listbox_scenario)
         self._listbox_scenario.Bind(wx.EVT_LISTBOX, self.OnScenario)
-        self._listbox_scenario.SetToolTip("Choose the acceptability scenario.")
+        self._listbox_scenario.SetToolTip(_("Choose the acceptability scenario."))
 
         sizer_ver_small = wx.BoxSizer(wx.VERTICAL)
-        self._but_checkfiles = wx.Button(panel, label='Check structure')
+        self._but_checkfiles = wx.Button(panel, label=_('Check structure'))
         self._but_checkfiles.Bind(wx.EVT_BUTTON, self.OnCheckFiles)
-        self._but_checkfiles.SetToolTip("Checks if the folder is correctly structured\n with INPUT, TEMP, OUTPUT.")
-        self._but_checksim = wx.Button(panel, label='Check simulations')
-        self._but_checksim.SetToolTip("Displays the loaded simulations, interpolated in INTERP_WD.")
+        self._but_checkfiles.SetToolTip(_("Checks if the folder is correctly structured\n with INPUT, TEMP, OUTPUT."))
+        self._but_checksim = wx.Button(panel, label=_('Check simulations'))
+        self._but_checksim.SetToolTip(_("Displays the loaded simulations, interpolated in INTERP_WD."))
         self._but_checksim.Bind(wx.EVT_BUTTON, self.OnHydrodynInput)
 
-        self._but_checkpond= wx.Button(panel, label='Check ponderation')
+        self._but_checkpond= wx.Button(panel, label=_('Check ponderation'))
         self._but_checkpond.Bind(wx.EVT_BUTTON, self.OnCheckPond)
-        self._but_checkpond.SetToolTip("Displays a graph of the computed weighting coefficient\n of the final acceptability computations.")
+        self._but_checkpond.SetToolTip(_("Displays a graph of the computed weighting coefficient\n of the final acceptability computations."))
 
         # 2nd LINE - Hydrodynamic part
-        self._but_loadgpu = wx.Button(panel, label='Load new\n hydraulic scenarios')
-        self._but_loadgpu.SetToolTip("To load or change the hydraulic simulations")
+        self._but_loadgpu = wx.ToggleButton(panel, label=_('Working with new\n hydraulic scenarios'))
+        self._but_loadgpu.SetToolTip(_("To load or change the hydraulic simulations"))
         self._but_loadgpu.SetFont(wx.Font(9, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD))
-        self._but_loadgpu.Bind(wx.EVT_BUTTON, self.OnLoadingSimu)
-        sizer_hor1_1.Add(self._but_loadgpu, 1, wx.ALL | wx.EXPAND, 0)
-
+        self._but_loadgpu.Bind(wx.EVT_TOGGLEBUTTON, self.OnLoadingSimu)
+        sizer_hor2.Add(self._but_loadgpu, 1, wx.ALL | wx.EXPAND, 0)
 
         self._check_listbox = wx.CheckListBox(panel, choices=[], style=wx.LB_MULTIPLE | wx.CHK_CHECKED)
         self.layout_listbox(self._check_listbox)
         self.sims = {}
-        sizer_hor1_1.Add(self._check_listbox, 1, wx.ALL | wx.EXPAND, 0) #ajouter!! sinon s'affiche pas
+        sizer_hor2.Add(self._check_listbox, 1, wx.ALL | wx.EXPAND, 0) #ajouter!! sinon s'affiche pas
 
-        self._but_DEM = wx.Button(panel, label='Check DEM inputs\n for interpolation')
-        self._but_DEM.SetToolTip("To display the existing DEM input for the interpolation of the simulated free surfaces.")
-        self._but_DEM.Bind(wx.EVT_BUTTON, self.OnDEM)
-        sizer_hor1_1.Add(self._but_DEM, 1, wx.ALL | wx.EXPAND, 0)
-
-        self._but_extrinterp = wx.Button(panel, label='Reading and interpolating\n free surface')
-        self._but_extrinterp.SetToolTip("To read the simulation, and created the hydraulic input for\n acceptability (interpolated simulated free surfaces)")
-        self._but_extrinterp.Bind(wx.EVT_BUTTON, self.on_button_click2)
+        self._but_danger = wx.Button(panel, label=_('Extract last step or\n compute danger map ▼'))
+        self._but_danger.SetToolTip(_("To create the danger maps of velocities and water depth. Please be patient."))
+        self._but_danger.Bind(wx.EVT_BUTTON, self.on_button_click2)
+        sizer_hor2.Add(self._but_danger, 1, wx.ALL | wx.EXPAND, 0)
+        
         self.menu2 = wx.Menu()
-        self.menu2.Append(1, "Interpolate the last step of the simulation.")
-        self.menu2.Append(2, "Interpolate the danger map of the simulation.")
-        self.menu2.Bind(wx.EVT_MENU, self.OnInterpolation)
-        sizer_hor1_1.Add(self._but_extrinterp, 1, wx.ALL | wx.EXPAND, 0)
+        self.menu2.Append(1, _("Extract the last step of the simulation."))
+        self.menu2.Append(2, _("Compute the danger maps of the simulation."))
+        self.menu2.Bind(wx.EVT_MENU, self.OnDanger)
+        
+        sizer_ver_small2 = wx.BoxSizer(wx.VERTICAL)
+        self._but_DEM = wx.Button(panel, label=_("Check  DEM, DTM for interpolation"))
+        self._but_DEM.SetToolTip(_("To display the existing DEM input for the interpolation of the simulated free surfaces."))
+        self._but_DEM.Bind(wx.EVT_BUTTON, self.OnDEM)
+                
+        self._but_MNTmodifs = wx.Button(panel, label=_("Check 'MNTmodifs_' scenarios"))
+        self._but_MNTmodifs.SetToolTip(_("To display the existing MNTmodifs_ scenario files for the DTM input of interpolation of the simulated free surfaces."))
+        self._but_MNTmodifs.Bind(wx.EVT_BUTTON, self.OnCheckMNTmodifs)
+        
+        sizer_hor2.Add(sizer_ver_small2, 0, wx.ALL | wx.EXPAND, 5)
+        
+        self._but_extrinterp = wx.Button(panel, label=_('Read and interpolate'))
+        self._but_extrinterp.SetToolTip(_("Reads and interpolates the danger maps computed (if not done, use previous buttons) of wolf gpu simulations."))
+        self._but_extrinterp.Bind(wx.EVT_BUTTON, self.OnInterpolation)
+        sizer_hor2.Add(self._but_extrinterp, 1, wx.ALL | wx.EXPAND, 0)
 
         sizer_hor1.Add(self._but_maindir, 2, wx.ALL | wx.EXPAND, 0)
         sizer_hor1.Add(self._listbox_studyarea, 1, wx.ALL | wx.EXPAND, 0)
@@ -608,19 +532,23 @@ class AcceptabilityGui(wx.Frame):
 
         #3rd line
         sizer_hor_threads = wx.BoxSizer(wx.HORIZONTAL)
-        text_dx = wx.StaticText(panel, label='Resolution (dx,dy) [m]:')
+        text_dx = wx.StaticText(panel, label=_('Resolution (dx,dy) [m]:'))
         self.input_dx = wx.StaticText(panel)
         self.input_dx.SetMinSize((80, -1))
-        text_nbxy = wx.StaticText(panel, label='(nbx, nby):')
+        text_nbxy = wx.StaticText(panel, label=_('(nbx, nby):'))
         self.input_nbxy = wx.StaticText(panel)
         self.input_nbxy.SetMinSize((90, -1))
-        text_O = wx.StaticText(panel, label='Origin (X,Y):')
+        text_O = wx.StaticText(panel, label=_('Origin (X,Y):'))
         self.input_O = wx.StaticText(panel)
         self.input_O.SetMinSize((170, -1))
-        text_threads = wx.StaticText(panel, label='Number of threads:')
+        text_threads = wx.StaticText(panel, label=_('Number of threads:'))
         self._nb_process = wx.SpinCtrl(panel, value=str(os.cpu_count()), min=1, max=os.cpu_count())
         self._nb_process.SetToolTip("Number of threads to be used in the computations.")
-
+        self._but_toggle_admin = wx.ToggleButton(panel, label=_('Admin mode'))
+        self._but_toggle_admin.SetToolTip("To activate admin mode. enter password.")
+        self.toggle_state_Admin = False
+        self._but_toggle_admin.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggleAdmin)
+        
         sizer_hor_threads.Add(text_dx, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(self.input_dx, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(text_nbxy, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
@@ -629,37 +557,44 @@ class AcceptabilityGui(wx.Frame):
         sizer_hor_threads.Add(self.input_O, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(text_threads, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_threads.Add(self._nb_process, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
+        sizer_hor_threads.Add(self._but_toggle_admin, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
 
-        # 3 last lines + scenarios
+        # 4,5,6th lines + scenarios
         #--------------------------
-        self._but_creation = wx.Button(panel, label='DataBase Creation')
+        self._but_creation = wx.Button(panel, label=_('DataBase Creation'))
         self.layout(self._but_creation)
         self._but_creation.Bind(wx.EVT_BUTTON, self.OnCreation)
 
         self._steps_db = wx.CheckListBox(panel, choices=steps_base_data_creation.get_list_names(), style=wx.LB_MULTIPLE | wx.CHK_CHECKED)
+        self._steps_db.Hide()
+        self._steps_db.SetForegroundColour(wx.Colour(170, 170, 170))
+        self._steps_db.SetBackgroundColour(wx.Colour(170, 170, 170)) 
 
-        self._but_vulnerability = wx.Button(panel, label='Vulnerability')
+        self._but_vulnerability = wx.Button(panel, label=_('Vulnerability'))
         self.layout(self._but_vulnerability)
         self._but_vulnerability.Bind(wx.EVT_BUTTON, self.OnVulnerability)
         step_Vuln_without_withoutscenarios = [item for item in steps_vulnerability.get_list_names() if item != 'APPLY_SCENARIOSVULN - 4']
         self._steps_vulnerability = wx.CheckListBox(panel, choices=step_Vuln_without_withoutscenarios, style=wx.LB_MULTIPLE | wx.CHK_CHECKED)
-
+        self._steps_vulnerability.Hide()
+        self._steps_vulnerability.SetForegroundColour(wx.Colour(170, 170, 170))
+        self._steps_vulnerability.SetBackgroundColour(wx.Colour(170, 170, 170)) 
+    
         # Scenarios specifics --
-        self._but_checkscenario = wx.Button(panel, label='Check existing scenarios')
-        self._but_checkscenario.SetToolTip("To display the scenario to be taken into account in CHANGE_VULNE.")
+        self._but_checkscenario = wx.Button(panel, label=_("Check 'vuln_' scenarios"))
+        self._but_checkscenario.SetToolTip(_("To display the scenario to be taken into account in CHANGE_VULNE."))
         self._but_checkscenario.Bind(wx.EVT_BUTTON, self.OnCheckScenario)
 
-        self._but_upriverbed = wx.Button(panel, label="Update riverbed")
-        self._but_upriverbed.SetToolTip("To create the raster of the riverbed trace.")
+        self._but_upriverbed = wx.Button(panel, label=_("Update riverbed ▼"))
+        self._but_upriverbed.SetToolTip(_("To create the raster of the riverbed trace."))
         self._but_upriverbed.Bind(wx.EVT_BUTTON, self.on_button_click)
 
         self.menu = wx.Menu()
-        self.menu.Append(1, "File of riverbed trace exists.")
-        self.menu.Append(2, "Point to a low discharge simulation and calculate the riverbed trace.")
+        self.menu.Append(1, _("File of riverbed trace exists."))
+        self.menu.Append(2, _("Point to a low discharge simulation and calculate the riverbed trace."))
         self.menu.Bind(wx.EVT_MENU, self.onRiverbed)
 
-        self._but_toggle_scen = wx.ToggleButton(panel, label="Accounting for scenarios")
-        self._but_toggle_scen.SetToolTip("To be activated to surimpose the vuln_ files, \n and so to take into account scenarios")
+        self._but_toggle_scen = wx.ToggleButton(panel, label=_("Accounting for scenarios"))
+        self._but_toggle_scen.SetToolTip(_("To be activated to surimpose the vuln_ files, \n and so to take into account scenarios"))
         self.toggle_state = False
         self._but_toggle_scen.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggle)
 
@@ -667,8 +602,8 @@ class AcceptabilityGui(wx.Frame):
         sizer_hor_scen.Add(self._but_upriverbed, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
         sizer_hor_scen.Add(self._but_toggle_scen, 1, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 1)
 
-        self._but_toggle_resamp = wx.ToggleButton(panel, label="Resampling [m]:")
-        self._but_toggle_resamp.SetToolTip("To compute the final raster with a coarser resolution than the original one.")
+        self._but_toggle_resamp = wx.ToggleButton(panel, label=_("Resampling [m]:"))
+        self._but_toggle_resamp.SetToolTip(_("To compute the final raster with a coarser resolution than the original one."))
         self.toggle_resamp_state = False
         self._but_toggle_resamp.Bind(wx.EVT_TOGGLEBUTTON, self.OnToggleResampling)
         sizer_hor_scen.Add(self._but_toggle_resamp, flag=wx.ALIGN_CENTER | wx.TOP)
@@ -677,22 +612,25 @@ class AcceptabilityGui(wx.Frame):
 
         #--
 
-        self._but_acceptability = wx.Button(panel, label='Acceptability')
+        self._but_acceptability = wx.Button(panel, label=_('Acceptability'))
         self.layout(self._but_acceptability)
         self._but_acceptability.Bind(wx.EVT_BUTTON, self.OnAcceptability)
 
         step_without_withoutscenarios = [item for item in steps_acceptability.get_list_names() if item != 'COMPUTE_WITH_SCENARIOS - 5']
         step_without_withoutscenarios = [item for item in step_without_withoutscenarios if item != 'RESAMPLING - 6']
         self._steps_acceptability = wx.CheckListBox(panel, choices=step_without_withoutscenarios, style=wx.LB_MULTIPLE | wx.CHK_CHECKED)
+        self._steps_acceptability.Hide()
+        self._steps_acceptability.SetForegroundColour(wx.Colour(170, 170, 170))
+        self._steps_acceptability.SetBackgroundColour(wx.Colour(170, 170, 170)) 
 
-        sizer_hor2.Add(self._but_creation, 1, wx.ALL | wx.EXPAND, 0)
-        sizer_hor2.Add(self._steps_db, 1, wx.ALL | wx.EXPAND, 0)
+        sizer_hor3.Add(self._but_creation, 1, wx.ALL | wx.EXPAND, 0)
+        sizer_hor3.Add(self._steps_db, 1, wx.ALL | wx.EXPAND, 0)
 
-        sizer_hor3.Add(self._but_vulnerability, 1, wx.ALL | wx.EXPAND, 0)
-        sizer_hor3.Add(self._steps_vulnerability, 1, wx.ALL | wx.EXPAND, 0)
+        sizer_hor4.Add(self._but_vulnerability, 1, wx.ALL | wx.EXPAND, 0)
+        sizer_hor4.Add(self._steps_vulnerability, 1, wx.ALL | wx.EXPAND, 0)
 
-        sizer_hor4.Add(self._but_acceptability, 1, wx.ALL | wx.EXPAND, 0)
-        sizer_hor4.Add(self._steps_acceptability, 1, wx.ALL | wx.EXPAND, 0)
+        sizer_hor5.Add(self._but_acceptability, 1, wx.ALL | wx.EXPAND, 0)
+        sizer_hor5.Add(self._steps_acceptability, 1, wx.ALL | wx.EXPAND, 0)
 
         #Lines order
         sizer_ver_small.Add(self._but_checkfiles, 0, wx.ALL | wx.EXPAND, 1)
@@ -700,12 +638,16 @@ class AcceptabilityGui(wx.Frame):
         sizer_ver_small.Add(self._but_checkpond, 0, wx.ALL | wx.EXPAND, 1)
 
         sizer_vert1.Add(sizer_hor1, 1, wx.EXPAND, 0)
-        sizer_vert1.Add(sizer_hor1_1, 1, wx.EXPAND, 0)
-        sizer_vert1.Add(sizer_hor_threads, 0, wx.EXPAND, 0)
         sizer_vert1.Add(sizer_hor2, 1, wx.EXPAND, 0)
-        sizer_vert1.Add(sizer_hor_scen, 1, wx.EXPAND, 0)
+        sizer_vert1.Add(sizer_hor_threads, 0, wx.EXPAND, 0)
         sizer_vert1.Add(sizer_hor3, 1, wx.EXPAND, 0)
+        sizer_vert1.Add(sizer_hor_scen, 1, wx.EXPAND, 0)
+         
         sizer_vert1.Add(sizer_hor4, 1, wx.EXPAND, 0)
+        sizer_vert1.Add(sizer_hor5, 1, wx.EXPAND, 0)
+        
+        sizer_ver_small2.Add(self._but_MNTmodifs, 0, wx.ALL | wx.EXPAND, 1)
+        sizer_ver_small2.Add(self._but_DEM, 0, wx.ALL | wx.EXPAND, 1)
 
         sizer_hor_main.Add(sizer_vert1, proportion=1, flag=wx.EXPAND, border=0)
 
@@ -715,6 +657,7 @@ class AcceptabilityGui(wx.Frame):
         self._but_creation.Enable(False)
         self._but_checkfiles.Enable(False)
         self._but_DEM.Enable(False)
+        self._but_MNTmodifs.Enable(False)
         self._but_extrinterp.Enable(False)
         self._but_toggle_scen.Enable(False)
         self._but_toggle_resamp.Enable(False)
@@ -724,11 +667,11 @@ class AcceptabilityGui(wx.Frame):
         self._but_checksim.Enable(False)
         self._but_creation.Enable(False)
         self._but_loadgpu.Enable(False)
+        self._but_danger.Enable(False)
 
         panel.SetSizer(sizer_hor_main)
         panel.Layout()
 
-
     def OnSims(self, e:wx.ListEvent):
         """ Load sim into the mapviewer """
         pass
@@ -750,19 +693,19 @@ class AcceptabilityGui(wx.Frame):
         """ Check the files """
 
         if self._manager is None:
-            logging.error("No main directory selected -- Nothing to check")
+            logging.error(_("No main directory selected -- Nothing to check"))
             return
 
         i=self._manager.check_inputs()
 
         if i == False :
-            logging.error(f"Missing files in INPUT. Please provide them by following the right structure.")
+            logging.error(_(f"Missing files in INPUT. Please provide them by following the right structure."))
             with wx.MessageDialog(self, f"Missing files in INPUT. Inputs can not be created automatically : you must provide them.\n Please read the logs and terminal to see the missing ones.", "Error", wx.OK | wx.ICON_ERROR) as dlg:
                 dlg.ShowModal()
             return
         else :
             if (self._manager._study_area is None) or (self._manager._scenario is None):
-                logging.error(f"No study area and/or scenario selected, no check of TEMP and OUTPUT.")
+                logging.error(_(f"No study area and/or scenario selected, no check of TEMP and OUTPUT."))
                 with wx.MessageDialog(self, f"INPUT is well structured, but TEMP and OUTPUT have not been checked because there is no study area and scenario selected.", "Checking", wx.OK | wx.ICON_INFORMATION) as dlg:
                         dlg.ShowModal()
             else:
@@ -780,7 +723,7 @@ class AcceptabilityGui(wx.Frame):
         """
 
         if self._manager is None:
-            logging.error("No main directory selected -- Nothing to check")
+            logging.error(_("No main directory selected -- Nothing to check"))
             return
 
         if self._manager.IN_SA_INTERP is None:
@@ -809,7 +752,7 @@ class AcceptabilityGui(wx.Frame):
 
             elif response == wx.ID_NO:
                 logging.info(_("Decision of loading simulations."))
-                with wx.MessageDialog(self, f"Please use the 'Load gpu simulations folder' button of the manager and follow the instructions.", "Redirecting",
+                with wx.MessageDialog(self, f"Please use the 'Working with new hydraulic scenarios' button of the manager and follow the instructions.", "Redirecting",
                                       wx.OK | wx.ICON_INFORMATION) as dlg:
                     dlg.ShowModal()
             else:
@@ -833,7 +776,7 @@ class AcceptabilityGui(wx.Frame):
     def OnCheckPond(self,e):
 
         if self._manager is None:
-            logging.error("No main directory selected -- Nothing to check")
+            logging.error(_("No main directory selected -- Nothing to check"))
             return
         if self._manager.IN_SA_INTERP is None:
             logging.error(_("No IN_SA_INTERP attribute found in the manager."))
@@ -907,13 +850,17 @@ class AcceptabilityGui(wx.Frame):
                 self._but_vulnerability.Enable(True)
                 self._but_creation.Enable(True)
                 self._but_checkfiles.Enable(True)
-                self._but_toggle_scen.Enable(True)
                 self._but_toggle_resamp.Enable(True)
                 self._but_upriverbed.Enable(True)
                 self._but_checkscenario.Enable(True)
                 self._but_checkpond.Enable(True)
                 self._but_checksim.Enable(True)
                 self._but_loadgpu.Enable(True)
+                
+                #Must be False if come back :
+                self._but_DEM.Enable(False)
+                self._but_MNTmodifs.Enable(False)
+                self._but_extrinterp.Enable(False) 
 
                 self._listbox_scenario.Clear()
                 studyareas = self._manager.get_list_studyareas()
@@ -939,7 +886,7 @@ class AcceptabilityGui(wx.Frame):
         if len(sc)!=0:
             self._listbox_scenario.InsertItems(sc, 0)
         else :
-            logging.error("No scenario available associated with this study area.")
+            logging.error(_("No scenario available associated with this study area."))
 
         if self.mapviewer is not None:
             tmp_path = self._manager.IN_STUDY_AREA / study_area
@@ -948,13 +895,18 @@ class AcceptabilityGui(wx.Frame):
             if not tmp_path.stem in self.mapviewer.get_list_keys(drawing_type=draw_type.VECTORS):
                 self.mapviewer.add_object('vector', filename=str(tmp_path), id=tmp_path.stem)
                 self.mapviewer.Refresh()
+        self._but_DEM.Enable(False)
+        self._but_MNTmodifs.Enable(False)
+        self._but_extrinterp.Enable(False) 
 
     def OnScenario(self, e):
         """ Change the scenario """
         if self._manager is None:
             return
         scenario = self._manager.get_list_scenarios()[e.GetSelection()]
-
+        self._but_DEM.Enable(True)
+        self._but_MNTmodifs.Enable(True)
+        self._but_extrinterp.Enable(True) 
         self._manager.change_scenario(scenario)
         create_INPUT_TEMP_OUTPUT_forScenario(self.maindir, self._manager.Study_area, self._manager.scenario, None)
         update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
@@ -962,7 +914,7 @@ class AcceptabilityGui(wx.Frame):
     def OnCreation(self, e):
         """ Create the database """
         if self._manager is None:
-            logging.error("No main directory selected -- Nothing to create")
+            logging.error(_("No main directory selected -- Nothing to create"))
             return
         if self._manager.IN_SA_INTERP is None:
             logging.error(_("No IN_SA_INTERP attribute found in the manager."))
@@ -970,7 +922,7 @@ class AcceptabilityGui(wx.Frame):
                 dlg.ShowModal()
             return
 
-        dx,_,_,_,_,_ = update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
+        dx,unused,unused,unused,unused,unused = update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
         resolution = dx
         if resolution == '':
             wx.MessageBox(
@@ -1002,7 +954,7 @@ class AcceptabilityGui(wx.Frame):
                             )
             else :
                 wx.MessageBox(
-                            f"No steps selected. The code for the DataBase creation will consider all steps by default, , with a resolution of {dx}. This process may take some time, and the window may temporarily stop responding.",
+                            f"Resolution of {dx}. This process may take some time, and the window may temporarily stop responding.",
                             "Information",
                             wx.OK | wx.ICON_INFORMATION
                             )
@@ -1022,8 +974,9 @@ class AcceptabilityGui(wx.Frame):
             -Create scenario and study area if needed.
         """
 
-        dlg = wx.DirDialog(None, "Please select the main scenario manager folder (containing the scenarios, the folder discharge, the scripts.py...), named after the STUDY AREA.", style=wx.DD_DEFAULT_STYLE)
+        dlg = wx.DirDialog(None, "Please select the main scenario manager folder (containing the scenarios, the folder discharge, the scripts.py...), named after the STUDY AREA.\n If you cancel, this button wont be activated or will be desactivated.", style=wx.DD_DEFAULT_STYLE)
         if dlg.ShowModal() == wx.ID_OK:
+            self._but_loadgpu.SetValue(True)
             main_gpu = Path(dlg.GetPath())
             study_area = main_gpu.name
             logging.info(_(f"Selected folder for GPU result such as the STUDY AREA is {study_area}"))
@@ -1037,8 +990,6 @@ class AcceptabilityGui(wx.Frame):
                 self._manager.change_studyarea(study_area+'.shp')
                 self._manager.change_scenario(scenario)
 
-
-
                 self._listbox_studyarea.Clear()
                 self._listbox_studyarea.InsertItems(self._manager.get_list_studyareas(), 0)
                 self._listbox_scenario.Clear()
@@ -1058,10 +1009,12 @@ class AcceptabilityGui(wx.Frame):
                 self._listbox_scenario.Refresh()
 
             else:
-                logging.error('No hydraulic scenario selected.')
+                logging.error('No hydraulic scenario selected, toggle button desactivated.')
+                self._but_loadgpu.SetValue(False)
                 return
         else:
             logging.error('No folder found / selected. Please try again.')
+            self._but_loadgpu.SetValue(False)
             return
 
         self._check_listbox.Clear()
@@ -1086,22 +1039,17 @@ class AcceptabilityGui(wx.Frame):
         self.gpu_bathy = hydraulic_scen.parent / BATHYMETRY_FOR_SIMULATION # this is the last bathymetry after the scripts have been run
         self._but_extrinterp.Enable(True)
         self._but_DEM.Enable(True)
+        self._but_danger.Enable(True)
+        self._but_MNTmodifs.Enable(True)
         with wx.MessageDialog(self,
                                 message,
                                 "Information",
                                 style=wx.OK | wx.ICON_INFORMATION) as dlg:
             dlg.ShowModal()
-
+    
     def OnDEM(self,e):
         """Import and create the inputs for the interpolation routine (name including 'MNT_...' and 'MNT_..._with_mask'.
         See function MTN_And_mask_creation_all"""
-        if not hasattr(self, 'file_paths'):
-            with wx.MessageDialog(self,
-                                f"Please, first load gpu simulations via the previous button.",
-                                "Attention",
-                                style=wx.OK | wx.ICON_ERROR) as dlg:
-                dlg.ShowModal()
-            return
         path = self._manager.IN_SA_DEM
         names_inDEM = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]
         if len(names_inDEM) != 0 :
@@ -1117,7 +1065,15 @@ class AcceptabilityGui(wx.Frame):
                 logging.info(_("No update of DEM_FILES."))
                 return
 
-        with wx.FileDialog(self, "Please select the DEM file in .tif format (without modifications).", wildcard="TIFF files (*.tif)|*.tif",
+        #Avec ajout BATHT_AFTER_SCRIPT
+        if self.gpu_bathy == None:
+            with wx.FileDialog(self, "Please select the bathymetry file of simulation, with all the modifications (e.g. '__bathymetry_after_scripts.tif') in .tif format.", wildcard="TIFF files (*.tif)|*.tif",
+                        style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) as dlg:
+                if dlg.ShowModal() != wx.ID_OK:
+                    return
+                self.gpu_bathy = dlg.GetPath()
+            
+        with wx.FileDialog(self, "Please select the DEM file in .tif format (without modifications, MNTmodifs_ will be used afterwards).", wildcard="TIFF files (*.tif)|*.tif",
                         style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST) as dlg:
             result = dlg.ShowModal()
             if result != wx.ID_OK:
@@ -1130,6 +1086,7 @@ class AcceptabilityGui(wx.Frame):
         path = self._manager.IN_CH_SA_SC
         names_inCHVUL_MNTmodifs = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f)) and f.startswith("MNTmodifs_")]
         #path_MNT_computed is the path to the DEM with the MNTmodifs if exist, or the given true DEM if not
+                
         path_MNT_computed = Path(path_DEM_base)
         if len(names_inCHVUL_MNTmodifs) !=0:
             path_MNT_computed = Path(self._manager.IN_CH_SA_SC_MNT_tif.with_suffix('.tif'))
@@ -1141,26 +1098,27 @@ class AcceptabilityGui(wx.Frame):
                 logging.info(_("No modifications done in MNTmodifs_ files, process stopped."))
                 return
 
-        #else :
         if os.path.exists(self._manager.IN_CH_SA_SC):
             existence=False
-            existence = self._manager.create_vrtIfExists(Path(path_DEM_base), self._manager.IN_CH_SA_SC, self._manager.IN_CH_SA_SC_MNT_VRT, name="MNTmodifs_")
-            if existence :
+            existence, fail = self._manager.create_vrtIfExists(Path(path_DEM_base), self._manager.IN_CH_SA_SC, self._manager.IN_CH_SA_SC_MNT_VRT, name="MNTmodifs_")
+            if existence:
                 self._manager.translate_vrt2tif(self._manager.IN_CH_SA_SC_MNT_VRT, self._manager.IN_CH_SA_SC_MNT_tif)
                 logging.info(_(f"Scenarios have been applied to DEM see {self._manager.IN_CH_SA_SC_MNT_tif}.tif."))
                 WA_mask = WolfArray(self._manager.IN_CH_SA_SC_MNT_tif.with_suffix('.tif'))
-                WA_mask.write_all(Path(self._manager.IN_SA_DEM / "MNT_loaded.bin"))
+                WA_mask.write_all(Path(self._manager.IN_SA_DEM / "MNT_loaded.bin"))   
+                     
             else :
                 logging.info(_(f"No MNTmodifs_ files in {self._manager.IN_CH_SA_SC}. The given file {path_DEM_base} has not been modified"))
                 WA_mask = WolfArray(path_DEM_base)
                 WA_mask.write_all(Path(self._manager.IN_SA_DEM / "MNT_loaded.bin"))
         else:
-            logging.error(f"Path {self._manager.IN_CH_SA_SC} does not exist.")
+            logging.error(_(f"Path {self._manager.IN_CH_SA_SC} does not exist."))
 
         #self._manager.IN_CH_SA_SC_MNT_tif   ou fn_mnt_cropped : ground + riverbed
         fn_wherebuildings_buffer = self._manager.IN_CH_SA_SC / "buffer_wherebuilding.tif"
         fn_mask = self._manager.IN_SA_DEM / "MNT_computed_with_mask.tif"
-        MNT_and_mask_creation_all(self.gpu_bathy, path_MNT_computed, fn_wherebuildings_buffer, fn_mask)
+        _interpol = interpolating_raster()
+        _interpol.MNT_and_mask_creation_all(self.gpu_bathy, path_MNT_computed, fn_wherebuildings_buffer, fn_mask)
         if fn_wherebuildings_buffer.exists():
             fn_wherebuildings_buffer.unlink()
         if fn_mask.exists():
@@ -1172,19 +1130,52 @@ class AcceptabilityGui(wx.Frame):
         dlg.ShowModal()
         dlg.Destroy()
         return
-
-    def OnInterpolation(self,e):
-        """Interpolates the last extracted time steps present in LAST_STEP_EXTRACTED using the fast marching
-        interpolation routine, by creating a batch file
-        while performing multiple checks on the required input files."""
+    
+    def OnDanger(self,e):
+        """ Specific button to extract last step or to compute the wd danger map"""
         menu_id = e.GetId()
+        param_danger = [0, -1, 1]
         if menu_id == 1:
             type_extraction = "last_step"
             logging.info(_("Option 1 : last step extraction and interpolation."))
         elif menu_id == 2:
             type_extraction = "danger_map"
             logging.info(_("Option 2 : danger map computation and interpolation."))
-
+            dlg = wx.TextEntryDialog(None,
+                "Enter parameters as (e.g 0, -1, 1): from which step, until which step (-1 if latest step), by number of step",
+                "Parameters", "0, -1, 1")
+            if dlg.ShowModal() == wx.ID_OK:
+                try:
+                    param_danger = [int(x.strip()) for x in dlg.GetValue().split(",")]
+                except:
+                    wx.MessageBox("Invalid input. Use format: 0, -1, 1", "Error")
+                dlg.Destroy()
+            
+            else :
+                return
+    
+            
+        with wx.TextEntryDialog(
+            self,
+            "What threshold (in meters) do you want to apply to filter the water depth danger map?",
+            "Water Depth Threshold",
+            "0.01"
+            ) as dlg:
+            threshold = None
+            if dlg.ShowModal() == wx.ID_OK:
+                val = dlg.GetValue().strip().replace(',', '.')
+                try:
+                    threshold = float(val)
+                    if threshold <= 0:
+                        wx.MessageBox("Please enter a strictly positive number.", "Invalid Value", wx.ICON_ERROR)
+                        threshold = None
+                        return
+                except Exception:
+                    wx.MessageBox("Invalid input — please enter a number (e.g., 0.01).", "Error", wx.ICON_ERROR)
+                    threshold = None
+                    return
+            else :
+                return
         if not hasattr(self, 'file_paths'):
             with wx.MessageDialog(self,
                                 f"Please, first load gpu simulations via the previous button.",
@@ -1192,15 +1183,18 @@ class AcceptabilityGui(wx.Frame):
                                 style=wx.OK | wx.ICON_ERROR) as dlg:
                 dlg.ShowModal()
             return
-
+        logging.info(_(f"Threshold for water depth selected : {threshold} [m]"))
         checked_indices = self._check_listbox.GetCheckedItems()
         checked_items = [self._check_listbox.GetString(index) for index in checked_indices]
         selected_paths = [self.file_paths[item] for item in checked_items]
+        if not selected_paths:
+            wx.MessageBox("No selection detected. Using all items in the list.", "Info", wx.ICON_INFORMATION)
+            selected_items = list(self._check_listbox.GetStrings())
+            selected_paths = [self.file_paths[item] for item in selected_items]
         path_simulations = self.datadir_simulations
 
-        path_LastSteps = Path(self._manager.IN_SA_EXTRACTED)
-        fn_write = None
-        dx,dy,nbx,nby,X,Y = False, False, False, False, False, False
+        #dx,dy,nbx,nby,X,Y = False, False, False, False, False, False
+        _interpol = interpolating_raster()
         for sim_ in selected_paths:
             if sim_.name.startswith("sim_"):
                 self.sims[sim_.name] = sim_
@@ -1209,29 +1203,44 @@ class AcceptabilityGui(wx.Frame):
                 parts = sim_.name.split("sim_")
                 if len(parts) > 1:
                     name = parts[1]
-                    fn_write = Path(path_LastSteps / name )
                     # dx,dy,nbx,nby,X,Y = display_info_header(self.input_dx, self.input_nbxy, self.input_O, fn_write.with_suffix(".bin"))
-                    read_export_z_bin(fn_read, fn_write, path_LastSteps, type_extraction = type_extraction)
+                    _interpol.export_z_or_v_bin(fn_read, self._manager, name, type_hazard="z", type_extraction = type_extraction, param_danger = param_danger, threshold=threshold)
+                
                 else:
                     logging.info(_(f"Please, ensure your simulations are named with the return period, e.g sim_T4"))
             else:
                 logging.info(_('No folder found / selected. Please try again...'))
-        else:
-            logging.error('No simulation selected! Please select some in the checkbox.')
-
-        checked_names = self._check_listbox.GetCheckedStrings()
-        if not checked_names:
-            logging.info(_("No items selected. Adding all paths."))
-            checked_paths = list(self.file_paths.values())
-        else:
-            logging.info(_("Adding only the selected simulations."))
-            checked_paths = [self.file_paths[name] for name in checked_names]
-
-        if len(self.file_paths) == 0 :
-            return logging.info(_("No files in EXTRACTED_LAST_STEP_WD. Please provide some or use the 'Load gpu simulation' button."))
-
-        # interp_bool, renamed_files = self._manager.batch_creation_and_interpolation_fotran_holes(checked_paths, False)
-        interp_bool, renamed_files = self._manager.batch_creation_and_interpolation_python_eikonal(checked_paths, False)
+        
+        with wx.MessageDialog(self,
+                                f"End of the process.",
+                                "Information",
+                                style=wx.OK | wx.ICON_INFORMATION) as dlg:
+                dlg.ShowModal()
+    
+    def OnInterpolation(self,e):
+        """Interpolates the last extracted time steps present in LAST_STEP_EXTRACTED using the fast marching
+        interpolation routine, by creating a batch file
+        while performing multiple checks on the required input files."""
+        if self._but_loadgpu.GetValue(): #if simulations have been loaded :
+            checked_names = self._check_listbox.GetCheckedStrings()
+            iftest = False
+            if not checked_names:
+                logging.info(_("No items selected. Adding all paths."))
+                checked_paths = list(self.file_paths.values())
+            else:
+                logging.info(_("Adding only the selected simulations."))
+                checked_paths = [self.file_paths[name] for name in checked_names]
+                
+            if len(self.file_paths) == 0 :
+                return logging.info(_("No files in EXTRACTED_LAST_STEP_WD. Please provide some or use the 'Load gpu simulation' button."))
+        
+        else : #if interpoalting based on existing files :
+            checked_paths = None
+            iftest = True
+        
+        _interpol = interpolating_raster()
+        #interp_bool, renamed_files = _interpol.batch_creation_and_interpolation_fotran_holes(self._manager, checked_paths, False)
+        interp_bool, renamed_files = _interpol.batch_creation_and_interpolation_python_eikonal(self._manager, checked_paths, iftest, True)
 
         if interp_bool:
             logging.info(_("Filling completed."))
@@ -1240,8 +1249,35 @@ class AcceptabilityGui(wx.Frame):
                 dlg.ShowModal()
             update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
         else :
-            logging.error("Something went wrong for the interpolation.")
+            logging.error(_("Something went wrong for the interpolation."))
+            
+    def OnToggleAdmin(self, e):
+        if self.toggle_state_Admin:
+            self.toggle_state_Admin = False
+            self._but_toggle_admin.SetBackgroundColour(wx.NullColour)
+            self._steps_db.Hide()
+            self._steps_vulnerability.Hide()
+            self._steps_acceptability.Hide()
+            return
 
+        dlg = wx.TextEntryDialog(self, "Enter developer password:", "Authentication")
+        if dlg.ShowModal() == wx.ID_OK:
+            password = dlg.GetValue()
+            if password == "LetMeIn#":
+                self.toggle_state_Admin = True
+                self._but_toggle_admin.SetBackgroundColour(wx.Colour(175, 175, 175))
+                
+                self._steps_db.Show()
+                self._steps_vulnerability.Show()
+                self._steps_acceptability.Show()
+                
+            else:
+                wx.MessageBox("Wrong password.", "Error")
+                self.toggle_state_Admin = False
+                self._but_toggle_admin.SetBackgroundColour(wx.NullColour)
+        dlg.Destroy()
+        self.mapviewer.Refresh()
+            
     def OnToggle(self,e):
         """Creates a toggle button to be activated if the scenarios vuln_ have to be taken into account."""
         self.toggle_state = False
@@ -1299,28 +1335,128 @@ class AcceptabilityGui(wx.Frame):
                 self._but_toggle_resamp.SetBackgroundColour(wx.NullColour)
                 logging.info(_("No simulations in INTERP_WD."))
 
-
         else:
             self.toggle_resamp_state = False
             self._but_toggle_resamp.SetValue(False)
             self._but_toggle_resamp.SetBackgroundColour(wx.NullColour)
             logging.info(_("Resampling disactivated"))
+            
+    def check_and_convert_rasters(self, manager, prefix, type_file, numpy_type, nodata_value, message_supp=None):
+        logging.info(_(f"Checking the scenarios for {prefix}."))
+
+        #tif_paths = self._manager.get_modifiedrasters(name=prefix)
+        tif_paths = manager.get_modifiedrasters(name=prefix)
+        good, bad, bad_paths = [], [], []
+
+        for f in tif_paths:
+            ds = gdal.Open(f)
+            if ds:
+                file_type = gdal.GetDataTypeName(ds.GetRasterBand(1).DataType)
+                ds = None
+                if file_type == type_file:
+                    good.append(f.stem)
+                else:
+                    suffix_to_add = f"_{file_type}"
+                    new_name = f.parent / f"{f.stem}{suffix_to_add}{f.suffix}"
+                    if not f.stem.endswith(suffix_to_add):
+                        f.rename(new_name)
+                    else:
+                        new_name = f
+                    bad.append(new_name.stem)
+                    bad_paths.append(new_name)
+
+        if bad:
+            message_intro = (
+                f"Detected {prefix} scenario files:\n"
+                f"{', '.join([f.stem for f in tif_paths])}\n\n"
+                f"However, wrong type in file(s): {', '.join(bad)}. "
+                f"Its/Their type has been added to their name (expected {type_file}).\n\n"
+                f"Do you want to try to convert them to {type_file} automatically?"
+            )
+
+            dlg = wx.MessageDialog(None, message_intro, "Warning", wx.YES_NO | wx.ICON_WARNING)
+            result = dlg.ShowModal()
+            dlg.Destroy()
+
+            if result == wx.ID_YES:
+                for path in bad_paths:
+                    with gdal.Open(path, gdal.GA_ReadOnly) as ds:
+                        band = ds.GetRasterBand(1)
+                        arr = band.ReadAsArray()
+                        nodata = band.GetNoDataValue()
+                        geotransform = ds.GetGeoTransform()
+                        projection = ds.GetProjection()
+
+                    # SPÉCIAL POUR LE CAS int8
+                    if type_file == "Byte":
+                        mask_valid = np.ones_like(arr, dtype=bool)
+                        if nodata is not None:
+                            mask_valid = arr != nodata
+
+                        valid_values = arr[mask_valid]
+                        if not np.all((valid_values >= 1) & (valid_values <= 5)):
+                            wx.MessageBox(
+                                f"Impossible to change the type to int8, there exist other type of data in the raster(s) !\n {message_supp}",
+                                "Error", wx.OK | wx.ICON_ERROR
+                            )
+                            return
 
-    def OnCheckScenario(self,e):
-        """Checks if scenarios exist in CHANGE_VULNE."""
-        tif_files = self._manager.get_modifiedrasters()
-        logging.info(_("checking the scenarios for vulnerability and acceptability."))
-        if not tif_files:
-            wx.MessageBox(
-                        "No files 'vuln_' or 'MNTmodifs_' found in CHANGE_VULNE.",
-                        "Information",
-                        wx.OK | wx.ICON_INFORMATION
-                        )
-        else :
-            wx.MessageBox(
-                f"There exist vuln_ file(s) in CHANGE_VULNE:\n {', '.join([tif_file for tif_file in tif_files])}",
-                "Information", wx.OK | wx.ICON_INFORMATION)
+                    arr_new = arr.astype(numpy_type)
+                    if nodata is not None:
+                        arr_new[arr == nodata] = nodata_value
+                    else:
+                        arr_new[arr_new < 1] = nodata_value #if nodata doesnt exist
+
+                    dirname, filename = os.path.split(path)
+                    new_filename = filename.replace(prefix, f"{prefix}AUTO_").replace(".tif", f"_to_{type_file}.tif")
+                    old_filename = filename.replace(prefix, f"OLD_{prefix}")
+                    new_path = os.path.join(dirname, new_filename)
+                    old_path = os.path.join(dirname, old_filename)
+
+                    os.rename(path, old_path)
+                    driver = gdal.GetDriverByName("GTiff")
+                    out_ds = driver.Create(new_path, arr.shape[1], arr.shape[0], 1,
+                                        gdal.GetDataTypeByName(type_file))
+                    out_ds.SetGeoTransform(geotransform)
+                    out_ds.SetProjection(projection)
+                    out_band = out_ds.GetRasterBand(1)
+                    out_band.WriteArray(arr_new)
+                    out_band.SetNoDataValue(nodata_value)
+                    out_band.FlushCache()
+                    out_ds = None
 
+                wx.MessageBox(
+                    f"Files converted to {type_file}. Previous ones renamed with 'OLD_...'.",
+                    "Information", wx.OK | wx.ICON_INFORMATION
+                )
+        else:
+            wx.MessageBox(
+                f"Detected {prefix} scenario files:\n{', '.join([f.stem for f in tif_paths])}\n Everything is fine.",
+                "Information", wx.OK | wx.ICON_INFORMATION
+            )
+        
+        if prefix == "vuln_":
+            self._but_toggle_scen.Enable(True)
+    
+    def OnCheckMNTmodifs(self,e):
+        """Checks if scenarios MNTmodifs_ exist in CHANGE_VULNE and test the type (float32)"""
+        self.check_and_convert_rasters(self._manager, "MNTmodifs_", "Float32", np.float32, 99999.)
+        return
+    
+    def OnCheckScenario(self,e):
+        """Checks if scenarios vuln_ exist in CHANGE_VULNE and test the type (int8)"""
+        message_supp = textwrap.dedent(""" To change the type and null value as needed, via WOLF HECE GUI: 
+                                       1. Load the problematic file (File > Add array, and point toward the name indicated above). 
+                                       2. Ctrl + double click on the name in the Arrays tree on the left. a window should open. 
+                                       3. Click on "Select all nodes" and then go to Operators. If "=99999", replace with "127" and click "Apply math operator". 
+                                       4. Go to "Miscellaneous", set "Null value = 127", and click on "Apply Null Value". 
+                                       5. Change other values (there exists value outside interval of vulnerability [1,5], change them to int8)!
+                                       6. (Optionnal) Go back to the main window, Ctrl + right click on the array to save it. 
+                                       7. Right-click on the array > Duplicate > enter new name (with "vuln_...") and change the type to int8 before saving it. 
+                                       8. DELETE THE PREVIOUS FILE, and retry the Vulnerability button. 
+                                       """)
+        self.check_and_convert_rasters(self._manager, "vuln_", "Byte", np.int8, 127, message_supp=message_supp)
+        
     def OnVulnerability(self, e):
         """ Run the vulnerability """
         if self._manager is None:
@@ -1328,7 +1464,7 @@ class AcceptabilityGui(wx.Frame):
         path = [self._manager.OUT_VULN]
         steps = list(self._steps_vulnerability.GetCheckedStrings())
         steps = [int(cur.split('-')[1]) for cur in steps]
-        resolution,_,_,_,_,_ =update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
+        resolution,unused,unused,unused,unused,unused =update_info_header(self.input_dx,self.input_nbxy,self.input_O,self._manager.IN_SA_INTERP)
         if resolution == '':
             wx.MessageBox(
                         f"There are no files in INTERP_WD lease, use first the buttons at the second line.",
@@ -1339,11 +1475,10 @@ class AcceptabilityGui(wx.Frame):
             message_supp = "."
             if len(steps) == 0:
                 steps = [1,10,11,2,3]
-                if self.toggle_state == True :
-                    message_supp = " AND scenario(s) vuln_ taken into account"
+                if self.toggle_state:
+                    message_supp = " with every steps AND scenario(s) vuln_ taken into account"
                     steps = [1,10,11,2,3,4]
                     if self._manager.OUT_VULN.exists:
-                        message_supp = " FOR scenario(s) (vuln_ taken into account)"
                         logging.info(_("Attention - The manager ONLY computes Vulnerability_scenario, as Vulnerability_baseline already computed."))
                         steps=[4]
                     else :
@@ -1355,23 +1490,17 @@ class AcceptabilityGui(wx.Frame):
                     if response == wx.ID_NO:
                         return
 
-                logging.info(_("No steps selected. By default every steps will be performed" + message_supp))
-                Vulnerability(str(self._manager.main_dir),
+                logging.info(_("No steps selected. By default computations will be performed" + message_supp))
+                check_fail = Vulnerability(str(self._manager.main_dir),
                             scenario=str(self._manager.scenario),
                             Study_area=str(self._manager.Study_area),
                             resolution=resolution,
                             steps=steps)
-                wx.MessageBox(
-                            "Vulnerability computed with every steps" + message_supp,
-                            "Information",
-                            wx.OK | wx.ICON_INFORMATION
-                            )
             else :
-                if self.toggle_state == True :
+                if self.toggle_state:
                     steps.append(4)
-                    message_supp = " AND scenario(s) vuln_ taken into account"
+                    message_supp = " with the selected steps AND scenario(s) vuln_ taken into account"
                     if self._manager.OUT_VULN.exists:
-                        message_supp = " FOR scenario(s) (vuln_ taken into account)"
                         logging.info(_("Attention - The manager ONLY computes Vulnerability_scenario, as Vulnerability_baseline already computed."))
                         steps=[4]
                     else :
@@ -1384,16 +1513,25 @@ class AcceptabilityGui(wx.Frame):
                     if response == wx.ID_NO:
                         return
 
-                Vulnerability(self._manager.main_dir,
+                check_fail = Vulnerability(self._manager.main_dir,
                             scenario=self._manager.scenario,
                             Study_area=self._manager.Study_area,
                             resolution=resolution,
                             steps=steps)
-                wx.MessageBox(
-                            "Vulnerability computed with the selected steps" + message_supp,
-                            "Information",
-                            wx.OK | wx.ICON_INFORMATION
-                            )
+                
+        if steps_vulnerability.APPLY_SCENARIOSVULN_BUG in check_fail :
+             wx.MessageBox(
+                        "Vulnerability NOT computed for scenarios\n Some vuln_ files did not have the required type (int8). They were not taken into account (see renamed files ended by its type (e.g vuln_..._Float32.tif) in CHANGE_VULNE)",
+                        "Error",
+                        wx.OK | wx.ICON_ERROR
+                        )
+        else:
+            wx.MessageBox(
+                        "Vulnerability computed" + message_supp,
+                        "Information - Success",
+                        wx.OK | wx.ICON_INFORMATION
+                        )
+            
         mapviewer_display(path, self.mapviewer)
 
     def OnAcceptability(self, e):
@@ -1401,7 +1539,7 @@ class AcceptabilityGui(wx.Frame):
         if self._manager is None:
             return
 
-        river_trace = self._manager.wich_river_trace()
+        river_trace = self._manager.wich_river_trace(self.toggle_state)
         if self.toggle_state == True and not os.path.isfile(str(self._manager.OUT_VULN_Stif)) and not os.path.isfile(str(river_trace)) :
             wx.MessageBox("Necessary files are missing, please ensure the DataBase or Vulnerability or Updating riverbed steps were performed. ","Error",  wx.OK | wx.ICON_ERROR )
             return
@@ -1417,7 +1555,7 @@ class AcceptabilityGui(wx.Frame):
         path = [self._manager.OUT_ACCEPT]
         if len(steps) == 0:
             steps = [1,2,3,4]
-            if self.toggle_state == True :
+            if self.toggle_state:
                 steps = [1,2,3,4,5]
                 message_supp = " AND scenario(s) vuln_ taken into account"
                 path = [self._manager.OUT_ACCEPT_Stif]
@@ -1428,7 +1566,7 @@ class AcceptabilityGui(wx.Frame):
 
                 if river_trace == self._manager.OUT_MASKED_RIVER : message_supp=message_supp +" WITH the _baseline riverbed trace."
                 if river_trace == self._manager.OUT_MASKED_RIVER_S :message_supp+= " WITH the _scenarios riverbed trace."
-            if self.toggle_resamp_state == True :
+            if self.toggle_resamp_state:
                 steps.append(6)
                 resampling = self._but_resampling.GetValue()
                 resolution = self.input_dx.GetLabel()
@@ -1439,18 +1577,27 @@ class AcceptabilityGui(wx.Frame):
                 message_supp+= f" It has been created for the resolution {resolution}m and the resampling size {resampling}m."
 
             logging.info(_("No steps selected. By default every steps will be performed."))
-            Acceptability(self._manager.main_dir,
+            done = Acceptability(self._manager.main_dir,
                         scenario=self._manager.scenario,
                         Study_area=self._manager.Study_area,
                         resample_size=resampling,
                         steps=steps)
-            wx.MessageBox(
-                        "Acceptability computed with every steps" + message_supp,
+            if len(done) == 0:
+                wx.MessageBox(
+                        "No acceptability computed with the selected steps" + message_supp,
                         "Information",
                         wx.OK | wx.ICON_INFORMATION
                         )
+            else :
+                
+                wx.MessageBox(
+                            "Acceptability computed with the selected steps" + message_supp,
+                            "Information",
+                            wx.OK | wx.ICON_INFORMATION
+                            )
+                mapviewer_display(path, self.mapviewer)
         else :
-            if self.toggle_state == True :
+            if self.toggle_state:
                 steps.append(5)
                 message_supp = " AND scenario(s) vuln_ taken into account"
                 if self._manager.OUT_ACCEPT.exists:
@@ -1458,10 +1605,10 @@ class AcceptabilityGui(wx.Frame):
                     logging.info(_('Acceptability_baseline not computed because it already exists.'))
                     message_supp = "FOR scenario(s) (vuln_taken into account)"
                 path = [self._manager.OUT_ACCEPT_Stif]
-                river_trace = self._manager.wich_river_trace()
+                river_trace = self._manager.wich_river_trace(self.toggle_state)
                 if river_trace == self._manager.OUT_MASKED_RIVER : message_supp =message_supp + " WITH the _baseline riverbed trace."
                 if river_trace == self._manager.OUT_MASKED_RIVER_S : message_supp =message_supp + " WITH the _scenarios riverbed trace."
-            if self.toggle_resamp_state == True :
+            if self.toggle_resamp_state:
                 resampling = self._but_resampling.GetValue()
                 steps.append(6)
 
@@ -1478,7 +1625,7 @@ class AcceptabilityGui(wx.Frame):
                         wx.OK | wx.ICON_INFORMATION
                         )
             else :
-
+                
                 wx.MessageBox(
                             "Acceptability computed with the selected steps" + message_supp,
                             "Information",