wolfhece 2.1.97__py3-none-any.whl → 2.1.99__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][:i]]
+            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][:i]]
+            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][:i]]
+            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
@@ -1217,6 +1585,14 @@ class WolfMapViewer(wx.Frame):
     #     # print(msg)
     #     return 0
 
+    @property
+    def viewer_name(self):
+        return self.GetTitle()
+
+    @viewer_name.setter
+    def viewer_name(self, value):
+        self.SetTitle(value)
+
     @property
     def wxlogging(self):
         return self._wxlogging
@@ -1442,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"))
@@ -1454,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
@@ -1651,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()
@@ -1670,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
@@ -2450,6 +2872,16 @@ class WolfMapViewer(wx.Frame):
         else:
             return config[ConfigurationKeys.TICKS_SIZE]
 
+    @property
+    def assembly_mode(self) -> str:
+        """ Return the assembly mode from configs """
+
+        config = self.get_configuration()
+        if config is None:
+            return 'square'
+        else:
+            return config[ConfigurationKeys.ASSEMBLY_IMAGES]
+
     @property
     def ticks_bounds(self) -> bool:
         """ Return the ticks bounds from configs """
@@ -3041,7 +3473,12 @@ class WolfMapViewer(wx.Frame):
 
             return myimage
 
-    def save_canvasogl(self, fn:str='', mpl:bool=True, ds:float=0., dpi:int= 300):
+    def save_canvasogl(self,
+                       fn:str='',
+                       mpl:bool=True,
+                       ds:float=0.,
+                       dpi:int= 300,
+                       add_title:bool = False):
         """
         Sauvegarde de la fenêtre d'affichage dans un fichier
 
@@ -3151,6 +3588,8 @@ class WolfMapViewer(wx.Frame):
 
                 # self.Paint()
 
+                if add_title:
+                    ax.set_title(self.viewer_name)
                 fig.set_size_inches(12, 10)
                 fig.tight_layout()
 
@@ -3253,23 +3692,37 @@ 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]
 
+        self.menu_options = wx.Menu()
+        self._change_title = self.menu_options.Append(wx.ID_ANY, _('Change title'), _('Change title of the window'))
+        self.Bind(wx.EVT_MENU, self.OnChangeTitle, self._change_title)
+
         if self.get_configuration() is not None:
             # see PyGui.py if necessary
 
-            self.menu_options = wx.Menu()
             self.menubar.Append(self.menu_options, _('Options'))
             self.option_global = self.menu_options.Append(wx.ID_ANY,_("Global"),_("Modify global options"))
             self.Bind(wx.EVT_MENU, self.GlobalOptionsDialog, self.option_global)
 
-            self.menu_1to9 =self.menu_options.Append(wx.ID_ANY, _('Colors for selections 1->9'), _('Selections'))
-            self.Bind(wx.EVT_MENU, self.colors1to9.change_colors, self.menu_1to9)
+        self.menu_1to9 =self.menu_options.Append(wx.ID_ANY, _('Colors for selections 1->9'), _('Selections'))
+        self.Bind(wx.EVT_MENU, self.colors1to9.change_colors, self.menu_1to9)
 
         self.Show(True)
 
+    def OnChangeTitle(self, e):
+        """
+        Change the title of the window
+        """
+
+        dlg = wx.TextEntryDialog(None, _('Enter the new title'), _('Change title'), self.GetTitle())
+        if dlg.ShowModal() == wx.ID_OK:
+            self.SetTitle(dlg.GetValue())
+        dlg.Destroy()
+
     def OnSize(self, e):
         """
         Redimensionnement de la fenêtre
@@ -4645,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
@@ -4738,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
@@ -5005,6 +5460,7 @@ class WolfMapViewer(wx.Frame):
 
             curmodel.read_oneresult()
             curmodel.set_currentview()
+            self._update_sim_explorer(curmodel)
 
         self.Refresh()
         self.currently_readresults = False
@@ -5023,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
@@ -5041,6 +5499,7 @@ class WolfMapViewer(wx.Frame):
 
             curmodel.read_previous()
             curmodel.set_currentview()
+            self._update_sim_explorer(curmodel)
 
         self.Refresh()
         self.currently_readresults = False
@@ -5082,6 +5541,8 @@ class WolfMapViewer(wx.Frame):
 
             curmodel.read_next()
             curmodel.set_currentview()
+            self._update_sim_explorer(curmodel)
+
 
         self.Refresh()
         self.currently_readresults = False
@@ -5364,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
@@ -6094,9 +6557,9 @@ class WolfMapViewer(wx.Frame):
             autoscale = False
 
             fn, ds = self.save_canvasogl(mpl=True)
-            all_images = self.save_linked_canvas(fn[:-4], mpl= True, ds= ds)
 
-            self.assembly_images(all_images)
+            all_images = self.save_linked_canvas(fn[:-4], mpl= True, ds= ds, add_title= True)
+            self.assembly_images(all_images, mode= self.assembly_mode)
 
         elif itemlabel == _('Copy image...'):
             autoscale = False
@@ -6405,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()
 
@@ -6452,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
 
@@ -6478,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()
 
@@ -6666,13 +7149,20 @@ class WolfMapViewer(wx.Frame):
 
         return linkedarrays
 
-    def save_linked_canvas(self, fn, mpl=True, ds=0.):
-        """ Save canvas of all linked viewers """
+    def save_linked_canvas(self, fn:str, mpl:bool= True, ds:float= 0., add_title:bool= True) -> tuple[(str, float), str]:
+        """ Save canvas of all linked viewers
+
+        :param fn: filename without extension -- '.png' will be added
+        :param mpl: save as matplotlib image
+        :param ds: Ticks size for matplotlib image
+        :return: list of tuple ((filename, ds), viewer_name)
+        """
 
+        fn = str(fn)
         ret = []
         if self.linked:
             for idx, curel in enumerate(self.linkedList):
-                ret.append(curel.save_canvasogl(fn + '_' + str(idx) + '.png', mpl, ds))
+                ret.append((curel.save_canvasogl(fn + '_' + str(idx) + '.png', mpl, ds, add_title= add_title), self.viewer_name))
 
         return ret
 
@@ -6680,50 +7170,55 @@ class WolfMapViewer(wx.Frame):
         """ Assembly images
 
         Every image has the same size (width, height)
+
+        :param all_images: list of tuple (filename, viewer_name)
+        :param mode: 'horizontal', 'vertical', 'square'
         """
 
+        assert mode in ['horizontal', 'vertical', 'square', 0, 1, 2], 'Mode not recognized'
+
         from PIL import Image
 
-        images = [Image.open(fn) for fn, ds in all_images]
+        images = [Image.open(fn) for (fn, ds), viewername in all_images]
 
         widths, heights = zip(*(i.size for i in images))
 
-        if mode == 'horizontal':
+        if mode == 'horizontal' or mode==0:
 
             total_width = sum(widths)
             max_height = max(heights)
 
-            new_im = Image.new('RGB', (total_width, max_height))
+            new_im = Image.new('RGB', (total_width, max_height), color=(255,255,255))
 
             x_offset = 0
             for im in images:
                 new_im.paste(im, (x_offset,0))
                 x_offset += im.size[0]
 
-            new_im.save(all_images[0][0][:-4] + '_assembly.png')
+            new_im.save(all_images[0][0][0][:-4] + '_assembly.png')
 
-        elif mode == 'vertical':
+        elif mode == 'vertical' or mode==1:
 
             total_height = sum(heights)
             max_width = max(widths)
 
-            new_im = Image.new('RGB', (max_width, total_height))
+            new_im = Image.new('RGB', (max_width, total_height), color=(255,255,255))
 
             y_offset = 0
             for im in images:
                 new_im.paste(im, (0, y_offset))
                 y_offset += im.size[1]
 
-            new_im.save(all_images[0][0][:-4] + '_assembly.png')
+            new_im.save(all_images[0][0][0][:-4] + '_assembly.png')
 
-        elif mode == 'square':
+        elif mode == 'square' or mode==2:
 
             max_width = max(widths)
             max_height = max(heights)
 
             nb_hor = int(np.ceil(np.sqrt(len(images))))
 
-            new_im = Image.new('RGB', (max_width*nb_hor, max_height*nb_hor))
+            new_im = Image.new('RGB', (max_width*nb_hor, max_height*nb_hor), color=(255,255,255))
 
             x_offset = 0
             y_offset = 0
@@ -6734,7 +7229,9 @@ class WolfMapViewer(wx.Frame):
                     y_offset += im.size[1]
                     x_offset = 0
 
-            new_im.save(all_images[0][0][:-4] + '_assembly.png')
+            new_im.save(all_images[0][0][0][:-4] + '_assembly.png')
+
+        return new_im
 
     def thread_update_blender(self):
         print("Update blender")
@@ -9380,7 +9877,7 @@ class WolfMapViewer(wx.Frame):
         #     \n \
         #     CTRL+Q : Quit application\n \
         #     CTRL+U : Import GLTF/GLB\n \
-        #     CTRL+C : Set copy source / Copy canvas to Clipboard\n \
+        #     CTRL+C : Set copy source\n \
         #     CTRL+V : Paste selected values\n \
         #     CTRL+ALT+V ou ALTGr+V : Paste/Recopy selection\n \
         #     CTRL+L : chargement d'une matrice sur base du nom de fichier de la tile\n \
@@ -9416,7 +9913,8 @@ class WolfMapViewer(wx.Frame):
                      'F7': _('Drawing : refresh'),
                      'Arrows': _('Drawing : lateral movements'),
                      'c or C': _('Drawing : copy canvas to Clipboard wo axes'),
-                     'CTRL+C': _('Drawing : copy canvas to Clipboard as Matplotlib image'),
+                     'ALT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image'),
+                     'ALT+SHIFT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image with axes - linked arrays'),
 
                      'CTRL+o': _('Results : increase transparency of the current result'),
                      'CTRL+O': _('Results : decrease transparency of the current result'),
@@ -9542,7 +10040,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()
@@ -9556,20 +10072,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:
@@ -9595,6 +10102,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'))
 
@@ -9612,6 +10121,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'))
@@ -9639,6 +10149,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'))
@@ -9707,11 +10218,45 @@ class WolfMapViewer(wx.Frame):
             elif key == wx.WXK_DOWN:
                 self.downobj()
 
-            elif key == ord('C') and altdown and not ctrldown:
+            elif key == ord('C') and altdown and not ctrldown and not shiftdown:
                 # ALT+C
                 #Copie du canvas dans le clipboard pour transfert vers autre application
                 self.copy_canvasogl()
 
+            elif key == ord('C') and altdown and not ctrldown and shiftdown:
+                # ALT+SHIFT+C
+                # Copie du canvas dans le clipboard pour transfert vers autre application
+                # Copie des canvas liés
+
+                from tempfile import TemporaryDirectory
+
+                logging.info(_('Creating images'))
+
+                with TemporaryDirectory() as tmpdirname:
+                    all_images = self.save_linked_canvas(Path(tmpdirname) / 'fig', mpl= True, ds= self.ticks_size, add_title= True)
+                    im_assembly = self.assembly_images(all_images, mode= self.assembly_mode)
+
+                logging.info(_('Creating images - done'))
+
+                # Copy image to clipboard
+                if im_assembly is not None:
+                    if wx.TheClipboard.Open():
+
+                        #création d'un objet bitmap wx
+                        wxbitmap = wx.Bitmap().FromBuffer(im_assembly.width, im_assembly.height, im_assembly.tobytes())
+
+                        # objet wx exportable via le clipboard
+                        dataobj = wx.BitmapDataObject()
+                        dataobj.SetBitmap(wxbitmap)
+
+                        wx.TheClipboard.SetData(dataobj)
+                        wx.TheClipboard.Close()
+                        logging.info(_('Image copied to clipboard'))
+                    else:
+                        logging.error(_('Cannot open the clipboard'))
+                else:
+                    logging.error(_('No image to copy to clipboard'))
+
             elif key == ord('C') and ctrldown and not altdown:
                 # CTRL+C
                 if self.active_array is None:
@@ -9975,7 +10520,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 !'))