wolfhece 2.1.98__py3-none-any.whl → 2.1.100__py3-none-any.whl

wolfhece/PyDraw.py

@@ -24,6 +24,7 @@ try:
     import json
     import glob
     import traceback
+    from datetime import datetime, timedelta
 except ImportError as e:
     print(e)
     raise ImportError("Error importing wxPython, numpy, PIL, json, glob, traceback. Please check your installation.")
@@ -731,6 +732,372 @@ class DragdropFileTarget(wx.FileDropTarget):
 
         return True
 
+
+class Sim_Explorer(wx.Frame):
+
+    def __init__(self, parent, title, mapviewer:"WolfMapViewer", sim:Wolfresults_2D):
+
+        super(Sim_Explorer, self).__init__(parent, title=title, size=(150, 250), style = wx.DEFAULT_FRAME_STYLE & ~ (wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX))
+
+        self._panel = wx.Panel(self)
+
+        self.mapviewer = mapviewer
+        self.active_res2d:Wolfresults_2D = sim
+
+        main_sizer = wx.BoxSizer(wx.HORIZONTAL)
+
+        left_bar = wx.BoxSizer(wx.VERTICAL)
+        right_bar = wx.BoxSizer(wx.VERTICAL)
+
+        self._all_times_steps = self.active_res2d.get_times_steps()
+
+        # Right bar
+        # ---------
+
+        # Slider
+        self._slider_steps = wx.Slider(self._panel, minValue=1, maxValue=sim.get_nbresults(), style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_MIN_MAX_LABELS | wx.SL_LABELS)
+        self._slider_steps.Bind(wx.EVT_SLIDER, self.OnSliderSteps)
+        right_bar.Add(self._slider_steps, 1, wx.EXPAND | wx.ALL, 2)
+
+        # Explore by index
+        self._label_idx = wx.StaticText(self._panel, label=_('Index'))
+        right_bar.Add(self._label_idx, 1, wx.EXPAND | wx.ALL, 2)
+
+        self._step_idx = wx.ListBox(self._panel, choices=[str(i) for i in range(1, sim.get_nbresults()+1)], style=wx.LB_SINGLE)
+        self._step_idx.Bind(wx.EVT_LISTBOX, self.OnSelectIdxStep)
+        right_bar.Add(self._step_idx, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Explore by time
+        self._label_time = wx.StaticText(self._panel, label=_('Time [s]'))
+        right_bar.Add(self._label_time, 1, wx.EXPAND | wx.ALL, 2)
+
+        _now = datetime.now()
+        self._starting_date = datetime(year=_now.year, month=_now.month, day=_now.day, hour=0, minute=0, second=0)
+        self._texttime = wx.TextCtrl(self._panel, value=self._starting_date.strftime('%Y-%m-%d %H:%M:%S'))
+        right_bar.Add(self._texttime, 1, wx.EXPAND | wx.ALL, 5)
+        self._texttime.Bind(wx.EVT_TEXT, self.OnTextTime)
+
+        self._step_time = wx.ListBox(self._panel, choices=['{:.3f} - {}'.format(i, datetime.strftime(self._starting_date + timedelta(seconds=i), '%Y-%m-%d %H:%M:%S')) for i in self._all_times_steps[0]], style=wx.LB_SINGLE)
+        self._step_time.Bind(wx.EVT_LISTBOX, self.OnSelectNumStep)
+        right_bar.Add(self._step_time, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Explore by time step
+        self._label_steps = wx.StaticText(self._panel, label=_('Time step [-]'))
+        right_bar.Add(self._label_steps, 1, wx.EXPAND | wx.ALL, 2)
+
+        self._step_num = wx.ListBox(self._panel, choices=[str(i) for i in self._all_times_steps[1]], style=wx.LB_SINGLE)
+        self._step_num.Bind(wx.EVT_LISTBOX, self.OnSelectCurTime)
+        right_bar.Add(self._step_num, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Left bar
+        # --------
+
+        # Apply selected step
+        self._cmd_apply = wx.Button(self._panel, wx.ID_APPLY, _('Apply'))
+        self._cmd_apply.SetToolTip(_('Apply the selected parameters to the map'))
+        self._cmd_apply.Bind(wx.EVT_BUTTON, self.OnApply)
+        left_bar.Add(self._cmd_apply, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Update listbox from files on disk
+        self._cmd_update = wx.Button(self._panel, wx.ID_REFRESH, _('Update'))
+        self._cmd_update.SetToolTip(_('Update the list of available results based on the files on disk'))
+        self._cmd_update.Bind(wx.EVT_BUTTON, self.OnUpdate)
+        left_bar.Add(self._cmd_update, 1, wx.EXPAND | wx.ALL, 5)
+
+        #Plot
+        self._cmd_plot = wx.Button(self._panel, wx.ID_PREVIEW, _('Plot simulation informations'))
+        self._cmd_plot.SetToolTip(_('Plot synthesis of the simulation (computation time, time step, clock time, mostly dry mesh...)'))
+        self._cmd_plot.Bind(wx.EVT_BUTTON, self.OnPlot)
+        left_bar.Add(self._cmd_plot, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Next step
+        self._cmd_next = wx.Button(self._panel, wx.ID_FORWARD, _('Next'))
+        self._cmd_next.SetToolTip(_('Go to the next step -- using the selected mode'))
+        self._cmd_next.Bind(wx.EVT_BUTTON, self.OnNext)
+        left_bar.Add(self._cmd_next, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Previous step
+        self._cmd_prev = wx.Button(self._panel, wx.ID_BACKWARD, _('Previous'))
+        self._cmd_prev.SetToolTip(_('Go to the previous step -- using the selected mode'))
+        self._cmd_prev.Bind(wx.EVT_BUTTON, self.OnPrev)
+        left_bar.Add(self._cmd_prev, 1, wx.EXPAND | wx.ALL, 5)
+
+        # Check Mode movement
+        self._mode = wx.ListBox(self._panel, choices=['by time [s]', 'by time [hour]', 'by index', 'by time step'], style=wx.LB_SINGLE)
+        self._mode.SetToolTip(_('Select the mode to move through the simulation'))
+        self._mode.SetSelection(2)
+        self._interval = wx.TextCtrl(self._panel, value='1', style=wx.ALIGN_CENTER_HORIZONTAL)
+        self._interval.SetToolTip(_('Interval for the mode selected -- unit depends on the mode'))
+        self._interval.Bind(wx.EVT_TEXT, self.OnInterval)
+
+        left_bar.Add(self._mode, 1, wx.EXPAND | wx.ALL, 5)
+        left_bar.Add(self._interval, 0, wx.EXPAND | wx.ALL, 5)
+
+        self.Bind(wx.EVT_CLOSE, self.OnClose)
+
+        main_sizer.Add(left_bar, 1, wx.EXPAND | wx.ALL, 2)
+        main_sizer.Add(right_bar, 1, wx.EXPAND | wx.ALL, 2)
+
+        self._panel.SetSizer(main_sizer)
+        self._panel.SetAutoLayout(True)
+
+        self.MinSize = (450, 500)
+
+        self.Fit()
+        self.Show()
+
+        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf_logo2.bmp")))
+
+        self._set_all(0)
+
+    def OnPlot(self, event):
+        """ Create a scatter plot of all steps.
+
+        Major x_axis is time in seconds, Minor X-axis is time by date.
+
+        Plots:
+            - Computation time step (Dt)
+            - Computation steps (N)
+            - Clock time (s)
+            - Mostly dry mesh (N)
+
+        """
+
+        main_x = self._all_times_steps[0]
+        second_x = [self._starting_date + timedelta(seconds=i) for i in main_x]
+
+        if isinstance(self.active_res2d, wolfres2DGPU):
+
+            ax:list[Axes]
+            fig, ax= plt.subplots(5, 1, figsize=(10, 8))
+
+            ax[0].plot(main_x, self._all_times_steps[1], 'o-')
+            ax[0].set_ylabel(_('Computation\ntime step (N)'), fontsize=8)
+            ax[0].ticklabel_format(axis='y', style='sci', scilimits=(0,0))
+
+            ax[0].grid(which='both')
+            ax[0].set_xticks(main_x)
+            ax[0].set_xticklabels([])
+
+            secax:Axes = ax[0].secondary_xaxis('top')
+            secax.set_xlabel(_('Real date\n[Y-M-D H:M:S]'), fontsize=8)
+            secax.set_xticks(main_x)
+            secax.set_xticklabels([datetime.strftime(i, '%Y-%m-%d %H:%M') for i in second_x], fontsize=8)
+            secax.tick_params(axis='x', rotation=30)
+
+            ax[1].plot(main_x, self.active_res2d.all_dt, 'o-')
+            ax[1].set_ylabel(_('$\Delta t$ [s]'), fontsize=8)
+            ax[1].grid(which='both')
+            ax[1].set_xticks(main_x)
+            ax[1].set_xticklabels([])
+            ax[1].ticklabel_format(axis='y', style='sci', scilimits=(0,0))
+
+            ctime = self.active_res2d.all_clock_time
+            ax[2].plot(main_x, self.active_res2d.all_clock_time, 'o-')
+            ax[2].set_ylabel(_('Clock time [s]'), fontsize=8)
+            ax[2].grid(which='both')
+            ax[2].set_xticks([])
+            ax[2].set_xticks(main_x)
+            ax[2].set_xticklabels([])
+            ax[2].ticklabel_format(axis='y', style='sci', scilimits=(0,0))
+
+            # Fit a line on the (main_x - clock time) plot
+            # This will give a mean acceleration factor
+            # The inverse of the slope of the line is the accelaration factor
+            # The line is y = slope * x + intercept
+            from scipy.stats import linregress
+            slope, intercept, r_value, p_value, std_err = linregress(main_x, ctime)
+
+            # Plot the info on the ax[2]
+            msg = _('Acceleration factor:')
+            ax[2].text(0.5, 0.5, f'{msg} {1/slope:.2f}', transform=ax[2].transAxes, fontsize=12, verticalalignment='top')
+
+            ax[3].plot(main_x, self.active_res2d.all_wet_meshes, 'o-', color='blue')
+            ax[3].plot(main_x, self.active_res2d.all_mostly_dry_mesh, 'o-', color='green')
+            ax[3].set_ylabel(_('Wet and Mostly dry\nmeshes [N]'), fontsize=8)
+            ax[3].grid(which='both')
+            ax[3].set_xticks(main_x)
+            ax[3].set_xlabel([])
+            ax[3].ticklabel_format(axis='y', style='sci', scilimits=(0,0))
+
+            ax[4].plot(main_x, [i/j*100 if j>0 else 0 for i, j in zip(self.active_res2d.all_mostly_dry_mesh, self.active_res2d.all_wet_meshes)], 'o-', color='red')
+            ax[4].set_ylabel(_('Wet/Mostly dry\nmeshes [%]'), fontsize=8)
+            ax[4].grid(which='both')
+            ax[4].set_xticks(main_x)
+            ax[4].set_xlabel(_('Simulated time [s]'), fontsize=8)
+            ax[4].ticklabel_format(axis='y', style='sci', scilimits=(0,0))
+
+            fig.suptitle('Simulation {}'.format(self.active_res2d.idx), fontsize=10)
+
+            fig.tight_layout()
+            fig.show()
+
+    def OnInterval(self, event):
+        """ Change the interval """
+
+        try:
+            interv = float(self._interval.GetValue())
+            if interv <= 0:
+                interv = 1.
+                self._interval.SetValue('1')
+        except:
+            interv = 1
+            self._interval.SetValue('1')
+
+    def _find_next(self, idx:int):
+        """ Find the next step based on the mode and interval """
+
+        mode = int(self._mode.GetSelection())
+
+        if mode == 0:
+            # By time [s]
+            next_time = self._all_times_steps[0][idx] + float(self._interval.GetValue())
+            diff = [abs(next_time - i) for i in self._all_times_steps[0][idx:]]
+            next_idx = diff.index(min(diff)) + idx
+
+            return next_idx
+
+        elif mode == 1:
+            # By time [hour]
+            next_time = self._all_times_steps[0][idx] + float(self._interval.GetValue())*3600
+            diff = [abs(next_time - i) for i in self._all_times_steps[0][idx:]]
+            next_idx = diff.index(min(diff)) + idx
+
+            return next_idx
+
+        elif mode == 2:
+            # By index
+            next_idx = min(idx + int(self._interval.GetValue()), len(self._all_times_steps[0])-1)
+
+            return next_idx
+
+        elif mode == 3:
+            # By time step
+            next_idx = self._all_times_steps[1].index(self._all_times_steps[1][idx] + int(self._interval.GetValue()))
+            diff = [abs(next_idx - i) for i in self._all_times_steps[1][idx:]]
+            next_idx = diff.index(min(diff)) + idx
+
+            return next_idx
+
+    def _find_prev(self, idx:int):
+        """ Find the previous step based on the mode and interval """
+
+        mode = int(self._mode.GetSelection())
+
+        if mode == 0:
+            # By time [s]
+            prev_time = self._all_times_steps[0][idx] - float(self._interval.GetValue())
+            diff = [abs(prev_time - i) for i in self._all_times_steps[0][:idx]]
+            prev_idx = diff.index(min(diff))
+
+            return prev_idx
+
+        elif mode == 1:
+            # By time [hour]
+            prev_time = self._all_times_steps[0][idx] - float(self._interval.GetValue())*3600
+            diff = [abs(prev_time - i) for i in self._all_times_steps[0][:idx]]
+            prev_idx = diff.index(min(diff))
+
+            return prev_idx
+
+        elif mode == 2:
+            # By index
+            prev_idx = max(idx - int(self._interval.GetValue()), 0)
+
+            return prev_idx
+
+        elif mode == 3:
+            # By time step
+            prev_idx = self._all_times_steps[1].index(self._all_times_steps[1][idx] - int(self._interval.GetValue()))
+            diff = [abs(prev_idx - i) for i in self._all_times_steps[1][:idx]]
+            prev_idx = diff.index(min(diff))
+
+            return prev_idx
+
+    def OnNext(self, event):
+        """ Go to the next step """
+
+        selected_step = self._slider_steps.GetValue()-1
+        next_idx = self._find_next(selected_step)
+
+        if next_idx != selected_step:
+            self._set_all(next_idx)
+            self.Refresh(next_idx)
+
+    def OnPrev(self, event):
+        """ Go to the previous step """
+
+        selected_step = self._slider_steps.GetValue()-1
+        prev_idx = self._find_prev(selected_step)
+
+        if prev_idx != selected_step:
+            self._set_all(prev_idx)
+            self.Refresh(prev_idx)
+
+    def OnTextTime(self, event):
+        try:
+            self._starting_date = datetime.strptime(self._texttime.GetValue(), '%Y-%m-%d %H:%M:%S')
+            self._step_time.Set(['{:.3f} - {}'.format(i, datetime.strftime(self._starting_date + timedelta(seconds=i), '%Y-%m-%d %H:%M:%S')) for i in self._all_times_steps[0]])
+        except:
+            logging.info('Error while parsing the date')
+            pass
+
+    def OnClose(self, event):
+        """ Close the simulation explorer """
+
+        self.mapviewer._pop_sim_explorer(self.active_res2d)
+        self.Destroy()
+
+    def OnUpdate(self, event):
+        self._update()
+
+    def OnApply(self, event):
+        selected_step = self._slider_steps.GetValue()-1
+
+        self._cmd_apply.SetBackgroundColour(wx.Colour(255, 0, 0))  # Set button color to red
+        self._cmd_apply.Refresh()  # Refresh the button to apply the color change
+
+        self.Refresh(selected_step)
+
+        self._cmd_apply.SetBackgroundColour(wx.NullColour)  # Reset button color to default
+        self._cmd_apply.Refresh()  # Refresh the button to apply the color change
+
+    def _set_all(self, idx:int):
+        self._slider_steps.SetValue(idx+1)
+        self._step_idx.SetSelection(idx)
+        self._step_time.SetSelection(idx)
+        self._step_num.SetSelection(idx)
+
+    def Refresh(self, idx:int):
+        self.active_res2d.read_oneresult(idx)
+        self.active_res2d.set_currentview()
+        self.mapviewer.Refresh()
+
+    def OnSliderSteps(self, event):
+        selected_step = self._slider_steps.GetValue()
+        self._set_all(selected_step-1)
+
+    def OnSelectCurTime(self, event):
+        selected_time = self._step_num.GetSelection()
+        self._set_all(selected_time)
+
+    def OnSelectNumStep(self, event):
+        selected_step = self._step_time.GetSelection()
+        self._set_all(selected_step)
+
+    def OnSelectIdxStep(self, event):
+        selected_step = self._step_idx.GetSelection()
+        self._set_all(selected_step)
+
+    def _update(self):
+        nb = self.active_res2d.get_nbresults()
+        self._all_times_steps = self.active_res2d.get_times_steps()
+
+        self._slider_steps.SetMax(nb)
+        self._step_idx.Set([str(i) for i in range(1,nb+1)])
+        self._step_time.Set(['{:.3f} - {}'.format(i, datetime.strftime(self._starting_date + timedelta(seconds=i), '%Y-%m-%d %H:%M:%S')) for i in self._all_times_steps[0]])
+        self._step_num.Set([str(i) for i in self._all_times_steps[1]])
+
 class WolfMapViewer(wx.Frame):
     """
     Fenêtre de visualisation de données WOLF grâce aux WxWidgets
@@ -751,6 +1118,7 @@ class WolfMapViewer(wx.Frame):
     mytiles: list[Tiles]
     mypartsystems: list[Particle_system]
     myviewers3d:list[Wolf_Viewer3D]
+    sim_explorers: dict[Wolfresults_2D:Sim_Explorer]
 
     canvas: GLCanvas  # canvas OpenGL
     context: GLContext  # context OpenGL
@@ -1450,6 +1818,10 @@ class WolfMapViewer(wx.Frame):
         if self.menuwolf2d is None:
             self.menuwolf2d = wx.Menu()
 
+            self.menu2d_explore_results = self.menuwolf2d.Append(wx.ID_ANY, _("Explore time/index results"), _("Open a dialog to explore time/index results"))
+
+            self.menuwolf2d.AppendSeparator()
+
             self.menu2d_curentview = self.menuwolf2d.Append(wx.ID_ANY, _("Change current view"), _("Current view"))
             self.menu2d_lastres = self.menuwolf2d.Append(wx.ID_ANY, _("Read last result"), _("Current view"))
             self.menu2d_epsilon = self.menuwolf2d.Append(wx.ID_ANY, _("Set epsilon water depth"), _("Set the epsilon used in the mask"))
@@ -1462,11 +1834,11 @@ class WolfMapViewer(wx.Frame):
             self.menuwolf2d.AppendSeparator()
 
             self.menu2d_dangermap = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map"), _("Compute the danger map"))
-            self.menu2d_dangermaph = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map - only h"), _("Compute the danger map"))
+            self.menu2d_dangermaph = self.menuwolf2d.Append(wx.ID_ANY, _("Danger map - only h"), _("Compute the danger map - only waterdepth"))
 
             self.menuwolf2d.AppendSeparator()
 
-            self.menu2d_export_as = self.menuwolf2d.Append(wx.ID_ANY, _("Export results as..."), _("Export results as Geotif or Shapefile"))
+            self.menu2d_export_as = self.menuwolf2d.Append(wx.ID_ANY, _("Export results as..."), _("Export results as Geotif, Shapefile or Numpy arrays"))
 
             self.menuwolf2d.AppendSeparator()
             # Possible cache entries will be added after this separator
@@ -1659,6 +2031,41 @@ class WolfMapViewer(wx.Frame):
 
             self.active_array.reset_plot()
 
+    def _add_sim_explorer(self, which:Wolfresults_2D):
+        """ Add a step chooser """
+
+        if which in self.sim_explorers:
+            logging.warning(_('Step chooser already exists for this result'))
+            self.sim_explorers[which].Show()
+            self.sim_explorers[which].Raise()
+            self.sim_explorers[which].SetFocus()
+            self.sim_explorers[which].Center()
+            return
+
+        self.sim_explorers[which] = Sim_Explorer(self, which.idx, self, which)
+        self.sim_explorers[which]._set_all(which.current_result)
+
+    def _pop_sim_explorer(self, which:Wolfresults_2D):
+        """ Pop a step chooser """
+
+        if which in self.sim_explorers:
+            self.sim_explorers.pop(which)
+            logging.debug(_('Pop step chooser for result {}'.format(which.idx)))
+        else:
+            logging.warning(_('No step chooser for this result'))
+
+    def _update_sim_explorer(self, which:Wolfresults_2D = None):
+
+        if which is None:
+            if self.active_res2d is None:
+                logging.warning(_('No active 2D result -- Please activate a 2D result first'))
+                return
+
+            which = self.active_res2d
+
+        if which in self.sim_explorers:
+            self.sim_explorers[which]._set_all(which.current_result)
+
     def Onmenuwolf2d(self, event: wx.MenuEvent):
 
         id = event.GetId()
@@ -1678,6 +2085,13 @@ class WolfMapViewer(wx.Frame):
 
             self.export_results_as()
 
+        elif itemlabel == _("Explore time/index results"):
+            if self.active_res2d is None:
+                logging.warning(_('No active 2D result ! -- Please activate a 2D result first'))
+                return
+
+            self._add_sim_explorer(self.active_res2d)
+
         elif itemlabel == _("Change current view"):
 
             # Change view for results
@@ -3278,6 +3692,7 @@ class WolfMapViewer(wx.Frame):
         self.mywmsfore = []
         self.myres2D = []
         self.myviewers3d = []
+        self.sim_explorers = {}
 
         # liste des éléments modifiable dans l'arbre
         self.all_lists = [self.myarrays, self.myvectors, self.myclouds, self.mytri, self.myothers, self.myviews, self.myres2D, self.mytiles, self.mypartsystems, self.myviewers3d]
@@ -4683,6 +5098,8 @@ class WolfMapViewer(wx.Frame):
             else:
                 return
 
+        logging.info(_('This could take some time for large area...\n Take a coffee and relax!'))
+
         bounds = array.get_bounds()
 
         # align bounds on chunk_size
@@ -4776,7 +5193,7 @@ class WolfMapViewer(wx.Frame):
         array.reset_plot()
         self.Paint()
 
-        logging.info(_('Filling done'))
+        logging.info(_('Filling done !'))
 
     def count_active_array_from_laz(self, array:WolfArray = None, used_codes:list = [], chunk_size:float = 500.):
         """ Fill active array with laz data
@@ -5043,6 +5460,7 @@ class WolfMapViewer(wx.Frame):
 
             curmodel.read_oneresult()
             curmodel.set_currentview()
+            self._update_sim_explorer(curmodel)
 
         self.Refresh()
         self.currently_readresults = False
@@ -5061,6 +5479,8 @@ class WolfMapViewer(wx.Frame):
 
                 curmodel.read_oneresult(which)
                 curmodel.set_currentview()
+                self._update_sim_explorer(curmodel)
+
 
         self.Refresh()
         self.currently_readresults = False
@@ -5079,6 +5499,7 @@ class WolfMapViewer(wx.Frame):
 
             curmodel.read_previous()
             curmodel.set_currentview()
+            self._update_sim_explorer(curmodel)
 
         self.Refresh()
         self.currently_readresults = False
@@ -5120,6 +5541,8 @@ class WolfMapViewer(wx.Frame):
 
             curmodel.read_next()
             curmodel.set_currentview()
+            self._update_sim_explorer(curmodel)
+
 
         self.Refresh()
         self.currently_readresults = False
@@ -5402,6 +5825,8 @@ class WolfMapViewer(wx.Frame):
             linkedarrays = self.get_linked_arrays()
 
             with wx.MultiChoiceDialog(None, _('Choose the arrays to plot'), _('Arrays'), [curarray for curarray in list(linkedarrays.keys())]) as dlg:
+                dlg.SetSelections(range(len(linkedarrays)))
+
                 if dlg.ShowModal() == wx.ID_CANCEL:
                     dlg.Destroy()
                     return
@@ -6443,31 +6868,40 @@ class WolfMapViewer(wx.Frame):
 
         logging.info(_('Filtering done !'))
 
-    def export_results_as(self, which:Literal['geotiff','shape'] = None, multiband:bool = None):
+    def export_results_as(self, which:Literal['geotiff','shape','numpy'] = None, multiband:bool = None):
         """
-        Export des résultats WOLF2D vers le format GeoTiff
-        On attend que les matrices ".hbin" aient été chargées dans l'interface
+        Export des résultats WOLF2D vers différents formats.
+        Au moins un résultat doit être chargé pour pouvoir être exporté.
         """
 
         dlg = wx.DirDialog(self,_('Choose output directory'), style = wx.DD_DIR_MUST_EXIST)
         ret=dlg.ShowModal()
 
         if ret == wx.ID_CANCEL:
+            logging.warning(_('Abort!'))
             dlg.Destroy()
             return
 
         outdir = dlg.GetPath()
         dlg.Destroy()
 
-        if which not in ['geotiff','shape']:
-            dlg = wx.SingleChoiceDialog(self,_('Choose output format'), _('Format'), ['Geotiff','Shape file'])
-            dlg.ShowModal()
+        if which not in ['geotiff','shape','numpy']:
+            dlg = wx.SingleChoiceDialog(self,_('Choose output format'), _('Format'), ['Geotiff','Shape file','Numpy array'])
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_CANCEL:
+                logging.warning(_('Abort!'))
+                dlg.Destroy()
+                return
+
             sel = dlg.GetSelection()
 
             if sel == 0:
                 which = 'geotiff'
-            else:
+            elif sel == 1:
                 which = 'shape'
+            else:
+                which = 'numpy'
 
             dlg.Destroy()
 
@@ -6490,7 +6924,12 @@ class WolfMapViewer(wx.Frame):
 
         dlg = wx.MultiChoiceDialog(self,_('Choose results to export'), _('Results'), choices=loaded_res)
         dlg.SetSelections([idx for idx, res in enumerate(loaded_res) if self.get_obj_from_id(res, drawtype=draw_type.RES2D).plotted])
-        dlg.ShowModal()
+        ret = dlg.ShowModal()
+        if ret == wx.ID_CANCEL:
+            logging.warning(_('Abort!'))
+            dlg.Destroy()
+            return
+
         sel = dlg.GetSelections() # Get a list if integers
         sel_res = [self.get_obj_from_id(loaded_res[cursel], drawtype=draw_type.RES2D) for cursel in sel] # convert to list of objects
 
@@ -6516,7 +6955,13 @@ class WolfMapViewer(wx.Frame):
 
         dlg = wx.MultiChoiceDialog(self,_('Choose fields to export'), _('Fields'), choices= [str(field[0]) for field in fields])
         dlg.SetSelections([idx for idx, field in enumerate(fields) if field[1]])
-        dlg.ShowModal()
+        ret = dlg.ShowModal()
+
+        if ret == wx.ID_CANCEL:
+            logging.warning(_('Abort!'))
+            dlg.Destroy()
+            return
+
         sel_fields = dlg.GetSelections() # Get a list if integers
         dlg.Destroy()
 
@@ -7136,16 +7581,27 @@ class WolfMapViewer(wx.Frame):
                 #     myhead.dy = 1.
 
             else:
+
+                dlg = wx.TextEntryDialog(self,_('Spatial step size (assuming dx == dy) ?'), value='1')
+                ret=dlg.ShowModal()
+
+                if ret == wx.ID_CANCEL:
+                    dlg.Destroy()
+                    return -1
+
+                tmpdx = float(dlg.GetValue())
+                dlg.Destroy()
+
+                dy = dx
+
                 myxyz = xyz_scandir(filename, None)
                 myhead = header_wolf()
 
-                myhead.origx = np.min(myxyz[:, 0]) - .5
-                myhead.origy = np.min(myxyz[:, 1]) - .5
+                myhead.origx = np.min(myxyz[:, 0]) - dx/2.
+                myhead.origy = np.min(myxyz[:, 1]) - dy/2.
 
-                myhead.dx = 1.
-                myhead.dy = 1.
-                tmpdx = 1.
-                tmpdy = 1.
+                myhead.dx = dx
+                myhead.dy = dy
 
                 myhead.nbx = int(np.max(myxyz[:, 0]) - myhead.origx) + 1
                 myhead.nby = int(np.max(myxyz[:, 1]) - myhead.origy) + 1
@@ -7163,10 +7619,6 @@ class WolfMapViewer(wx.Frame):
 
             newobj.mask_data(newobj.nullvalue)
 
-            # if min(tmpdx, tmpdy) != 1.:
-            #     newobj.rebin(min(tmpdx, tmpdy))
-            #     newobj.mask_data(newobj.nullvalue)
-
             newobj.change_gui(self)
             newobj.updatepalette(0)
             self.myarrays.append(newobj)
@@ -9595,7 +10047,25 @@ class WolfMapViewer(wx.Frame):
             logging.debug(_('Alt is down'))
 
         if ctrldown or altdown:
-            if key == wx.WXK_F2 and not shiftdown:
+            if key == 60 and shiftdown: #'>'
+                if self.active_array is not None:
+                    if self.active_array.SelectionData is not None:
+                        self.active_array.SelectionData.dilate_contour_selection(1)
+                        self.active_array.reset_plot()
+            elif key == 60 and not shiftdown: #'<'
+                if self.active_array is not None:
+                    if self.active_array.SelectionData is not None:
+                        self.active_array.SelectionData.erode_contour_selection()
+                        self.active_array.reset_plot()
+
+            elif key == wx.WXK_F2 and ctrldown and altdown and shiftdown:
+
+                if self.active_res2d is None:
+                    logging.info(_('Please activate a simulation before search a specific result'))
+
+                self._add_sim_explorer(self.active_res2d)
+
+            elif key == wx.WXK_F2 and not shiftdown:
 
                 if self.active_res2d is not None:
                     nb = self.active_res2d.get_nbresults()
@@ -9609,20 +10079,11 @@ class WolfMapViewer(wx.Frame):
                     self.active_res2d.set_currentview()
                     self.Refresh()
 
+                    self._update_sim_explorer()
+
                 else:
                     logging.info(_('Please activate a simulation before search a specific result'))
 
-            elif key == 60 and shiftdown: #'>'
-                if self.active_array is not None:
-                    if self.active_array.SelectionData is not None:
-                        self.active_array.SelectionData.dilate_contour_selection(1)
-                        self.active_array.reset_plot()
-            elif key == 60 and not shiftdown: #'<'
-                if self.active_array is not None:
-                    if self.active_array.SelectionData is not None:
-                        self.active_array.SelectionData.erode_contour_selection()
-                        self.active_array.reset_plot()
-
             elif key == wx.WXK_F2 and shiftdown:
 
                 if self.active_res2d is not None:
@@ -9648,6 +10109,8 @@ class WolfMapViewer(wx.Frame):
                     self.active_res2d.set_currentview()
                     self.Refresh()
 
+                    self._update_sim_explorer()
+
                 else:
                     logging.info(_('Please activate a simulation before searching a specific result'))
 
@@ -9665,6 +10128,7 @@ class WolfMapViewer(wx.Frame):
                     self.active_particle_system.current_step = nb-1
                     self.Refresh()
                     self._update_mytooltip()
+                    self._update_sim_explorer()
 
                 else:
                     logging.info(_('Please activate a particle system before searching a specific result'))
@@ -9692,6 +10156,7 @@ class WolfMapViewer(wx.Frame):
                     self.active_particle_system.current_step = choices.index(keyvalue)
                     self.Refresh()
                     self._update_mytooltip()
+                    self._update_sim_explorer()
 
                 else:
                     logging.info(_('Please activate a simulation before search a specific result'))
@@ -10062,7 +10527,13 @@ class WolfMapViewer(wx.Frame):
                     self.active_array.myops.select_node_by_node()
 
                 if self.active_res2d is not None:
-                    self.active_res2d.properties.select_node_by_node()
+                    if self.active_array is not None:
+                        msg = wx.MessageDialog(None, _('Do you want to select the nodes of the active result ?'), _('Select nodes'), wx.YES_NO | wx.ICON_QUESTION)
+                        ret = msg.ShowModal()
+                        if ret == wx.ID_YES:
+                            self.active_res2d.properties.select_node_by_node()
+                    else:
+                        self.active_res2d.properties.select_node_by_node()
 
                 if self.active_array is None and self.active_res2d is None:
                     logging.warning(_('No active array or result 2D to select node by node !'))