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

wolfhece/PyDraw.py

@@ -25,9 +25,11 @@ try:
     import glob
     import traceback
     from datetime import datetime, timedelta
+    from sklearn import linear_model, datasets
+
 except ImportError as e:
     print(e)
-    raise ImportError("Error importing wxPython, numpy, PIL, json, glob, traceback. Please check your installation.")
+    raise ImportError("Error importing wxPython, numpy, PIL, json, glob, traceback, sklearn. Please check your installation.")
 
 try:
     from osgeo import gdal
@@ -73,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
@@ -84,7 +86,7 @@ try:
     from .Results2DGPU import wolfres2DGPU
     from .PyCrosssections import crosssections, profile, Interpolator, Interpolators
     from .GraphNotebook import PlotNotebook
-    from .lazviewer.laz_viewer import myviewer, read_laz, clip_data_xyz, xyz_laz_grids, choices_laz_colormap, Classification_LAZ, Base_LAZ_Data, viewer as viewerlaz
+    from .lazviewer.laz_viewer import myviewer, read_laz, clip_data_xyz, xyz_laz_grids, choices_laz_colormap, Classification_LAZ, Wolf_LAZ_Data, viewer as viewerlaz
     from . import Lidar2002
     from .picc import Picc_data, Cadaster_data
     from .wolf_zi_db import ZI_Databse_Elt, PlansTerrier
@@ -112,6 +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, 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.")
@@ -167,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 """
 
@@ -1151,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
@@ -1172,7 +1377,9 @@ class WolfMapViewer(wx.Frame):
     myimagestiles: list[ImagesTiles]
     mypartsystems: list[Particle_system]
     myviewers3d:list[Wolf_Viewer3D]
-    mylazdata:list[Base_LAZ_Data]
+    mylazdata:list[Wolf_LAZ_Data]
+
+    mymplfigs:list[MplFigViewer]
 
     sim_explorers: dict[Wolfresults_2D:Sim_Explorer]
 
@@ -1204,7 +1411,9 @@ class WolfMapViewer(wx.Frame):
     active_bridge: Bridge
     active_weirs : Weirs
     active_weir : Weir
-    active_laz : Base_LAZ_Data
+    active_laz : Wolf_LAZ_Data
+
+    active_fig: MplFigViewer
 
     def __init__(self,
                  wxparent = None,
@@ -1471,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'))
@@ -1549,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'
@@ -1687,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()
@@ -1930,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)'))
@@ -3902,6 +4208,8 @@ class WolfMapViewer(wx.Frame):
         self.myviewerslaz = []
         self.mylazdata = []
 
+        self.mymplfigs = []
+
         self.sim_explorers = {}
 
         # liste des éléments modifiable dans l'arbre
@@ -4007,7 +4315,7 @@ class WolfMapViewer(wx.Frame):
         self.ymin = self.mousey - height / 2.
         self.ymax = self.ymin + height
 
-    def setbounds(self,updatescale=True):
+    def setbounds(self, updatescale=True):
         """
         Calcule les limites visibles de la fenêtrte graphique sur base des
         facteurs d'échelle courants
@@ -5542,7 +5850,7 @@ class WolfMapViewer(wx.Frame):
         curbounds = [[self.xmin, self.xmin + self.width], [self.ymin, self.ymin + self.height]]
 
         if self.active_laz is None:
-            newobj = Base_LAZ_Data()
+            newobj = Wolf_LAZ_Data()
             newobj.classification = self.mylazgrid.colors
             newobj.from_grid(self.mylazgrid, curbounds)
 
@@ -5553,7 +5861,7 @@ class WolfMapViewer(wx.Frame):
             ret = dlg.ShowModal()
 
             if ret == wx.ID_YES:
-                newobj = Base_LAZ_Data()
+                newobj = Wolf_LAZ_Data()
                 newobj.classification = self.mylazgrid.colors
                 newobj.from_grid(self.mylazgrid, curbounds)
 
@@ -5588,14 +5896,14 @@ class WolfMapViewer(wx.Frame):
             else:
                 logging.info(_('Filter cancelled'))
 
-    def decimate_laz_data(self, factor:int = 10):
-        """ Decimate data """
+    def descimate_laz_data(self, factor:int = 10):
+        """ Descimate data """
 
         if self.active_laz is None:
             logging.warning(_('No laz data'))
             return
 
-        self.active_laz.decimate(factor)
+        self.active_laz.descimate(factor)
 
     def select_active_array_from_laz(self, array:WolfArray = None, used_codes:list = None, chunk_size:float = 500.):
         """ select some nodes from laz data
@@ -5953,7 +6261,7 @@ class WolfMapViewer(wx.Frame):
             fn = dlg.GetPath()
             dlg.Destroy()
 
-        self.mylazdata.append(Base_LAZ_Data())
+        self.mylazdata.append(Wolf_LAZ_Data())
         self.active_laz = self.mylazdata[-1]
         self.active_laz.from_file(fn)
 
@@ -6209,14 +6517,22 @@ class WolfMapViewer(wx.Frame):
         """ Select laz source """
 
         if self.active_laz is None and self.mylazgrid is None:
-            logging.warning(_('No LAZ data loaded !'))
+            logging.warning(_('No LAZ data loaded/initialized !'))
             return None
         elif self.active_laz is None:
+            # No active laz data
             laz_source = self.mylazgrid
         elif self.mylazgrid is None:
+            # No laz grid
             laz_source = self.active_laz
         else:
+            # We have both
             choices = [_('From active LAZ data'), _('From newly extracted data')]
+
+            keys = self.get_list_keys(draw_type.LAZ, None)
+            if len(keys) > 1:
+                choices.append(_('From multiple LAZ data'))
+
             dlg = wx.SingleChoiceDialog(None, _("Pick a data source"), "Choices", choices)
             ret = dlg.ShowModal()
             if ret == wx.ID_CANCEL:
@@ -6229,8 +6545,22 @@ class WolfMapViewer(wx.Frame):
 
             if idx == 0:
                 laz_source = self.active_laz
-            else:
+            elif idx == 1:
                 laz_source = self.mylazgrid
+            else:
+                dlg = wx.MultiChoiceDialog(None, _('Choose the LAZ data to use\n\nIf multiple, a new one will be created !'), _('LAZ data'), keys)
+                if dlg.ShowModal() == wx.ID_OK:
+                    used_keys = dlg.GetSelections()
+                    used_keys = [keys[cur] for cur in used_keys]
+                    laz_source = Wolf_LAZ_Data()
+                    for curkey in used_keys:
+                        laz_source.merge(self.get_obj_from_id(curkey, draw_type.LAZ))
+
+                    self.add_object('laz', newobj=laz_source, id = 'Merged LAZ data')
+                    dlg.Destroy()
+                else:
+                    dlg.Destroy()
+                    return None
 
         return laz_source
 
@@ -6240,7 +6570,7 @@ class WolfMapViewer(wx.Frame):
         dlg = wx.SingleChoiceDialog(None, _("Pick a colormap"), "Choices", choices)
 
         if self.active_laz is not None:
-            dlg.SetSelection(self.active_laz.associated_color)
+            dlg.SetSelection(ass_values.index(self.active_laz.associated_color))
 
         ret = dlg.ShowModal()
         if ret == wx.ID_CANCEL:
@@ -6334,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 """
@@ -6347,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..."):
 
@@ -6463,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 = self.active_res2d.plot_some_values(all_selected, which, toshow=False, figax=newfig, for_steps= (begin-1, end-1, interval))
 
-            figax = None
+            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
+
+            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()
 
-                    figax = self.active_res2d.plot_h(curblock.SelectionData.myselection,
-                                                   unknown, toshow=False, figax=figax)
-            if figax is not None:
-                fig, ax = figax
-                fig.show()
+                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)..."):
 
@@ -6500,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
 
-            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
+
+            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
 
-            fig, ax = self.active_res2d.plot_h(self.active_vector, unknown, toshow=True)
+            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(self.active_vector, which, filename=filename, for_steps= (begin-1, end-1, interval))
 
         elif itemlabel == _("Plot stats unknown (inside active zone)..."):
 
@@ -6529,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 """
@@ -6597,11 +7147,14 @@ class WolfMapViewer(wx.Frame):
 
                 dlg.Destroy()
 
-            fig, ax = self.active_vector.plot_mpl(True, False)
+            # Création d'un graphique matplotlib sous wx
+            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:
@@ -6615,20 +7168,19 @@ 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)
+                    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)
 
-                fig.canvas.draw()
-                fig.canvas.flush_events()
+            figmpl.Show()
 
         elif itemlabel == _("Compute and apply unique colormap on all..."):
             self.uniquecolormap()
@@ -6649,79 +7201,84 @@ class WolfMapViewer(wx.Frame):
             self.filter_inundation()
 
         elif itemlabel == _("Plot active polygons..."):
+
             if self.active_zone is None:
                 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]
 
-            fig, ax = plt.subplots(1, 1)
-
-            linkedarrays = {}
+                # 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)
 
-            # 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)
+                figmpl.Show()
 
-            ax.grid()
-            ax.legend()
-            fig.show()
+            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..."):
 
@@ -6906,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:
@@ -6946,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:
@@ -6983,7 +7584,7 @@ class WolfMapViewer(wx.Frame):
                 return
 
             # Choose a decimation factor - integer
-            dlg = wx.NumberEntryDialog(None, _('Your dataset contains {} points.\nWould you like to decimate?').format(self.active_laz.num_points),
+            dlg = wx.NumberEntryDialog(None, _('Your dataset contains {} points.\nWould you like to descimate?').format(self.active_laz.num_points),
                                         _('Decaimate factor'), _('Decimation'), 0, 0, 100)
 
             ret = dlg.ShowModal()
@@ -6992,11 +7593,11 @@ class WolfMapViewer(wx.Frame):
                 dlg.Destroy()
                 return
 
-            decimate_fact = dlg.GetValue()
+            descimate_fact = dlg.GetValue()
             dlg.Destroy()
 
-            if decimate_fact > 0:
-                self.active_laz.decimate(decimate_fact)
+            if descimate_fact > 0:
+                self.active_laz.descimate(descimate_fact)
                 logging.info(_('New count : {}').format(self.active_laz.num_points))
 
         elif itemlabel == _('Clip LAZ grid on current zoom'):
@@ -7014,8 +7615,8 @@ class WolfMapViewer(wx.Frame):
             if self.active_laz.data.shape[0] > 100_000_000:
 
                 # Choose a decimation factor - integer
-                dlg = wx.NumberEntryDialog(None, _('Your data selection is very large (>100 M)\nWould you like to decimate?'),
-                                           _('Decaimate factor'), _('Decimation'), 0, 0, 100)
+                dlg = wx.NumberEntryDialog(None, _('Your data selection is very large (>100 M)\nWould you like to descimate?\n\n{} points').format(self.active_laz.data.shape[0]),
+                                           _('Descimate factor'), _('Decimation'), 0, 0, 100)
 
                 ret = dlg.ShowModal()
 
@@ -7023,11 +7624,11 @@ class WolfMapViewer(wx.Frame):
                     dlg.Destroy()
                     return
 
-                decimate_fact = dlg.GetValue()
+                descimate_fact = dlg.GetValue()
                 dlg.Destroy()
 
-                if decimate_fact > 0:
-                    self.decimate_laz_data(decimate_fact)
+                if descimate_fact > 0:
+                    self.descimate_laz_data(descimate_fact)
 
         elif itemlabel == _('Fill active array from LAZ data'):
 
@@ -7198,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()
 
@@ -8680,7 +9281,7 @@ class WolfMapViewer(wx.Frame):
             curtree = self.myitemslaz
 
             if newobj is None:
-                newobj = Base_LAZ_Data(mapviewer=self)
+                newobj = Wolf_LAZ_Data(mapviewer=self)
                 newobj.from_file(filename)
 
             self.mylazdata.append(newobj)
@@ -9361,10 +9962,20 @@ class WolfMapViewer(wx.Frame):
 
                     fdlg.Destroy()
 
+                elif isinstance(self.selected_object, Wolf_LAZ_Data):
+                    filterArray = "Dump (*.dump)|*.dmp|all (*.*)|*.*"
+                    fdlg = wx.FileDialog(self, "Choose file name for LAZ data :" + self.selected_object.idx, wildcard=filterArray,
+                                            style=wx.FD_SAVE)
+                    ret = fdlg.ShowModal()
+                    if ret == wx.ID_OK:
+                        self.selected_object.saveas(fdlg.GetPath())
+
+                    fdlg.Destroy()
+
         elif text == _('Properties'):
 
             myobj = self.selected_object
-            if type(myobj) in [WolfArray, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU, Particle_system, Picc_data, Cadaster_data, hydrometry_wolfgui, Bridge, Weir, Base_LAZ_Data]:
+            if type(myobj) in [WolfArray, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU, Particle_system, Picc_data, Cadaster_data, hydrometry_wolfgui, Bridge, Weir, Wolf_LAZ_Data]:
                 myobj.show_properties()
 
             elif isinstance(myobj, cloud_vertices):
@@ -9514,22 +10125,27 @@ class WolfMapViewer(wx.Frame):
 
         elif _('Set colormap') in text:
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
                 self.selected_object.associated_color = self._choice_laz_colormap()
 
         elif _('Edit colormap') in text:
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
                 self.selected_object.interactive_update_colors()
 
         elif _('Set classification') in text:
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
                 self.selected_object.set_classification(self._choice_laz_classification())
 
+        elif _('Edit selection') in text:
+
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
+                self.selected_object._edit_selection()
+
         elif _('All to cloud') in text:
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
 
                 if self.selected_object.num_points > 100000:
                     dlg = wx.MessageDialog(None, _('The number of points is high, it could take some time to convert to cloud.\nDo you want to continue ?'), _('Warning'), wx.YES_NO | wx.NO_DEFAULT)
@@ -9546,7 +10162,7 @@ class WolfMapViewer(wx.Frame):
 
         elif _('Selection to cloud') in text:
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
 
                 xyz = self.selected_object.xyz_selected
                 if xyz.shape[0] ==0:
@@ -9566,14 +10182,75 @@ class WolfMapViewer(wx.Frame):
                 newcloud.init_from_nparray(xyz)
                 self.add_object('cloud', newobj=newcloud, id=self.selected_object.idx + '_cloud_sel')
 
+        elif _('Selection to vector') in text:
+
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
+
+                if self.active_zone is None:
+                    logging.warning(_('No active zone selected'))
+                    return
+
+                xyz = self.selected_object.xyz_selected
+                if xyz.shape[0] ==0:
+                    logging.warning('No points selected')
+                    return
+
+                if xyz.shape[0] > 100000:
+                    dlg = wx.MessageDialog(None, _('The number of points is high, it could take some time to convert to cloud.\nDo you want to continue ?'), _('Warning'), wx.YES_NO | wx.NO_DEFAULT)
+                    ret = dlg.ShowModal()
+
+                    if ret != wx.ID_YES:
+                        dlg.Destroy()
+
+                        return
+
+                def approximate_vector(xyz):
+                    """ Get a cloud of points and return a vector
+                    based on the best approximated segment
+                    and points projected on its trace
+                    """
+
+                    # best approximation of the segment
+                    # based on the RANSAC algorithm from scikit-learn
+                    model = linear_model.RANSACRegressor()
+                    model.fit(xyz[:,0].reshape(-1,1), xyz[:,1])
+
+                    # get the points projected on the segment
+                    proj = model.predict(xyz[:,0].reshape(-1,1))
+
+                    # get the coordinates of the projected points
+                    xyz_proj = np.zeros((xyz.shape[0],3))
+                    xyz_proj[:,0] = xyz[:,0]
+                    xyz_proj[:,1] = proj
+                    xyz_proj[:,2] = xyz[:,2]
+
+                    #Sort the points
+                    idx = np.argsort(xyz_proj[:,0])
+                    xyz_proj = xyz_proj[idx]
+
+                    return xyz_proj
+
+                newvector = vector(name = self.selected_object.idx + '_vector_sel', fromnumpy= approximate_vector(xyz))
+                self.active_zone.add_vector(newvector, forceparent=True)
+                self.active_zone.parent.find_minmax(True)
+                self.active_zone.parent.reset_listogl()
+
+                self.active_zone.parent.fill_structure()
+                self.Refresh()
+
         elif _('Play') in text:
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
                 self.selected_object.play_flight()
 
+        elif _('Add point') in text:
+
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
+                self.selected_object.add_pose_in_memory()
+
         elif _('Record') in text:
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
 
                 dlg = wx.DirDialog(self, _('Choose a directory to save the video'), style=wx.DD_DEFAULT_STYLE)
                 if dlg.ShowModal() == wx.ID_OK:
@@ -9583,7 +10260,7 @@ class WolfMapViewer(wx.Frame):
 
         elif _('Load flight') in text:
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
                 dlg = wx.FileDialog(self, _('Choose a file to load the flight'), wildcard='JSON (*.json)|*.json|All (*.*)|*.*', style=wx.FD_OPEN)
                 if dlg.ShowModal() == wx.ID_OK:
                     self.selected_object.load_flight(dlg.GetPath())
@@ -9592,7 +10269,7 @@ class WolfMapViewer(wx.Frame):
 
         elif _('Save flight') in text:
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
                 dlg = wx.FileDialog(self, _('Choose a file to save the flight'), wildcard='JSON (*.json)|*.json|All (*.*)|*.*', style=wx.FD_SAVE)
                 if dlg.ShowModal() == wx.ID_OK:
                     self.selected_object.save_flight(dlg.GetPath())
@@ -10311,14 +10988,27 @@ class WolfMapViewer(wx.Frame):
 
         self.mousex = self.mousedown[0]
         self.mousey = self.mousedown[1]
-        self.mousedown = (0., 0.)
+        # self.mousedown = (0., 0.)
         self.oneclick = False
         self.setbounds()
 
         if ctrldown:
-            if self.active_viewer3d is not None:
-                self.active_viewer3d.force_view(self.mousex, self.mousey, self.active_array.get_value(self.mousex, self.mousey))
-                self.Refresh()
+            if self.active_array is not None:
+                if self.active_viewer3d is not None:
+                    self.active_viewer3d.force_view(self.mousex, self.mousey, self.active_array.get_value(self.mousex, self.mousey))
+                    self.Refresh()
+
+                if self.active_laz is not None:
+                    if self.active_laz.viewer is not None:
+                        self.active_laz.force_view(self.mousex, self.mousey, self.active_array.get_value(self.mousex, self.mousey))
+            else:
+                if self.active_viewer3d is not None:
+                    self.active_viewer3d.force_view(self.mousex, self.mousey)
+                    self.Refresh()
+
+                if self.active_laz is not None:
+                    if self.active_laz.viewer is not None:
+                        self.active_laz.force_view(self.mousex, self.mousey)
 
     def OnLDown(self, e):
 
@@ -10384,7 +11074,7 @@ class WolfMapViewer(wx.Frame):
             if ctrl:
                 myobj.show_properties()
 
-        elif type(myobj) == Base_LAZ_Data:
+        elif type(myobj) == Wolf_LAZ_Data:
 
             self.active_laz = myobj
 
@@ -11857,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('')
 
@@ -12021,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
 
@@ -12123,6 +12834,7 @@ class WolfMapViewer(wx.Frame):
             tracks.append(_('Edit colormap'))
             tracks.append(_('Set classification'))
             tracks.append(_('Convert to...'))
+            tracks.append(_('Edit selection'))
             tracks.append(_('All to cloud'))
             tracks.append(_('Selection to cloud'))
 
@@ -12174,7 +12886,7 @@ class WolfMapViewer(wx.Frame):
                 self.popupmenu.Append(wx.ID_ANY, _('Export to Shape file'), _('Export to Shape file'))
                 self.popupmenu.Append(wx.ID_ANY, _('Export active zone to Shape file'), _('Export active zone to Shape file'))
 
-            if isinstance(self.selected_object, Base_LAZ_Data):
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
 
                 colrmapmenu = wx.Menu()
                 self.popupmenu.AppendSubMenu(colrmapmenu, _('Colormap'))
@@ -12188,12 +12900,16 @@ class WolfMapViewer(wx.Frame):
 
                 converttomenu.Append(wx.ID_ANY, _('All to cloud'), _('Convert all to cloud'))
                 converttomenu.Append(wx.ID_ANY, _('Selection to cloud'), _('Convert selection to cloud'))
+                converttomenu.Append(wx.ID_ANY, _('Selection to vector'), _('Convert selection to vector'))
+
+                self.popupmenu.Append(wx.ID_ANY, _('Edit selection'), _('Edit selection'))
 
                 moviemenu = wx.Menu()
                 self.popupmenu.AppendSubMenu(moviemenu, _('Movie'))
 
+                moviemenu.Append(wx.ID_ANY, _('Add point'), _('Add point passage'))
                 moviemenu.Append(wx.ID_ANY, _('Play'), _('Play'))
-                moviemenu.Append(wx.ID_ANY, _('Record'), _('Record'))
+                # moviemenu.Append(wx.ID_ANY, _('Record'), _('Record'))
                 moviemenu.Append(wx.ID_ANY, _('Load flight'), _('Load flight'))
                 moviemenu.Append(wx.ID_ANY, _('Save flight'), _('Save flight'))