wolfhece 2.2.27__py3-none-any.whl → 2.2.29__py3-none-any.whl

wolfhece/scenario/config_manager.py

@@ -110,6 +110,8 @@ class GPU_2D_file(Enum):
     MANNING      = _gpu_file('manning'   , np.float32, GPU_2D_file_extensions.NPY.value)
     COMPUTATION_MASK = _gpu_file('nap'   , np.uint8  , GPU_2D_file_extensions.NPY.value)
     INFILTRATION = _gpu_file('infiltration_zones', np.int32, GPU_2D_file_extensions.NPY.value)
+    ROOF         = _gpu_file('bridge_roof'       , np.float32, GPU_2D_file_extensions.NPY.value)
+    # DECK         = _gpu_file('bridge_deck'        , np.float32, GPU_2D_file_extensions.NPY.value)
 
 # répertoire de sortie des simulations GPU
 RESULT_DIR = 'simul_gpu_results'
@@ -240,6 +242,8 @@ class Config_Manager_2D_GPU:
         self._epsilon = 0.01
         self._filter_independent = True
 
+        self._active_simulation = None
+
         self.load_data()
 
     def find_wolfgpu(self):
@@ -559,15 +563,172 @@ class Config_Manager_2D_GPU:
 
         logging.info(_('Hydrographs...'))
         hydro = self.get_hydrographs()
-        nb = hydro[0].data.shape[1]
+        if len(hydro) == 0:
+            logging.info(_('No hydrographs found !'))
+            log += _('No hydrographs found !') + '\n'
+        else:
+            try:
+                nb = hydro[0].data.shape[1]
+
+                logging.info(_('Number of hydrographs : {}'.format(len(hydro))))
+                for curhydro in hydro:
+                    if curhydro.data.shape[1] != nb:
+                        loclog = _('Bad number of columns for {} !'.format(curhydro[0]._filename))
+                        log += loclog + '\n'
+                        logging.warning(loclog)
+            except Exception as e:
+                logging.error(_('Error while checking hydrographs: {}').format(e))
+                log += _('Error while checking hydrographs: {}').format(e) + '\n'
+
+        return log
+
+    def check_one_simulation(self) -> str:
+        """
+        Check consistency of one simulation
+
+        """
+
+        if self._active_simulation is None:
+            logging.error(_('No active simulation !'))
+            return _('No active simulation !')
+
+        logging.info(_('Checking consistency of one simulation...\n'))
 
-        logging.info(_('Number of hydrographs : {}'.format(len(hydro))))
-        for curhydro in hydro:
-            if curhydro.data.shape[1] != nb:
-                loclog = _('Bad number of columns for {} !'.format(curhydro[0]._filename))
+        logging.info(_('NPY files...'))
+        numpyfiles = self._active_simulation[GPU_2D_file_extensions.NPY.value]
+        numpynames = [file.name.lower() for file in numpyfiles]
+
+        logging.info(_('Number of numpy files : {}'.format(len(numpyfiles))))
+
+        if self._header.nbx == 0 or self._header.nby == 0:
+            logging.error(_('No header found !'))
+            logging.info(_('Trying to get header from first numpy file...'))
+            try:
+                wa = WolfArray(numpyfiles[0])
+                self._header = wa.get_header()
+            except Exception as e:
+                logging.error(_('Error while getting header from first numpy file: {}').format(e))
+                return _('Error while getting header from first numpy file: {}').format(e)
+
+        log = ''
+        for curnpy in numpyfiles:
+
+            # test if the shape of the numpy file is the same as the tif file
+            # using memmap to avoid loading the whole array in memory -> faster
+            arr = np.lib.format.open_memmap(curnpy, mode='r')
+
+            if arr.shape != (self._header.nbx, self._header.nby):
+                loclog = _('Bad shape for {} !'.format(curnpy))
                 log += loclog + '\n'
                 logging.warning(loclog)
 
+            del(arr)
+
+        logging.info(_('Hydrographs...'))
+        hydro = self.get_hydrographs()
+        if len(hydro) == 0:
+            logging.info(_('No hydrographs found !'))
+            log += _('No hydrographs found !') + '\n'
+        else:
+            try:
+                nb = hydro[0].data.shape[1]
+
+                logging.info(_('Number of hydrographs : {}'.format(len(hydro))))
+                for curhydro in hydro:
+                    if curhydro.data.shape[1] != nb:
+                        loclog = _('Bad number of columns for {} !'.format(curhydro[0]._filename))
+                        log += loclog + '\n'
+                        logging.warning(loclog)
+            except Exception as e:
+                logging.error(_('Error while checking hydrographs: {}').format(e))
+                log += _('Error while checking hydrographs: {}').format(e) + '\n'
+
+        for curfile in GPU_2D_file:
+            if curfile.value.extension == '.npy':
+                if curfile.value.name + curfile.value.extension not in numpynames:
+                    loclog = _('Missing file {} !').format(curfile.value.name + curfile.value.extension)
+                    log += loclog + '\n'
+                    logging.warning(loclog)
+                else:
+                    try:
+                        wa = WolfArray(numpyfiles[numpynames.index(curfile.value.name + curfile.value.extension)])
+                        if wa.dtype != curfile.value.type:
+                            loclog = _('Bad dtype for {} ! Expected {}, got {}').format(
+                                curfile.value.name + curfile.value.extension,
+                                curfile.value.type, wa.dtype)
+                            log += loclog + '\n'
+                            logging.warning(loclog)
+                        del(wa)
+                    except Exception as e:
+                        loclog = _('Error while checking {}: {}').format(
+                            curfile.value.name + curfile.value.extension, e)
+                        log += loclog + '\n'
+                        logging.error(loclog)
+
+        if 'nap.npy' in numpynames:
+            nap =  WolfArray(numpyfiles[numpynames.index('nap.npy')])
+        else:
+            nap = None
+            logging.error(_('No nap file found !'))
+            log += _('No nap file found !') + '\n'
+
+        if nap is not None:
+            if 'infiltration_zones.npy' in numpynames:
+                # Check if infiltration zones are consistent
+                infil_zones = WolfArray(numpyfiles[numpynames.index('infiltration_zones.npy')])
+
+                if np.any(infil_zones.array[nap.array == 0] != 0):
+                    loclog = _('Infiltration zones are not consistent with the nap file !')
+                    log += loclog + '\n'
+
+                # find all non zero infiltration zones
+                non_zero_infil_zones = list(set(np.unique(infil_zones.array[nap.array == 1])))
+                if len(non_zero_infil_zones) == 0:
+                    loclog = _('No infiltration zones found !')
+                    log += loclog + '\n'
+                else:
+                    if non_zero_infil_zones[0] == 0:
+                        #pop
+                        non_zero_infil_zones.pop(0)
+                    if len(non_zero_infil_zones) == 0:
+                        loclog = _('No infiltration zones found !')
+                        log += loclog + '\n'
+
+                    elif non_zero_infil_zones[0] !=1:
+                        loclog = _('Infiltration zones should start at 1 ! Found {} instead.').format(non_zero_infil_zones[0])
+                        log += loclog + '\n'
+                        logging.warning(loclog)
+
+                        # increments
+                        if not all([non_zero_infil_zones[i] - non_zero_infil_zones[i-1] == 1 for i in range(1, len(non_zero_infil_zones))]):
+                            loclog = _('Infiltration zones are not consecutive !')
+                            log += loclog + '\n'
+                            logging.warning(loclog)
+                del(infil_zones)
+
+            if 'bathymetry.npy' in numpynames:
+                # Check if infiltration zones are consistent
+                bath = WolfArray(numpyfiles[numpynames.index('bathymetry.npy')])
+
+                if np.any(bath.array[nap.array == 0] != 99999.):
+                    loclog = _("Some bathymetry's cells are different of 99999 outside the computation domain !\n")
+                    loclog += _('This may lead to unexpected results !')
+                    log += loclog + '\n'
+
+                del(bath)
+
+            for file in ['h.npy', 'qx.npy', 'qy.npy']:
+                if file in numpynames:
+                    # Check if infiltration zones are consistent
+                    bath = WolfArray(numpyfiles[numpynames.index(file)])
+
+                    if np.any(bath.array[nap.array == 0] != 0.):
+                        loclog = _("Some cells are different of 0.0 outside the computation domain in {}!\n").format(file)
+                        loclog += _('This may lead to unexpected results !')
+                        log += loclog + '\n'
+
+                    del(bath)
+
         return log
 
     # Analyze files
@@ -671,7 +832,13 @@ class Config_Manager_2D_GPU:
             ok &= (GPU_2D_file.PARAMETERS.value.name+GPU_2D_file.PARAMETERS.value.extension).lower() in [cur.name.lower() for cur in curdict[GPU_2D_file_extensions.JSON.value]]
 
             if ok:
-                json_data = json.load(open(curdict['path'] / (GPU_2D_file.PARAMETERS.value.name+GPU_2D_file.PARAMETERS.value.extension), 'r'))
+                try:
+                    json_data = json.load(open(curdict['path'] / (GPU_2D_file.PARAMETERS.value.name+GPU_2D_file.PARAMETERS.value.extension), 'r'))
+                except json.JSONDecodeError as e:
+                    logging.error(_('Error decoding JSON file: {}').format(e))
+                    curdict['missing'].append(GPU_2D_file_extensions.JSON.value)
+                    ok = False
+                    return
 
         else:
             curdict['missing'].append(GPU_2D_file_extensions.JSON.value)
@@ -1182,6 +1349,22 @@ class Config_Manager_2D_GPU:
         else:
             logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
 
+    def create_void_dtm(self):
+        """ create void dtm file """
+        if (self.workingdir / 'bathymetry.tif').exists():
+            locheader = self.get_header()
+            dtm = WolfArray(srcheader=locheader, whichtype= WOLF_ARRAY_FULL_SINGLE)
+            dtm.array.data[:,:] = 99999.
+            dtm.nullvalue = 99999.
+            dtm.write_all(str(self.workingdir / 'dtm.tif'))
+
+            if (self.workingdir / 'dtm.tif').exists():
+                logging.info(_('dtm.tif created and set to 99999. ! -- Please edit it !'))
+            else:
+                logging.error(_("dtm.tif not created ! --  Does 'bathymetry.tif' or any '.tif' file exist in the root directory ?"))
+        else:
+            logging.error(_("No 'bathymetry.tif' file found in the root directory !"))
+
     def create_void_roof(self):
         """ create void roof file """
 
@@ -1382,6 +1565,7 @@ class Config_Manager_2D_GPU:
                 logging.error(_('Infiltration .tif must be a full integer array ! -- The array will be ignored !'))
                 infiltration = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_INTEGER)
                 infiltration.array.data[:,:] = 0
+
         else:
             infiltration = WolfArray(srcheader=bat.get_header(), whichtype= WOLF_ARRAY_FULL_INTEGER)
             infiltration.array.data[:,:] = 0
@@ -1494,6 +1678,20 @@ class Config_Manager_2D_GPU:
                     else:
                         cursim.qy = np.zeros((self._header.nbx, self._header.nby), dtype=np.float32)
 
+
+            # check if infiltration array is strictly inside nap
+            if not np.all(cursim.nap[infiltration.array.data[infiltration.array.data > 0]] == 1):
+                logging.warning(_('Infiltration zones must be strictly inside the NAP !'))
+                logging.warning(_('Infiltration zones outside NAP will be set to 0 !'))
+
+                #count number of infiltration zones outside NAP
+                nb_outside = np.sum(infiltration.array.data[(infiltration.array.data > 0) & (cursim.nap == 0)])
+                logging.warning(_('Number of infiltration zones outside NAP: {}').format(nb_outside))
+                # index infiltration zones outside NAP
+                indices = list(set(infiltration.array.data[(infiltration.array.data > 0) & (cursim.nap == 0)]))
+                logging.warning(_('Indices of infiltration zones outside NAP: {}').format(indices))
+                infiltration.array.data[(infiltration.array.data > 0) & (cursim.nap == 0)] = 0
+
             cursim.infiltration_zones = np.asarray(infiltration.array.data, dtype=np.int32)
 
             if roof.nbnotnull == 0:
@@ -1753,10 +1951,18 @@ class UI_Manager_2D_GPU():
         self._reload.Bind(wx.EVT_BUTTON,self.onupdate_structure)
         self._reload.SetToolTip(_('reScan the directory and reload the entire structure'))
 
+        tif_sizer = wx.BoxSizer(wx.HORIZONTAL)
         self._create_void_infil = wx.Button(self._frame,label = _('Create .tif infiltration zones'))
         self._create_void_infil.Bind(wx.EVT_BUTTON,self.oncreate_void_infil)
         self._create_void_infil.SetToolTip(_('Create a void infiltration zones file based on bathymetry.tif'))
 
+        self._create_dtm = wx.Button(self._frame,label = _('Create .tif DTM'))
+        self._create_dtm.Bind(wx.EVT_BUTTON,self.oncreate_dtm)
+        self._create_dtm.SetToolTip(_('Create a DTM file based on bathymetry.tif\n\n - bathymetry.tif must be present in the root directory'))
+
+        tif_sizer.Add(self._create_void_infil, 1, wx.EXPAND)
+        tif_sizer.Add(self._create_dtm, 1, wx.EXPAND)
+
         bridge_sizer = wx.BoxSizer(wx.HORIZONTAL)
         self._create_void_roof = wx.Button(self._frame,label = _('Create .tif bridge/culvert roof elevation'))
         self._create_void_roof.Bind(wx.EVT_BUTTON,self.oncreate_void_roof)
@@ -1797,6 +2003,10 @@ class UI_Manager_2D_GPU():
         self._checkconsistency.Bind(wx.EVT_BUTTON,self.oncheck_consistency)
         self._checkconsistency.SetToolTip(_('Check consistency of the scenario\n\n - bathymetry.tif\n - manning.tif\n - infiltration.tif\n - hydrographs\n - initial conditions\n - boundary conditions\n - scripts'))
 
+        self._checkonesimulation = wx.Button(self._frame,label = _('Check one simulation'))
+        self._checkonesimulation.Bind(wx.EVT_BUTTON,self.oncheck_one_simulation)
+        self._checkonesimulation.SetToolTip(_('Check consistency of one simulation'))
+
         self._createsim = wx.Button(self._frame,label = _('Create simulation(s)'))
         self._createsim.Bind(wx.EVT_BUTTON,self.oncreate_simulation)
         self._createsim.SetToolTip(_('Create simulation(s) from selected hydrographs'))
@@ -1840,14 +2050,19 @@ class UI_Manager_2D_GPU():
 
         # buttons -> sizer
         sizer_buttons.Add(self._reload,1,wx.EXPAND)
-        sizer_buttons.Add(self._create_void_infil,1,wx.EXPAND)
+        sizer_buttons.Add(tif_sizer,1,wx.EXPAND)
         sizer_buttons.Add(bridge_sizer,1,wx.EXPAND)
         sizer_buttons.Add(self._create_void_scripts,1,wx.EXPAND)
         sizer_buttons.Add(self._check_prefix,1,wx.EXPAND)
         sizer_buttons.Add(self._create_vrt,1,wx.EXPAND)
         sizer_buttons.Add(self._translate_vrt,1,wx.EXPAND)
         sizer_buttons.Add(self._apply_scripts,1,wx.EXPAND)
-        sizer_buttons.Add(self._checkconsistency,1,wx.EXPAND)
+
+        _sizer_check = wx.BoxSizer(wx.HORIZONTAL)
+        _sizer_check.Add(self._checkconsistency, 1, wx.EXPAND)
+        _sizer_check.Add(self._checkonesimulation, 1, wx.EXPAND)
+
+        sizer_buttons.Add(_sizer_check,1,wx.EXPAND)
         sizer_buttons.Add(self._create_vec,1,wx.EXPAND)
         sizer_buttons.Add(self.listsims,1,wx.EXPAND)
         sizer_buttons.Add(self._createsim,1,wx.EXPAND)
@@ -1910,6 +2125,12 @@ class UI_Manager_2D_GPU():
         self._parent.create_void_infil()
         self.reload()
 
+    def oncreate_dtm(self, e:wx.MouseEvent):
+        """ Création d'un fichier DTM vide """
+
+        self._parent.create_void_dtm()
+        self.reload()
+
     def oncreate_void_roof(self, e:wx.MouseEvent):
         """ Création d'un fichier de toit de pont vide """
 
@@ -2101,6 +2322,40 @@ class UI_Manager_2D_GPU():
         else:
             self._txtctrl.WriteText(log)
 
+    def oncheck_one_simulation(self, e:wx.MouseEvent):
+        """ Vérification de la cohérence d'une simulation
+        """
+        self._txtctrl.Clear()
+        log = self._parent.check_one_simulation()
+        if log == '':
+            self._txtctrl.WriteText("\n\n".join([_("All seems fine !")]))
+        else:
+            self._txtctrl.WriteText("\n\n".join([log]))
+
+        # Info on Python Environment and wolfgpu Path and version
+        # -------------------------------------------------------
+
+        import sys
+        # Python Environment
+        self._txtctrl.write(_('\nPython Environment\n'))
+        self._txtctrl.write('-------------------\n')
+        self._txtctrl.write('Python version : {}\n'.format(sys.version))
+        self._txtctrl.write('Python path : {}\n'.format(sys.executable))
+        self._txtctrl.write('Python version info : {}\n'.format(sys.version_info))
+
+        # Test if wolfgpu.exe exists in script directory
+        # wolfgpu Path and version
+        self._txtctrl.write('\nWolfgpu Path and version\n')
+        self._txtctrl.write('------------------------\n')
+
+        wolfgpu = self._parent.wolfgpu
+        if wolfgpu.exists():
+            self._txtctrl.write('Wolfgpu.exe found in : {}\n'.format(self._parent.wolfgpu.parent))
+        else:
+            self._txtctrl.write('Wolfgpu.exe not found !\n')
+            self._parent.wolfgpu = None
+
+
     def oncheck_consistency(self,e:wx.MouseEvent):
         """ Vérification de la cohérence des fichiers """
 
@@ -2401,10 +2656,12 @@ class UI_Manager_2D_GPU():
         self._txtctrl.SetBackgroundColour(wx.WHITE)
         self._txtctrl.SetForegroundColour(wx.BLACK)
 
+        self._parent._active_simulation = None
         if isinstance(mydata, dict):
             self._txtctrl.write(_('Yous have selected : {}\n\n'.format(str(mydata['path']))))
 
             if mydata[IS_SIMUL]:
+                self._parent._active_simulation = mydata
                 self._txtctrl.write(_('GPU SIMULATION\n\n'))
 
                 if ctrl and not shift and not alt:

wolfhece/ui/wolf_multiselection_collapsiblepane.py

@@ -211,6 +211,8 @@ class Wolf_MultipleSelection(wx.Dialog):
             assert len(self.delete_if_transfer) == len(values_dict), "delete_if_transfer must be a list of len(values_dict)"
             for i, values in enumerate(values_dict.values()):
                 assert isinstance(self.delete_if_transfer[i], bool), "delete_if_transfer must be a list of boolean"
+        else:
+            self.delete_if_transfer = None
 
         super().__init__(parent, title=title)
 
@@ -339,6 +341,145 @@ class Wolf_MultipleSelection(wx.Dialog):
         if self.callback is not None:
             self.callback(self)
 
+class Wolf_CompareArrays_Selection(Wolf_MultipleSelection):
+    """
+    Dialog with multiple 'collapsiblepanes' containing 2 lists to select multiple items
+    This class is a specific case of Wolf_MultipleSelection for comparing arrays
+    """
+    def __init__(self,
+                 parent,
+                 title,
+                 values_dict:dict,
+                 callback = None,
+                 info:str='',
+                 cmdApply:bool=False,
+                 styles = wx.LB_EXTENDED,
+                 destroyOK = False,
+                 **kwargs):
+        """
+        :param parent : wx.Window
+        :param title : str - title of the frame
+        :param values_dict : dict - {'label1':[item1, item2, ...], 'label2':[item1, item2, ...], ...}
+        :param callback : function - callback function when OK or Apply button is pressed
+        :param info : str - information to display upper the collapsiblepanes
+        :param cmdApply : bool - if True, Apply button is displayed
+        :param styles : wx.ListBox styles - wx constant or list of wx constants
+        :param kwargs : dict - other arguments for wx.Frame (example : max_selected_items=[1, 2, 3], delete_if_transfer=[True, False, True])
+        """
+        super().__init__(parent=parent,
+                         title=title,
+                         values_dict=values_dict,
+                         callback=callback,
+                         info=info,
+                         cmdApply=cmdApply,
+                         styles=styles,
+                         destroyOK=destroyOK,
+                         max_selected_items=[1]*len(values_dict),
+                         delete_if_transfer=[True]*len(values_dict),
+                         **kwargs)
+        
+        # add some UI specific to the compare arrays selection
+
+        # textbox for a threshold value
+        self.threshold_label = wx.StaticText(self, label="Threshold value [m]:")
+        self.threshold_value = wx.TextCtrl(self, value="0.01", style=wx.TE_PROCESS_ENTER | wx.TE_CENTER)
+        self.threshold_value.Bind(wx.EVT_TEXT_ENTER, self._on_threshold_enter)
+        self.threshold_value.Bind(wx.EVT_KILL_FOCUS, self._on_threshold_enter)
+        self.threshold_value.SetToolTip("Enter a threshold value - All differences below this threshold will be considered as equal")
+        # add the threshold label and value to the sizer
+        sizer = self.GetSizer()
+
+        sizer_threshold = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_threshold.Add(self.threshold_label, proportion=0, flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5)
+        sizer_threshold.Add(self.threshold_value, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
+        sizer.Add(sizer_threshold, proportion=0, flag=wx.EXPAND | wx.ALL, border=5)
+
+        # textbox for a minimal area value
+        self.min_area_label = wx.StaticText(self, label="Minimal area value [m²]:")
+        self.min_area_value = wx.TextCtrl(self, value="2.0", style=wx.TE_PROCESS_ENTER | wx.TE_CENTER)
+        self.min_area_value.Bind(wx.EVT_TEXT_ENTER, self._on_min_area_enter)    
+        self.min_area_value.Bind(wx.EVT_KILL_FOCUS, self._on_min_area_enter)
+        self.min_area_value.SetToolTip("Enter a minimal area value - All patches below this area will be ignored")
+        # add the minimal area label and value to the sizer
+        sizer_min_area = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_min_area.Add(self.min_area_label, proportion=0, flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5)
+        sizer_min_area.Add(self.min_area_value, proportion=1, flag=wx.EXPAND | wx.ALL, border=5)
+        sizer.Add(sizer_min_area, proportion=0, flag=wx.EXPAND | wx.ALL, border=5)
+        # Maximum patches to include in the report
+        self.max_patches_label = wx.StaticText(self, label="Maximum patches to include in the report:")
+        self.max_patches_value = wx.TextCtrl(self, value="10", style=wx.TE_PROCESS_ENTER | wx.TE_CENTER)
+        self.max_patches_value.Bind(wx.EVT_TEXT_ENTER, self._on_max_patches_enter)
+        self.max_patches_value.Bind(wx.EVT_KILL_FOCUS, self._on_max_patches_enter)
+        self.max_patches_value.SetToolTip("Enter a maximum number of patches to include in the report - If more patches are found, only the first ones will be included")
+        # add the maximum patches label and value to the sizer
+        sizer_max_patches = wx.BoxSizer(wx.HORIZONTAL)
+        sizer_max_patches.Add(self.max_patches_label, proportion=0, flag=wx.ALIGN_CENTER_VERTICAL | wx.ALL, border=5)
+        sizer_max_patches.Add(self.max_patches_value, proportion=1, flag= wx.EXPAND | wx.ALL, border=5)
+        sizer.Add(sizer_max_patches, proportion=0, flag=wx.EXPAND | wx.ALL, border=5)
+        # add the sizer to the main sizer
+        self.SetSizer(sizer)
+        self.Fit()
+        self.Layout()
+
+
+    def _on_threshold_enter(self, event):
+        """ Callback when the threshold value is changed """
+        try:
+            value = float(self.threshold_value.GetValue())
+            if value < 0:
+                self.threshold_value.SetValue("0.01")
+        except ValueError as e:
+            wx.MessageBox(f"Invalid threshold value: {e}", "Error", wx.OK | wx.ICON_ERROR)
+            self.threshold_value.SetValue("0.01")
+        event.Skip()
+
+    def _on_min_area_enter(self, event):
+        """ Callback when the minimal area value is changed """
+        try:
+            value = float(self.min_area_value.GetValue())
+            if value < 0:
+                self.min_area_value.SetValue("2.0")
+        except ValueError as e:
+            wx.MessageBox(f"Invalid minimal area value: {e}", "Error", wx.OK | wx.ICON_ERROR)
+            self.min_area_value.SetValue("2.0")
+        event.Skip()
+
+    def _on_max_patches_enter(self, event):
+        """ Callback when the maximum patches value is changed """
+        try:
+            value = int(self.max_patches_value.GetValue())
+            if value < 1:
+                self.max_patches_value.SetValue("10")
+        except ValueError as e:
+            wx.MessageBox(f"Invalid maximum patches value: {e}", "Error", wx.OK | wx.ICON_ERROR)
+            self.max_patches_value.SetValue("10")
+        event.Skip()
+
+    def get_threshold(self):
+        """ Get the threshold value """
+        try:
+            return float(self.threshold_value.GetValue())
+        except ValueError:
+            wx.MessageBox("Invalid threshold value", "Error", wx.OK | wx.ICON_ERROR)
+            return 0.01
+        
+    def get_min_area(self):
+        """ Get the minimal area value """
+        try:
+            return float(self.min_area_value.GetValue())
+        except ValueError:
+            wx.MessageBox("Invalid minimal area value", "Error", wx.OK | wx.ICON_ERROR)
+            return 2.0
+        
+    def get_max_patches(self):
+        """ Get the maximum patches value """
+        try:
+            return int(self.max_patches_value.GetValue())
+        except ValueError:
+            wx.MessageBox("Invalid maximum patches value", "Error", wx.OK | wx.ICON_ERROR)
+            return 10
+        
+
 if __name__ == "__main__":
     # Utilisation de la classe Wolf_MultipleSelection
     app = wx.App()
@@ -351,6 +492,17 @@ if __name__ == "__main__":
                                 callback=None,
                                 styles=[wx.LB_SINGLE, wx.LB_EXTENDED, wx.LB_EXTENDED],
                                 max_selected_items=[1, -1, -1],)
-    frame.ShowModal()
+    
+    fram2 = Wolf_CompareArrays_Selection(None,
+                                         title="Exemple de Wolf_CompareArrays_Selection",
+                                            values_dict={'domain':["Item 1", "Item 2", "Item 3", "Item 4"],
+                                                        'u':["Item 3", "Item 4", "Item 5", "Item 6"],
+                                                        'v':["Item v1", "Item v2", "Item v3", "Item v4"]},
+                                            info="You can define :                     \n   - the domain\n   - u\n   -v",
+                                            callback=None,
+                                            styles=[wx.LB_SINGLE, wx.LB_SINGLE, wx.LB_SINGLE],
+                                            destroyOK=True)
+    
+    fram2.ShowModal()
     pass
     app.MainLoop()