wolfhece 2.1.119__py3-none-any.whl → 2.1.120__py3-none-any.whl

wolfhece/PyDraw.py

@@ -75,7 +75,7 @@ try:
     from .xyz_file import xyz_scandir, XYZFile
     from .mesh2d import wolf2dprev
     from .PyPalette import wolfpalette
-    from .wolfresults_2D import Wolfresults_2D, views_2D
+    from .wolfresults_2D import Wolfresults_2D, views_2D, Extractable_results
     from .PyTranslate import _
     from .PyVertex import cloud_vertices, getIfromRGB
     from .RatingCurve import SPWMIGaugingStations, SPWDCENNGaugingStations
@@ -114,7 +114,7 @@ try:
     from .lagrangian.particle_system_ui import Particle_system_to_draw as Particle_system
     from .opengl.py3d import Wolf_Viewer3D
     from .pyGui1D import GuiNotebook1D
-    from .matplotlib_fig import Matplotlib_Figure as MplFig
+    from .matplotlib_fig import Matplotlib_Figure as MplFig, PRESET_LAYOUTS
 except ImportError as e:
     print(e)
     raise ImportError("Error importing pyshields, pyviews, PyConfig, GraphProfile, pybridges, tools_mpl, wolf_tiles, lagrangian.particle_system_ui, opengl.py3d, pyGui1D. Please check your installation.")
@@ -170,6 +170,48 @@ PROJECT_GROUP_KEYS = {PROJECT_ACTION : {'which': 'compare_arrays'},
                       PROJECT_LINK_VEC_ARRAY : {'id - id vector': 'id of array/wolf2d/gpu2d - id of vector to link (only 1 vector in 1 zone)'},
                     }
 
+class MplFigViewer(MplFig):
+
+    def __init__(self, layout = None, idx:str='',
+                 mapviewer:"WolfMapViewer" = None,
+                 caption:str = '', size:tuple = (800, 600),
+                 style:int = wx.DEFAULT_FRAME_STYLE ^ wx.RESIZE_BORDER):
+
+        super().__init__(layout)
+        self._mapviewer = mapviewer
+        self._idx = idx
+
+        self.SetTitle(caption)
+
+        self.SetSize(size)
+
+        dpi = self.fig.get_dpi()
+        size_x = (size[0]-16)/dpi
+        size_y = (size[1]-240)/dpi
+
+        self.fig.set_size_inches(size_x, size_y)
+
+
+        self.SetWindowStyle(style)
+
+        self.Bind(wx.EVT_CLOSE, self.OnClose)
+
+    def OnClose(self, event):
+        """ Close the window """
+
+        if self.mapviewer is not None:
+            self.mapviewer.destroy_fig_by_id(self.idx)
+        else:
+            self.Destroy()
+
+    @property
+    def mapviewer(self):
+        return self._mapviewer
+
+    @property
+    def idx(self):
+        return self._idx
+
 class Memory_View():
     """ Memory view """
 
@@ -1154,6 +1196,166 @@ class Sim_Explorer(wx.Frame):
         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 Select_Begin_end_interval_step(wx.Dialog):
+    """ wx.frame to select the begin and end of the interval to extract """
+
+    def __init__(self, parent, title, sim:Wolfresults_2D, checkbox:bool = False):
+
+        super(Select_Begin_end_interval_step, self).__init__(parent, title=title, size=(500, 350), style = wx.DEFAULT_FRAME_STYLE & ~ (wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX))
+
+        # ajout d'un slider pour choisir le début et la fin de l'intervalle -> selrange
+        # ajout d'un slider pour choisir le pas de l'intervalle
+
+
+        # + les mêmes informations mais sous forme de TextCtrl
+
+        # ajout d'un bouton pour valider
+        # ajout d'un bouton pour annuler
+
+        self._panel = wx.Panel(self)
+
+        sizer = wx.BoxSizer(wx.VERTICAL)
+
+        self.begin = 1
+        self.end = sim.get_nbresults(True)
+        self.step = 1
+        self.check_all = True
+        self.check_violin = False
+
+        self._slider_begin = wx.Slider(self._panel, minValue=self.begin, maxValue=self.end, style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_MIN_MAX_LABELS | wx.SL_LABELS)
+        self._slider_begin.SetToolTip(_('Select the first result to export'))
+        self._slider_begin.SetValue(self.begin)
+
+        self._slider_begin.Bind(wx.EVT_SLIDER, self.OnSliderBegin)
+        sizer.Add(self._slider_begin, 1, wx.EXPAND | wx.ALL, 2)
+
+        self._slider_end = wx.Slider(self._panel, minValue=self.begin, maxValue=self.end, style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_MIN_MAX_LABELS | wx.SL_LABELS)
+        self._slider_end.SetToolTip(_('Select the last result to export - If step is > 1, this value will be forced if not already captured'))
+        self._slider_end.SetValue(self.end)
+        self._slider_end.Bind(wx.EVT_SLIDER, self.OnSliderEnd)
+
+        sizer.Add(self._slider_end, 1, wx.EXPAND | wx.ALL, 2)
+
+        sizer_txt1 = wx.BoxSizer(wx.HORIZONTAL)
+        self._label_range = wx.StaticText(self._panel, label=_('Range'))
+        self._text_range = wx.TextCtrl(self._panel, value='1 - {}'.format(sim.get_nbresults(True)))
+
+        sizer_txt1.Add(self._label_range, 0, wx.EXPAND | wx.ALL, 2)
+        sizer_txt1.Add(self._text_range, 1, wx.EXPAND | wx.ALL, 2)
+
+        sizer.Add(sizer_txt1, 0, wx.EXPAND | wx.ALL, 2)
+
+        self._slider_step = wx.Slider(self._panel, minValue=1, maxValue=sim.get_nbresults(True), style=wx.SL_HORIZONTAL | wx.SL_AUTOTICKS | wx.SL_MIN_MAX_LABELS | wx.SL_LABELS)
+        self._slider_step.SetToolTip(_('Export one result every N steps'))
+        self._slider_step.Bind(wx.EVT_SLIDER, self.OnSliderStep)
+        sizer.Add(self._slider_step, 1, wx.EXPAND | wx.ALL, 2)
+
+        sizer_txt2 = wx.BoxSizer(wx.HORIZONTAL)
+        self._label_step = wx.StaticText(self._panel, label=_('Step'))
+        self._text_step = wx.TextCtrl(self._panel, value='1')
+
+        sizer_txt2.Add(self._label_step, 0, wx.EXPAND | wx.ALL, 2)
+        sizer_txt2.Add(self._text_step, 0, wx.EXPAND | wx.ALL, 2)
+
+        sizer.Add(sizer_txt2, 0, wx.EXPAND | wx.ALL, 2)
+
+        sizer_but = wx.BoxSizer(wx.HORIZONTAL)
+        self._cmd_apply = wx.Button(self._panel, wx.ID_APPLY, _('Apply'))
+        self._cmd_apply.Bind(wx.EVT_BUTTON, self.OnApply)
+
+        self._cmd_ok = wx.Button(self._panel, wx.ID_OK, _('OK'))
+        self._cmd_ok.Bind(wx.EVT_BUTTON, self.OnOK)
+
+        self._cmd_cancel = wx.Button(self._panel, wx.ID_CANCEL, _('Cancel'))
+        self._cmd_cancel.Bind(wx.EVT_BUTTON, self.OnCancel)
+
+        sizer_but.Add(self._cmd_apply, 1, wx.EXPAND | wx.ALL, 2)
+        sizer_but.Add(self._cmd_ok, 1, wx.EXPAND | wx.ALL, 2)
+        sizer_but.Add(self._cmd_cancel, 1, wx.EXPAND | wx.ALL, 2)
+
+        sizer.Add(sizer_but, 1, wx.EXPAND | wx.ALL, 2)
+
+        if checkbox:
+            sizer_check = wx.BoxSizer(wx.HORIZONTAL)
+            self._check_all = wx.CheckBox(self._panel, label=_('Statistics and values'), style=wx.CHK_2STATE)
+            self._check_all.SetToolTip(_('If checked, export statistics and all values for each step'))
+            self._check_all.SetValue(True)
+            self._check_all.Bind(wx.EVT_CHECKBOX, self.OnCheckAll)
+            sizer_check.Add(self._check_all, 1, wx.EXPAND | wx.ALL, 2)
+            sizer.Add(sizer_check, 1, wx.EXPAND | wx.ALL, 2)
+
+            self._check_violin= wx.CheckBox(self._panel, label=_('Violin plot (experimental)'), style=wx.CHK_2STATE)
+            self._check_violin.SetToolTip(_('If checked, create a violin plot for each step'))
+            self._check_violin.SetValue(False)
+            self._check_violin.Bind(wx.EVT_CHECKBOX, self.OnCheckViolin)
+            sizer_check.Add(self._check_violin, 1, wx.EXPAND | wx.ALL, 2)
+
+        self._panel.SetSizer(sizer)
+
+        self.CenterOnScreen()
+
+        self.SetIcon(wx.Icon(str(Path(__file__).parent / "apps/wolf_logo2.bmp")))
+
+        self.Show()
+
+
+    def OnCheckAll(self, event):
+        self.check_all = self._check_all.IsChecked()
+
+    def OnCheckViolin(self, event):
+        self.check_violin = self._check_violin.IsChecked()
+
+    def OnSliderBegin(self, event):
+
+        self.begin = min(self._slider_begin.GetValue(), self.end)
+        self._slider_begin.SetValue(self.begin)
+        self._text_range.SetValue('{} - {}'.format(self.begin, self.end))
+
+    def OnSliderEnd(self, event):
+
+        self.end = max(self._slider_end.GetValue(), self.begin)
+        self._slider_end.SetValue(self.end)
+        self._text_range.SetValue('{} - {}'.format(self.begin, self.end))
+
+    def OnSliderStep(self, event):
+
+        self.step = self._slider_step.GetValue()
+        self._text_step.SetValue(str(self.step))
+
+    def OnApply(self, event):
+
+        try:
+            txt_begin, txt_end = self._text_range.GetValue().split('-')
+        except:
+            self._text_range.SetValue('{} - {}'.format(self.begin, self.end))
+
+        txt_step = self._text_step.GetValue()
+
+        try:
+            if self.step != int(txt_step):
+                self._slider_step.SetValue(int(txt_step))
+        except:
+            logging.error('Error while parsing the step')
+            return
+
+        try:
+            if int(txt_begin) != self.begin or int(txt_end) != self.end:
+                self._slider_begin.SetRange(int(txt_begin), int(txt_end))
+        except:
+            logging.error('Error while parsing the range')
+            return
+
+    def OnOK(self, event):
+        self.Hide()
+
+    def OnCancel(self, event):
+        self.begin = -1
+        self.end = -1
+        self.step = -1
+
+        self.Hide()
+
 class WolfMapViewer(wx.Frame):
     """
     Fenêtre de visualisation de données WOLF grâce aux WxWidgets
@@ -1177,6 +1379,8 @@ class WolfMapViewer(wx.Frame):
     myviewers3d:list[Wolf_Viewer3D]
     mylazdata:list[Wolf_LAZ_Data]
 
+    mymplfigs:list[MplFigViewer]
+
     sim_explorers: dict[Wolfresults_2D:Sim_Explorer]
 
     canvas: GLCanvas  # canvas OpenGL
@@ -1209,6 +1413,8 @@ class WolfMapViewer(wx.Frame):
     active_weir : Weir
     active_laz : Wolf_LAZ_Data
 
+    active_fig: MplFigViewer
+
     def __init__(self,
                  wxparent = None,
                  title:str = _('Default Wolf Map Viewer'),
@@ -1474,34 +1680,44 @@ class WolfMapViewer(wx.Frame):
                                            _("Linear colormap"))
 
         self.analyzemenu = wx.Menu()
-        plotvect = self.analyzemenu.Append(wx.ID_ANY, _("Plot active vector..."),
+
+        self.analyzeplot = wx.Menu()
+        self.analyzeexport = wx.Menu()
+
+        plotvect = self.analyzeplot.Append(wx.ID_ANY, _("Plot active vector..."),
                                            _("Plot the active vector and linked arrays"))
-        plotpoly = self.analyzemenu.Append(wx.ID_ANY, _("Plot active polygons..."),
+        plotpoly = self.analyzeplot.Append(wx.ID_ANY, _("Plot active polygons..."),
                                            _("Plot the active polygons and linked arrays"))
 
-        masksimul = self.analyzemenu.Append(wx.ID_ANY, _("Load and apply mask (nap)..."),
-                                           _("Apply mask from sim2D"))
-        filterinund = self.analyzemenu.Append(wx.ID_ANY, _("Filter inundation arrays..."),
-                                           _("Filter arrays"))
+        self.analyzeplot.AppendSeparator()
+
+        self.analyzemenu.Append(wx.ID_ANY,_('Plot...'),self.analyzeplot)
+        self.analyzemenu.Append(wx.ID_ANY,_('Export...'),self.analyzeexport)
+        self.analyzemenu.AppendSeparator()
+
+        masksimul = self.analyzemenu.Append(wx.ID_ANY, _("Load and apply mask (nap)..."), _("Apply mask from sim2D"))
+        filterinund = self.analyzemenu.Append(wx.ID_ANY, _("Filter inundation arrays..."), _("Filter arrays"))
+
         # Plot hydrographs
-        self.menuHydrographs = wx.Menu()
-        self.analyzemenu.Append(wx.ID_ANY,_('Integrate Q...'),self.menuHydrographs)
-        plotqvect = self.menuHydrographs.Append(wx.ID_ANY, _("Plot integrated Q along active vector..."),
-                                           _("Integrate Q along the active vector and plot"))
-        plotqvect = self.menuHydrographs.Append(wx.ID_ANY, _("Plot integrated Q along active zone..."),
-                                           _("Integrate Q along the active zone and plot"))
-        self.menuHydrographs.AppendSeparator()
-        exportqvect = self.menuHydrographs.Append(wx.ID_ANY, _("Export integrated Q along active vector..."),
-                                             _("Integrate Q along the active vector and export"))
-        exportqvect = self.menuHydrographs.Append(wx.ID_ANY, _("Export integrated Q along all vectors in active zone..."),
-                                                _("Integrate Q along ALL VECTORS of the active zone and export"))
-
-        plothselect = self.analyzemenu.Append(wx.ID_ANY, _("Plot stats unknown (selected nodes)..."),
-                                           _("Compute stats and plot on the selected nodes"))
-        plothvector = self.analyzemenu.Append(wx.ID_ANY, _("Plot stats unknown (inside active vector)..."),
-                                           _("Compute stats and plot on nodes inside the active vector"))
-        plothzone = self.analyzemenu.Append(wx.ID_ANY, _("Plot stats unknown (inside active zone)..."),
-                                           _("Compute stats and plot on nodes inside the active zone"))
+
+        plotqvect = self.analyzeplot.Append(wx.ID_ANY, _("Plot integrated Q along active vector..."), _("Integrate Q along the active vector and plot"))
+        plotqvect = self.analyzeplot.Append(wx.ID_ANY, _("Plot integrated Q along active zone..."), _("Integrate Q along the active zone and plot"))
+
+        self.analyzeplot.AppendSeparator()
+
+
+        exportqvect = self.analyzeexport.Append(wx.ID_ANY, _("Export integrated Q along active vector..."), _("Integrate Q along the active vector and export"))
+        exportqvect = self.analyzeexport.Append(wx.ID_ANY, _("Export integrated Q along all vectors in active zone..."), _("Integrate Q along ALL VECTORS of the active zone and export"))
+
+        self.analyzeexport.AppendSeparator()
+
+        plothselect = self.analyzeplot.Append(wx.ID_ANY, _("Plot stats unknown (selected nodes)..."), _("Compute stats and plot on the selected nodes"))
+        plothvector = self.analyzeplot.Append(wx.ID_ANY, _("Plot stats unknown (inside active vector)..."), _("Compute stats and plot on nodes inside the active vector"))
+        plothzone = self.analyzeplot.Append(wx.ID_ANY, _("Plot stats unknown (inside active zone)..."), _("Compute stats and plot on nodes inside the active zone"))
+
+        exporthselect = self.analyzeexport.Append(wx.ID_ANY, _("Export stats unknown (selected nodes)..."), _("Compute stats and export on the selected nodes"))
+        exporthvector = self.analyzeexport.Append(wx.ID_ANY, _("Export stats unknown (inside active vector)..."), _("Compute stats and export on nodes inside the active vector"))
+        exporthzone = self.analyzeexport.Append(wx.ID_ANY, _("Export stats unknown (inside active zone)..."), _("Compute stats and export on nodes inside the active zone"))
 
         self.filemenu.AppendSeparator()
         menuquit = self.filemenu.Append(wx.ID_EXIT, _('&Quit\tCTRL+Q'), _('Quit application'))
@@ -1552,6 +1768,8 @@ class WolfMapViewer(wx.Frame):
         self.active_weir = None
         self.active_laz = None
 
+        self.active_fig = None
+
         curtool = self.tools[ID_SORTALONG] = {}
         curtool['menu'] = self.sortalong
         curtool['name'] = 'Sort along vector'
@@ -1690,6 +1908,90 @@ class WolfMapViewer(wx.Frame):
     #     # print(msg)
     #     return 0
 
+    def _check_id_for_fig(self, idx:str):
+        """ Check if an ID is already used for a figure """
+
+        ids = [cur.idx for cur in self.mymplfigs]
+
+        if idx in ids:
+            return True
+
+        return False
+
+    def _create_id_for_fig(self):
+
+        idx = 'Figure'
+        while not self._check_id_for_fig(idx):
+            idx += '_'
+
+        return idx
+
+    def _validate_id_for_fig(self, idx:str):
+        """ Validate an ID for a figure """
+
+        if idx is None:
+            return self._create_id_for_fig()
+
+        while self._check_id_for_fig(idx):
+            idx += '_'
+
+        return idx
+
+    def new_fig(self, caption:str, idx:str = None, layout = PRESET_LAYOUTS.DEFAULT, size = (800,600), show:bool = True) -> MplFigViewer:
+        """ Create a new figure """
+
+        if idx is None:
+            with wx.TextEntryDialog(self, _('Enter an id for the figure'), _('Figure id'), _('Figure')) as dlg:
+                dlg: wx.TextEntryDialog
+                if dlg.ShowModal() == wx.ID_CANCEL:
+                    return None
+
+                idx = dlg.GetValue()
+
+                idx = self._validate_id_for_fig(idx)
+        else:
+            idx = self._validate_id_for_fig(idx)
+
+        logging.info(f'Figure ID: {idx}')
+
+        added_fig = MplFigViewer(layout, idx= idx, mapviewer = self, caption = caption, size= size)
+
+        if show:
+            added_fig.Show()
+        else:
+            added_fig.Hide()
+
+        self.mymplfigs.append(added_fig)
+
+        return added_fig
+
+    def destroy_fig_by_id(self, idx:str) -> bool:
+        """ Destroy a figure by its ID """
+
+        for id, fig in enumerate(self.mymplfigs):
+            if fig.idx == idx:
+                if self.active_fig is fig:
+                    self.active_fig = None
+                fig.Destroy()
+                self.mymplfigs.pop(id)
+                return True
+
+        return False
+
+    def get_fig(self, idx:str) -> MplFigViewer:
+        """ Get a figure by its ID """
+
+        for cur in self.mymplfigs:
+            if cur.idx == idx:
+                return cur
+
+        return None
+
+    def list_ids_figs(self) -> list[str]:
+        """ List all IDs of figures """
+
+        return [cur.idx for cur in self.mymplfigs]
+
     @property
     def viewer_name(self):
         return self.GetTitle()
@@ -1933,6 +2235,7 @@ class WolfMapViewer(wx.Frame):
 
             readlaz = self.menulazdata.Append(wx.ID_ANY, _('Initialize from laz, las or npz'), _('LAZ data from one specific file (type laz, las or npz)'))
             readlaz_gridinfo = self.menulazgrid.Append(wx.ID_ANY, _('Initialize from directory'), _('LAZ GRID stored in a directory - subgridding of LAZ files'), kind=wx.ITEM_CHECK)
+            copylaz_gridinfo = self.menulazgrid.Append(wx.ID_ANY, _('Copy from current zoom'), _('Make a copy of the used files'))
             updatecolors_laz = self.menulazgrid.Append(wx.ID_ANY, _('Change colors - Classification'), _('Change color map associated to the current classification'),)
 
             bridgelaz = self.menulazdata.Append(wx.ID_ANY, _('Create cloud points from bridges'), _('Extract bridge from LAZ data as cloud points (class 10)'))
@@ -3905,6 +4208,8 @@ class WolfMapViewer(wx.Frame):
         self.myviewerslaz = []
         self.mylazdata = []
 
+        self.mymplfigs = []
+
         self.sim_explorers = {}
 
         # liste des éléments modifiable dans l'arbre
@@ -6359,7 +6664,8 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No active 2D result !'))
                 return
 
-            self.active_res2d.plot_q(self.active_vector, 'border', toshow=True)
+            fig = self.new_fig(_('Q along active vector'), 'Q_along_active_vector', show=False, size=(800, 600))
+            self.active_res2d.plot_q_wx(self.active_vector, 'border', toshow=True, fig= fig)
 
         elif itemlabel == _("Plot integrated Q along active zone..."):
             """ Integrate Q along active zone """
@@ -6372,7 +6678,8 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No active 2D result !'))
                 return
 
-            self.active_res2d.plot_q(self.active_zone.myvectors, ['border'] * self.active_zone.nbvectors, toshow=True)
+            fig = self.new_fig(_('Q along active zone'), 'Q_along_active_zone', show=False, size=(800, 600))
+            self.active_res2d.plot_q_wx(self.active_zone.myvectors, ['border'] * self.active_zone.nbvectors, toshow=True, fig = fig)
 
         elif itemlabel == _("Export integrated Q along active vector..."):
 
@@ -6488,32 +6795,105 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No active 2D result !'))
                 return
 
-            dlg = wx.SingleChoiceDialog(None, _('Choose the unknown to plot'), _('Unknown'), [_('Water depth'), _('Water level'), _('Head')])
+            all_selected = []
+            for curblock in self.active_res2d.myblocks.values():
+                if curblock.SelectionData.nb > 0:
+                    all_selected += curblock.SelectionData.myselection
+
+            if len(all_selected) == 0:
+                logging.warning(_('No selected nodes - Nothing to do !'))
+                return
+
+            keys = Extractable_results.get_list()
+            dlg = wx.SingleChoiceDialog(None, _('Choose the unknown/variable to plot'), _('Unknown'), keys)
 
             ret = dlg.ShowModal()
             if ret == wx.ID_CANCEL:
+                logging.info(_('No unknown chosen - Aborting !'))
                 dlg.Destroy()
                 return
 
-            unknown = dlg.GetStringSelection()
+            which = Extractable_results.get_from_key(dlg.GetStringSelection())
             dlg.Destroy()
 
-            if unknown == _('Water depth'):
-                unknown = 'h'
-            elif unknown == _('Water level'):
-                unknown = 'z'
-            elif unknown == _('Head'):
-                unknown = 'head'
+            try:
+                choice_bes = Select_Begin_end_interval_step(self, _('Choose the interval and step'), self.active_res2d, checkbox=True)
+                ret = choice_bes.ShowModal()
+
+                begin = choice_bes.begin
+                end = choice_bes.end
+                interval = choice_bes.step
+
+            finally:
+                choice_bes.Destroy()
+
+            if begin == -1:
+                logging.info(_('No interval chosen - Aborting !'))
+                return
+
+            newfig = self.new_fig(_('Series of {} - {} (nodes)').format(which.value[0], self.active_res2d.idx), 'series_'+self.active_res2d.idx, show=False, size= (800,600))
 
-            figax = None
+            figax = self.active_res2d.plot_some_values(all_selected, which, toshow=False, figax=newfig, for_steps= (begin-1, end-1, interval))
+
+            newfig.Show()
+
+        elif itemlabel == _("Export stats unknown (selected nodes)..."):
+
+            if self.active_res2d is None:
+                logging.warning(_('No active 2D result !'))
+                return
+
+            all_selected = []
             for curblock in self.active_res2d.myblocks.values():
                 if curblock.SelectionData.nb > 0:
+                    all_selected += curblock.SelectionData.myselection
 
-                    figax = self.active_res2d.plot_h(curblock.SelectionData.myselection,
-                                                   unknown, toshow=False, figax=figax)
-            if figax is not None:
-                fig, ax = figax
-                fig.show()
+            if len(all_selected) == 0:
+                logging.warning(_('No selected nodes - Nothing to do !'))
+                return
+
+            keys = Extractable_results.get_list()
+            dlg = wx.SingleChoiceDialog(None, _('Choose the unknown/variable to plot'), _('Unknown'), keys)
+
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                logging.info(_('No unknown chosen - Aborting !'))
+                dlg.Destroy()
+                return
+
+            which = Extractable_results.get_from_key(dlg.GetStringSelection())
+            dlg.Destroy()
+
+            dlg = wx.FileDialog(None, _('Choose the file to export'), wildcard='csv (*.csv)|*.csv', style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                logging.info(_('No file chosen - Aborting !'))
+                dlg.Destroy()
+                return
+
+            filename = Path(dlg.GetPath())
+            dlg.Destroy()
+
+
+            try:
+                choice_bes = Select_Begin_end_interval_step(self, _('Choose the interval and step'), self.active_res2d, checkbox=True)
+                ret = choice_bes.ShowModal()
+
+                begin = choice_bes.begin
+                end = choice_bes.end
+                interval = choice_bes.step
+
+            finally:
+                choice_bes.Destroy()
+
+            if begin == -1:
+                logging.info(_('No interval chosen - Aborting !'))
+                return
+
+            ret = self.active_res2d.export_some_values_to_csv(all_selected, which, filename, for_steps= (begin-1, end-1, interval))
+
+            if not ret:
+                logging.error(_('Error in exporting values !'))
 
         elif itemlabel == _("Plot stats unknown (inside active vector)..."):
 
@@ -6525,24 +6905,91 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No active vector !'))
                 return
 
-            dlg = wx.SingleChoiceDialog(None, _('Choose the unknown to plot'), _('Unknown'), [_('Water depth'), ['Water level'], ['Head']])
+            keys = Extractable_results.get_list()
+            dlg = wx.SingleChoiceDialog(None, _('Choose the unknown/variable to plot'), _('Unknown'), keys)
+
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                logging.info(_('No unknown chosen - Aborting !'))
+                dlg.Destroy()
+                return
+
+            which = Extractable_results.get_from_key(dlg.GetStringSelection())
+            dlg.Destroy()
+
+            try:
+                choice_bes = Select_Begin_end_interval_step(self, _('Choose the interval and step'), self.active_res2d, checkbox=True)
+                ret = choice_bes.ShowModal()
+
+                begin = choice_bes.begin
+                end = choice_bes.end
+                interval = choice_bes.step
+                violin = choice_bes.check_violin
+
+            finally:
+                choice_bes.Destroy()
+
+            if begin == -1:
+                logging.info(_('No interval chosen - Aborting !'))
+                return
+
+            newfig = self.new_fig(_('Series of {} - {} (polygon)').format(which.value[0], self.active_res2d.idx), 'series_'+self.active_res2d.idx, show=False, size= (800,600))
+
+            if violin:
+                figax = self.active_res2d.plot_violin_values(self.active_vector, which, toshow=False, figax=newfig, for_steps= (begin-1, end-1, interval))
+            else:
+                figax = self.active_res2d.plot_some_values(self.active_vector, which, toshow=False, figax=newfig, for_steps= (begin-1, end-1, interval))
+
+            newfig.Show()
+
+        elif itemlabel == _("Export stats unknown (inside active vector)..."):
+
+            if self.active_res2d is None:
+                logging.warning(_('No active 2D result !'))
+                return
+
+            if self.active_vector is None:
+                logging.warning(_('No active vector !'))
+                return
+
+            keys = Extractable_results.get_list()
+            dlg = wx.SingleChoiceDialog(None, _('Choose the unknown/variable to plot'), _('Unknown'), keys)
+
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                logging.info(_('No unknown chosen - Aborting !'))
+                dlg.Destroy()
+                return
+
+            which = Extractable_results.get_from_key(dlg.GetStringSelection())
+            dlg.Destroy()
 
+            dlg = wx.FileDialog(None, _('Choose the file to export'), wildcard='csv (*.csv)|*.csv', style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
             ret = dlg.ShowModal()
             if ret == wx.ID_CANCEL:
+                logging.info(_('No file chosen - Aborting !'))
                 dlg.Destroy()
                 return
 
-            unknown = dlg.GetStringSelection()
+            filename = Path(dlg.GetPath())
             dlg.Destroy()
 
-            if unknown == _('Water depth'):
-                unknown = 'h'
-            elif unknown == _('Water level'):
-                unknown = 'z'
-            elif unknown == _('Head'):
-                unknown = 'head'
+            try:
+                choice_bes = Select_Begin_end_interval_step(self, _('Choose the interval and step'), self.active_res2d, checkbox=True)
+                ret = choice_bes.ShowModal()
+
+                begin = choice_bes.begin
+                end = choice_bes.end
+                interval = choice_bes.step
+
+            finally:
+                choice_bes.Destroy()
+
+            if begin == -1:
+                logging.info(_('No interval chosen - Aborting !'))
+                return
 
-            fig, ax = self.active_res2d.plot_h(self.active_vector, unknown, toshow=True)
+            ret = self.active_res2d.export_some_values_to_csv(self.active_vector, which, filename=filename, for_steps= (begin-1, end-1, interval))
 
         elif itemlabel == _("Plot stats unknown (inside active zone)..."):
 
@@ -6554,30 +7001,108 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No active zone !'))
                 return
 
-            dlg = wx.SingleChoiceDialog(None, _('Choose the unknown to plot'), _('Unknown'), [_('Water depth'), ['Water level'], ['Head']])
+            keys = Extractable_results.get_list()
+            dlg = wx.SingleChoiceDialog(None, _('Choose the unknown/variable to plot'), _('Unknown'), keys)
 
             ret = dlg.ShowModal()
             if ret == wx.ID_CANCEL:
+                logging.info(_('No unknown chosen - Aborting !'))
                 dlg.Destroy()
                 return
 
-            unknown = dlg.GetStringSelection()
+            which = Extractable_results.get_from_key(dlg.GetStringSelection())
             dlg.Destroy()
 
-            if unknown == _('Water depth'):
-                unknown = 'h'
-            elif unknown == _('Water level'):
-                unknown = 'z'
-            elif unknown == _('Head'):
-                unknown = 'head'
+            try:
+                choice_bes = Select_Begin_end_interval_step(self, _('Choose the interval and step'), self.active_res2d, checkbox=True)
+                ret = choice_bes.ShowModal()
+
+                begin = choice_bes.begin
+                end = choice_bes.end
+                interval = choice_bes.step
+                violin = choice_bes.check_violin
+
+            finally:
+                choice_bes.Destroy()
+
+            if begin == -1:
+                logging.info(_('No interval chosen - Aborting !'))
+                return
 
             for idx, curvect in enumerate(self.active_zone.myvectors):
+                logging.info(_('Plotting {} / {}'.format(idx, self.active_zone.nbvectors)))
                 if idx ==0:
-                    fig, ax = self.active_res2d.plot_h(curvect, unknown, toshow=False)
+                    newfig = self.new_fig(_('Series of {} - {} (zone)').format(which.value[0], self.active_res2d.idx), 'series_'+self.active_res2d.idx, show=False, size= (800,600))
+
+                if violin:
+                    figax = self.active_res2d.plot_violin_values(curvect, which, toshow=False, figax=newfig, for_steps= (begin-1, end-1, interval))
                 else:
-                    self.active_res2d.plot_h(curvect, unknown, toshow=False, figax = (fig, ax))
+                    figax = self.active_res2d.plot_some_values(curvect, which, toshow=False, figax=newfig, for_steps= (begin-1, end-1, interval))
 
-            fig.show()
+            newfig.Show()
+
+        elif itemlabel == _("Export stats unknown (inside active zone)..."):
+
+            if self.active_res2d is None:
+                logging.warning(_('No active 2D result !'))
+                return
+
+            if self.active_zone is None:
+                logging.warning(_('No active zone !'))
+                return
+
+            keys = Extractable_results.get_list()
+            dlg = wx.SingleChoiceDialog(None, _('Choose the unknown/variable to plot'), _('Unknown'), keys)
+
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                logging.info(_('No unknown chosen - Aborting !'))
+                dlg.Destroy()
+                return
+
+            which = Extractable_results.get_from_key(dlg.GetStringSelection())
+            dlg.Destroy()
+
+            dlg = wx.DirDialog(None, _('Choose the directory where to export'), style= wx.DD_DEFAULT_STYLE)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                logging.info(_('No file chosen - Aborting !'))
+                dlg.Destroy()
+                return
+
+            directory = Path(dlg.GetPath())
+            dlg.Destroy()
+
+            try:
+                choice_bes = Select_Begin_end_interval_step(self, _('Choose the interval and step'), self.active_res2d, checkbox=True)
+                ret = choice_bes.ShowModal()
+
+                begin = choice_bes.begin
+                end = choice_bes.end
+                interval = choice_bes.step
+
+            finally:
+                choice_bes.Destroy()
+
+            if begin == -1:
+                logging.info(_('No interval chosen - Aborting !'))
+                return
+
+            allnames = [curvect.myname for curvect in self.active_zone.myvectors]
+            if len(set(allnames)) != len(allnames):
+                logging.warning(_('Some vectors have the same name !'))
+
+                # create new unique names
+                unique_name = []
+                for curvect in self.active_zone.myvectors:
+                    if curvect.myname in unique_name:
+                        unique_name.append(curvect.myname + '_' + str(unique_name.count(curvect.myname)))
+                    else:
+                        unique_name.append(curvect.myname)
+
+
+            for idx, (curvect, name) in enumerate(zip(self.active_zone.myvectors, unique_name)):
+                self.active_res2d.export_some_values_to_csv(curvect, which, filename=directory / name, for_steps= (begin-1, end-1, interval))
 
         elif itemlabel == _("Plot active vector..."):
             """ Plot data along active vector """
@@ -6623,16 +7148,13 @@ class WolfMapViewer(wx.Frame):
                 dlg.Destroy()
 
             # Création d'un graphique matplotlib sous wx
-            figmpl = MplFig()
-            figmpl.presets()
-            figmpl.Hide()
-            fig, ax = figmpl.get_figax()
-
-            # fig, ax = self.active_vector.plot_mpl(True, False)
+            lab  = _('Plot of active vector') + ' - ' + self.active_vector.myname
+            figmpl = self.new_fig(lab, lab, show=False, size= (800,600))
 
             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:wx.MultiChoiceDialog
                 dlg.SetSelections(range(len(linkedarrays)))
 
                 if dlg.ShowModal() == wx.ID_CANCEL:
@@ -6646,20 +7168,17 @@ class WolfMapViewer(wx.Frame):
 
             linkedarrays = {curkey:curval for curkey, curval in linkedarrays.items() if curkey in selected}
 
-            self.active_vector.plot_linked(fig, ax, linkedarrays)
+            self.active_vector.plot_linked_wx(figmpl, linkedarrays)
 
             if add_cloud:
                 s, z = self.active_cloud.projectontrace(self.active_vector, return_cloud=False, proximity= proxval)
 
-                ax.scatter( s, z, c='black', s=1.0)
+                figmpl.plot( s, z, c='black', s=1.0, marker='x')
 
                 for curs, curz in zip(s,z):
-                    ax.plot([curs, curs], [curz-tolval, curz+tolval], 'k--', linewidth=0.5)
-                    ax.plot([curs-.1, curs+.1], [curz+tolval, curz+tolval], c='black', linewidth=0.5)
-                    ax.plot([curs-.1, curs+.1], [curz-tolval, curz-tolval], c='black', linewidth=0.5)
-
-                # fig.canvas.draw()
-                # fig.canvas.flush_events()
+                    figmpl.plot([curs, curs], [curz-tolval, curz+tolval], 'k--', linewidth=0.5)
+                    figmpl.plot([curs-.1, curs+.1], [curz+tolval, curz+tolval], c='black', linewidth=0.5)
+                    figmpl.plot([curs-.1, curs+.1], [curz-tolval, curz-tolval], c='black', linewidth=0.5)
 
             figmpl.Show()
 
@@ -6687,85 +7206,79 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No active zone ! -- please select a zone containing polygons !'))
                 return
 
-            plotzone:list[zone]
-            plotzone = []
-            zonename = self.active_zone.myname
-            if '_left_' in zonename or '_right_' in zonename:
-
-                logging.info(_('Left and Right polygons are detected'))
-
-                testname = zonename.replace('_left_', '')
-                testname = testname.replace('_right_', '')
-
-                for curzone in self.active_zones.myzones:
-                    if testname == curzone.myname.replace('_left_', '').replace('_right_', ''):
-                        plotzone.append(curzone)
-
-                msg = wx.MessageDialog(self,
-                                       _('Left and Right polygons are detected \nDo you want like to plot left and right polygons on the same plot ?'),
-                                       style=wx.YES_NO | wx.YES_DEFAULT)
-                ret = msg.ShowModal()
-                msg.Destroy()
-                if ret == wx.ID_NO:
+            try:
+                plotzone:list[zone]
+                plotzone = []
+                zonename = self.active_zone.myname
+                if '_left_' in zonename or '_right_' in zonename:
+
+                    logging.info(_('Left and Right polygons are detected'))
+
+                    testname = zonename.replace('_left_', '')
+                    testname = testname.replace('_right_', '')
+
+                    for curzone in self.active_zones.myzones:
+                        if testname == curzone.myname.replace('_left_', '').replace('_right_', ''):
+                            plotzone.append(curzone)
+
+                    msg = wx.MessageDialog(self,
+                                        _('Left and Right polygons are detected \nDo you want like to plot left and right polygons on the same plot ?'),
+                                        style=wx.YES_NO | wx.YES_DEFAULT)
+                    ret = msg.ShowModal()
+                    msg.Destroy()
+                    if ret == wx.ID_NO:
+                        plotzone = [self.active_zone]
+                else:
+                    logging.info(_('Sole polygon detected'))
                     plotzone = [self.active_zone]
-            else:
-                logging.info(_('Sole polygon detected'))
-                plotzone = [self.active_zone]
-
-            # Création d'un graphique matplotlib sous wx
-            figmpl = MplFig()
-            figmpl.presets()
-            figmpl.Hide()
 
-            fig, ax = figmpl.get_figax()
-
-            # fig, ax = plt.subplots(1, 1)
-
-            linkedarrays = {}
-
-            # Matrices 2D
-            for curarray in self.iterator_over_objects(draw_type.ARRAYS):
-                curarray: WolfArray
-                logging.info(_('Plotting array {}').format(curarray.idx))
-                linkedarrays[curarray.idx] = curarray
-
-            # Résultats 2D
-            for curarray in self.iterator_over_objects(draw_type.RES2D):
-                curarray: Wolfresults_2D
-                logging.info(_('Plotting results {}').format(curarray.idx))
-                linkedarrays[curarray.idx] = curarray
-
-            linkedvecs={}
-            for curvect in self.iterator_over_objects(draw_type.VECTORS):
-                curvect: Zones
-                logging.info(_('Plotting vector {}').format(curvect.idx))
-                linkedvecs[curvect.idx] = curvect
-
-            if len(plotzone) > 1:
-                # left and right polygons
-                for curzone in plotzone:
-                    if '_left_' in curzone.myname:
-                        locarrays = {}
-                        for curkey, curarray in linkedarrays.items():
-                            locarrays[curkey+ '_left'] = curarray
-
-                        curzone.plot_linked_polygons(fig, ax, locarrays, linked_vec=linkedvecs, linestyle= '--')
-                    elif '_right_' in curzone.myname:
-                        locarrays = {}
-                        for curkey, curarray in linkedarrays.items():
-                            locarrays[curkey+ '_right'] = curarray
-
-                        curzone.plot_linked_polygons(fig, ax, locarrays, linked_vec=linkedvecs, linestyle= '-.')
-            else:
-                # sole polygon
-                plotzone[0].plot_linked_polygons(fig, ax, linkedarrays, linked_vec=linkedvecs)
+                # Création d'un graphique matplotlib sous wx
+                figmpl = self.new_fig(_('Plot of active polygons'), 'plot_active_polygons', show=False, size= (800,600))
+
+                linkedarrays = {}
+
+                # Matrices 2D
+                for curarray in self.iterator_over_objects(draw_type.ARRAYS):
+                    curarray: WolfArray
+                    logging.info(_('Plotting array {}').format(curarray.idx))
+                    linkedarrays[curarray.idx] = curarray
+
+                # Résultats 2D
+                for curarray in self.iterator_over_objects(draw_type.RES2D):
+                    curarray: Wolfresults_2D
+                    logging.info(_('Plotting results {}').format(curarray.idx))
+                    linkedarrays[curarray.idx] = curarray
+
+                linkedvecs={}
+                for curvect in self.iterator_over_objects(draw_type.VECTORS):
+                    curvect: Zones
+                    logging.info(_('Plotting vector {}').format(curvect.idx))
+                    linkedvecs[curvect.idx] = curvect
+
+                if len(plotzone) > 1:
+                    # left and right polygons
+                    for curzone in plotzone:
+                        if '_left_' in curzone.myname:
+                            locarrays = {}
+                            for curkey, curarray in linkedarrays.items():
+                                locarrays[curkey+ '_left'] = curarray
+
+                            curzone.plot_linked_polygons_wx(figmpl, locarrays, linked_vec=linkedvecs, linestyle= '--')
+                        elif '_right_' in curzone.myname:
+                            locarrays = {}
+                            for curkey, curarray in linkedarrays.items():
+                                locarrays[curkey+ '_right'] = curarray
+
+                            curzone.plot_linked_polygons_wx(figmpl, locarrays, linked_vec=linkedvecs, linestyle= '-.')
+                else:
+                    # sole polygon
+                    plotzone[0].plot_linked_polygons_wx(figmpl, linkedarrays, linked_vec=linkedvecs)
 
-            # ax.grid()
-            # ax.legend()
-            # fig.show()
+                figmpl.Show()
 
-            figmpl.Show()
-            figmpl.CenterOnScreen()
+            except Exception as e:
+                logging.error(_('Error in plotting active polygons\n{}'.format(e)))
+                logging.warning(_('Are you sure the active zone contains polygons ?'))
 
         elif itemlabel == _("Manage banks..."):
 
@@ -6950,6 +7463,23 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel == _('Initialize from directory'):
             self.init_laz_from_gridinfos()
 
+        elif itemlabel == _('Copy from current zoom'):
+
+            if self.mylazgrid is None:
+                logging.warning(_('No gridded LAZ data loaded !'))
+                return
+
+            dlg = wx.DirDialog(None, _('Choose a directory to copy the files'), _('Copy files'), style=wx.DD_DEFAULT_STYLE)
+            if dlg.ShowModal() == wx.ID_CANCEL:
+                dlg.Destroy()
+
+            dirout = dlg.GetPath()
+            dlg.Destroy()
+
+            curbounds = [[self.xmin, self.xmin + self.width], [self.ymin, self.ymin + self.height]]
+
+            self.mylazgrid.copy_files_in_bounds(curbounds, dirout)
+
         elif itemlabel == _('Create cloud points from bridges'):
 
             if self.active_laz is None:
@@ -6990,12 +7520,39 @@ class WolfMapViewer(wx.Frame):
                 self.add_object('cloud', newobj=mycloud, ToCheck=True, id='Buildings')
 
         elif itemlabel == _('Create cloud points from specified classes'):
-            pass
+
+            if self.active_laz is None:
+                self.init_laz_from_lazlasnpz()
+
+            codes = self.active_laz.codes_unique
+
+            dlg = wx.MultiChoiceDialog(None, _('Choose the classes to plot'), _('Classes'), codes)
+            if dlg.ShowModal() == wx.ID_CANCEL:
+                dlg.Destroy()
+
+            selected = dlg.GetSelections()
+            selected = [codes[cur] for cur in selected]
+            dlg.Destroy()
+
+            for curcode in selected:
+                mycloud = cloud_vertices()
+                mydata = self.active_laz.get_data_class(curcode)
+                mycloud.init_from_nparray(mydata)
+                mycloud.myprop.style = 2
+                mycloud.myprop.color = getIfromRGB([102, 102, 102])
+                mycloud.myprop.width = .5
+                if self.linked:
+                    if len(self.linkedList) > 0:
+                        for curframe in self.linkedList:
+                            curframe.add_object('cloud', newobj=mycloud, ToCheck=True, id='Class {}'.format(curcode))
+                else:
+                    self.add_object('cloud', newobj=mycloud, ToCheck=True, id='Class {}'.format(curcode))
 
         elif itemlabel == _('Create LAZ viewer'):
 
             laz_source = self._select_laz_source()
             if laz_source is None:
+                logging.warning(_('No LAZ data loaded !'))
                 return
 
             if laz_source is self.mylazgrid:
@@ -7242,7 +7799,7 @@ class WolfMapViewer(wx.Frame):
             self.menu_particlesystem()
 
         elif itemlabel == _('Create particle system...'):
-            self.active_particlesystem = newpart = Particle_system()
+            self.active_particle_system = newpart = Particle_system()
             self.add_object(which='particlesystem', newobj=newpart, ToCheck=True)
             self.menu_particlesystem()
 
@@ -11990,6 +12547,19 @@ class WolfMapViewer(wx.Frame):
                 self.active_vertex = None
                 self.active_cloud = None
 
+                self.active_laz = None
+
+                self.active_fig = None
+                self.active_bridge  = None
+                self.active_bridges = None
+                self.active_bc = None
+                self.active_cs = None
+                self.active_imagestiles = None
+                self.active_landmap = None
+                self.active_profile = None
+                self.active_tri = None
+                self.active_viewer3d = None
+
                 self.set_statusbar_text(_('Esc pressed - No more action in progress - No more active object'))
                 self.set_label_selecteditem('')
 
@@ -12154,11 +12724,19 @@ class WolfMapViewer(wx.Frame):
                     self.active_array.myops.reset_all_selection()
                     self.Refresh()
 
+                if self.active_res2d is not None:
+                    self.active_res2d.SelectionData.reset_all()
+                    self.Refresh()
+
             elif key == ord('R'):  # r
                 if self.active_array is not None:
                     self.active_array.myops.reset_selection()
                     self.Refresh()
 
+                if self.active_res2d is not None:
+                    self.active_res2d.SelectionData.reset()
+                    self.Refresh()
+
             elif key == ord('O'):
                 # Active Opacity for the active array