wolfhece 2.1.117__py3-none-any.whl → 2.1.119__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
@@ -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
+    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
 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.")
@@ -557,6 +560,7 @@ class draw_type(Enum):
     WMSFORE = 'wms-foreground'
     TILES = 'tiles'
     IMAGESTILES = 'imagestiles'
+    LAZ = 'laz'
 
 class Colors_1to9(wx.Frame):
 
@@ -1171,6 +1175,8 @@ class WolfMapViewer(wx.Frame):
     myimagestiles: list[ImagesTiles]
     mypartsystems: list[Particle_system]
     myviewers3d:list[Wolf_Viewer3D]
+    mylazdata:list[Wolf_LAZ_Data]
+
     sim_explorers: dict[Wolfresults_2D:Sim_Explorer]
 
     canvas: GLCanvas  # canvas OpenGL
@@ -1196,10 +1202,12 @@ class WolfMapViewer(wx.Frame):
     active_imagestiles: ImagesTiles
     active_particle_system: Particle_system
     active_viewer3d: Wolf_Viewer3D
+    active_viewerlaz: viewerlaz
     active_bridges: Bridges
     active_bridge: Bridge
     active_weirs : Weirs
     active_weir : Weir
+    active_laz : Wolf_LAZ_Data
 
     def __init__(self,
                  wxparent = None,
@@ -1275,9 +1283,7 @@ class WolfMapViewer(wx.Frame):
         self.forcemimic = True
         self.currently_readresults = False
 
-        self.mylazdata = None
-        # self.mylazdata_colors = None
-        self.mylazgrid = None
+        self.mylazgrid:xyz_laz_grids = None # LAZ grid preprocessed by Numpy
 
         self.colors1to9 = Colors_1to9(self)
 
@@ -1309,7 +1315,7 @@ class WolfMapViewer(wx.Frame):
         self.menuimagestiles = None
 
         self.filemenu = wx.Menu()
-        openitem = self.filemenu.Append(wx.ID_OPEN, _('Open/Add project'), _('Open a complete project from file'))
+        openitem = self.filemenu.Append(wx.ID_OPEN, _('Open/Add project'), _('Open a full project from file'))
         saveproject = self.filemenu.Append(wx.ID_ANY, _('Save project as...'), _('Save the current project to file'))
         self.filemenu.AppendSeparator()
         saveitem = self.filemenu.Append(wx.ID_SAVE, _('Save'), _('Save all checked arrays or vectors to files'))
@@ -1535,6 +1541,7 @@ class WolfMapViewer(wx.Frame):
         self.active_res2d = None
         self.active_particle_system = None
         self.active_viewer3d = None
+        self.active_viewerlaz = None
         self.active_landmap:PlansTerrier = None
         self.active_tile = None
         self.selected_treeitem = None
@@ -1543,6 +1550,7 @@ class WolfMapViewer(wx.Frame):
         self.active_bridge = None
         self.active_weirs = None
         self.active_weir = None
+        self.active_laz = None
 
         curtool = self.tools[ID_SORTALONG] = {}
         curtool['menu'] = self.sortalong
@@ -1591,14 +1599,15 @@ class WolfMapViewer(wx.Frame):
 
         self.root = self.treelist.GetRootItem()
         self.treelist.AppendColumn(_('Objects to plot'))
-        self.myitemsarray = self.treelist.AppendItem(self.root, _("Arrays"))
+        self.myitemsarray  = self.treelist.AppendItem(self.root, _("Arrays"))
         self.myitemsvector = self.treelist.AppendItem(self.root, _("Vectors"))
-        self.myitemscloud = self.treelist.AppendItem(self.root, _("Clouds"))
-        self.myitemstri = self.treelist.AppendItem(self.root, _("Triangulations"))
-        self.myitemsres2d = self.treelist.AppendItem(self.root, _("Wolf2D"))
-        self.myitemsps = self.treelist.AppendItem(self.root, _("Particle systems"))
+        self.myitemscloud  = self.treelist.AppendItem(self.root, _("Clouds"))
+        self.myitemslaz    = self.treelist.AppendItem(self.root, _("Laz"))
+        self.myitemstri    = self.treelist.AppendItem(self.root, _("Triangulations"))
+        self.myitemsres2d  = self.treelist.AppendItem(self.root, _("Wolf2D"))
+        self.myitemsps     = self.treelist.AppendItem(self.root, _("Particle systems"))
         self.myitemsothers = self.treelist.AppendItem(self.root, _("Others"))
-        self.myitemsviews = self.treelist.AppendItem(self.root, _("Views"))
+        self.myitemsviews  = self.treelist.AppendItem(self.root, _("Views"))
         self.myitemswmsback = self.treelist.AppendItem(self.root, _("WMS-background"))
         self.myitemswmsfore = self.treelist.AppendItem(self.root, _("WMS-foreground"))
 
@@ -1922,17 +1931,20 @@ class WolfMapViewer(wx.Frame):
             self.menulaz.AppendSubMenu(self.menulazdata, _('LAZ data'))
             self.menulaz.AppendSubMenu(self.menulazgrid, _('LAZ grid'))
 
-            readlaz = self.menulazdata.Append(wx.ID_ANY, _('Initialize from npz'), _('LAZ from Numpy array'))
-            readlaz_gridinfo = self.menulazgrid.Append(wx.ID_ANY, _('Initialize from GridInfos'), _('LAZ from gridinfos - subgridding of LAZ files'), kind=wx.ITEM_CHECK)
+            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)
+            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'), _('LAZ Bridge'))
-            buildinglaz = self.menulazdata.Append(wx.ID_ANY, _('Create cloud points from buildings'), _('LAZ Buildings'))
+            bridgelaz = self.menulazdata.Append(wx.ID_ANY, _('Create cloud points from bridges'), _('Extract bridge from LAZ data as cloud points (class 10)'))
+            buildinglaz = self.menulazdata.Append(wx.ID_ANY, _('Create cloud points from buildings'), _('Extract buildings from LAZ data as cloud points (class 1)'))
+            classlaz = self.menulazdata.Append(wx.ID_ANY, _('Create cloud points from specified classes'), _('Extract cloud points from LAZ data (class to specify)'))
 
             croplaz = self.menulaz.Append(wx.ID_ANY, _('Clip LAZ grid on current zoom'), _('Select LAZ data based on the visible screen extent'),)
             viewlaz = self.menulaz.Append(wx.ID_ANY, _('Create LAZ viewer'), _('Create a LAZ Viewer based on loaded data'))
+            filterlaz = self.menulaz.Append(wx.ID_ANY, _('Filter data based on codes'), _('Filter LAZ data based on codes'),)
+            descimate_laz = self.menulaz.Append(wx.ID_ANY, _('Descimate LAZ data'), _('Descimate LAZ data'),)
             aroundlaz = self.menulaz.Append(wx.ID_ANY, _('Plot LAZ around active vector'), _('Display a Matplotlib plot with the LAZ values around the active vector/polyline'),)
             pick_aroundlaz = self.menulaz.Append(wx.ID_ANY, _('Plot LAZ around temporary vector'), _('Display a Matplotlib plot with the LAZ values around a temporary vector/polyline -- Right clicks to add points + Enter'),)
-            updatecolors_laz = self.menulaz.Append(wx.ID_ANY, _('Change colors - Classification'), _('Change color map associated to the current classification'),)
             fillarray_laz = self.menulaz.Append(wx.ID_ANY, _('Fill active array from LAZ data'), _('Fill an array from the LAZ data'),)
             selectarray_laz = self.menulaz.Append(wx.ID_ANY, _('Select cells in array from LAZ data'), _('Select nodes in active array from the LAZ data'),)
             countarray_laz = self.menulaz.Append(wx.ID_ANY, _('Count LAZ data in cells'), _('Count the number of LAZ data in each cell of the matrix'),)
@@ -3890,10 +3902,13 @@ class WolfMapViewer(wx.Frame):
         self.mywmsfore = []
         self.myres2D = []
         self.myviewers3d = []
+        self.myviewerslaz = []
+        self.mylazdata = []
+
         self.sim_explorers = {}
 
         # liste des éléments modifiable dans l'arbre
-        self.all_lists = [self.myarrays, self.myvectors, self.myclouds, self.mytri, self.myothers, self.myviews, self.myres2D, self.mytiles, self.myimagestiles, self.mypartsystems, self.myviewers3d]
+        self.all_lists = [self.myarrays, self.myvectors, self.myclouds, self.mytri, self.myothers, self.myviews, self.myres2D, self.mytiles, self.myimagestiles, self.mypartsystems, self.myviewers3d, self.myviewerslaz]
 
         self.menu_options = wx.Menu()
         self._change_title = self.menu_options.Append(wx.ID_ANY, _('Change title'), _('Change title of the window'))
@@ -3995,7 +4010,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
@@ -5524,22 +5539,66 @@ class WolfMapViewer(wx.Frame):
         """ Clip laz grid on current zoom """
 
         if self.mylazgrid is None:
+            logging.warning(_('No laz grid -- Please initialize it !'))
             return
 
         curbounds = [[self.xmin, self.xmin + self.width], [self.ymin, self.ymin + self.height]]
 
-        self.mylazdata = self.mylazgrid.scan(curbounds)
+        if self.active_laz is None:
+            newobj = Wolf_LAZ_Data()
+            newobj.classification = self.mylazgrid.colors
+            newobj.from_grid(self.mylazgrid, curbounds)
+
+            self.add_object('laz', newobj= newobj)
+
+        else:
+            dlg = wx.MessageDialog(None, _('Do you want to keep the current data ?'), _('Keep data ?'), wx.YES_NO | wx.ICON_QUESTION)
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_YES:
+                newobj = Wolf_LAZ_Data()
+                newobj.classification = self.mylazgrid.colors
+                newobj.from_grid(self.mylazgrid, curbounds)
+
+                self.add_object('laz', newobj= newobj)
+
+            else:
+
+                self.active_laz.from_grid(self.mylazgrid, curbounds)
 
-        logging.info(_('Clip LAZ grid on current zoom {}-{}  {}-{}').format(curbounds[0][0],curbounds[0][1],curbounds[1][0],curbounds[1][1]))
+        logging.info(_('Clip LAZ grid on current zoom'))
+        logging.info(_('Bounds {}-{}  {}-{}').format(curbounds[0][0],curbounds[0][1],curbounds[1][0],curbounds[1][1]))
+        logging.info(_('Nb points : {}').format(self.active_laz.num_points))
 
-    def decimate_laz_data(self, factor:int = 10):
-        """ Decimate data """
+    def filter_active_laz(self):
+        """ Filter active laz data """
 
-        if self.mylazdata is None:
+        if self.active_laz is None:
             logging.warning(_('No laz data'))
             return
 
-        self.mylazdata = self.mylazdata[::factor]
+        codes = self.active_laz.codes_unique()
+
+        names = [self.active_laz.classification.classification[curcode][0] for curcode in codes]
+
+        with wx.MultiChoiceDialog(None, _('Choose the codes to keep'), _('Codes'), names) as dlg:
+            if dlg.ShowModal() == wx.ID_OK:
+                used_codes = dlg.GetSelections()
+                used_codes = [codes[cur] for cur in used_codes]
+                self.active_laz.filter_data(used_codes)
+
+                logging.info(_('Filter done - Nb points : {}').format(self.active_laz.num_points))
+            else:
+                logging.info(_('Filter cancelled'))
+
+    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.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
@@ -5548,6 +5607,7 @@ class WolfMapViewer(wx.Frame):
         :param used_codes: codes to use
         """
         if self.mylazgrid is None:
+            logging.info(_('No laz grid - Aborting !'))
             return
 
         if array is None:
@@ -5581,19 +5641,19 @@ class WolfMapViewer(wx.Frame):
                 curbounds = [[curx, curx + chunk_size], [cury, cury + chunk_size]]
 
                 logging.info(_('Scan {}-{}  {}-{}').format(curbounds[0][0],curbounds[0][1],curbounds[1][0],curbounds[1][1]))
-                self.mylazdata = self.mylazgrid.scan(curbounds)
+                mylazdata = self.mylazgrid.scan(curbounds)
                 # logging.info(_('Scan done'))
 
                 data = {}
                 for curcode in used_codes:
-                    data[curcode] = self.mylazdata[self.mylazdata[:, 3] == curcode]
+                    data[curcode] = mylazdata[mylazdata[:, 3] == curcode]
 
                 for curdata in data.values():
 
                     if curdata.shape[0] == 0:
                         continue
 
-                    i,j = array.get_ij_from_xy(curdata[:, 0], curdata[:, 1]) #= np.float32(self.mylazdata[:, 2])
+                    i,j = array.get_ij_from_xy(curdata[:, 0], curdata[:, 1])
 
                     keys = np.vstack((i,j)).T
 
@@ -5616,6 +5676,7 @@ class WolfMapViewer(wx.Frame):
         """
 
         if self.mylazgrid is None:
+            logging.info(_('No laz grid - Aborting !'))
             return
 
         if array is None:
@@ -5679,16 +5740,16 @@ class WolfMapViewer(wx.Frame):
                 curbounds = [[curx, curx + chunk_size], [cury, cury + chunk_size]]
 
                 logging.info(_('Scan {}-{}  {}-{}').format(curbounds[0][0],curbounds[0][1],curbounds[1][0],curbounds[1][1]))
-                self.mylazdata = self.mylazgrid.scan(curbounds)
+                mylazdata = self.mylazgrid.scan(curbounds)
                 # logging.info(_('Scan done'))
 
-                if len(self.mylazdata) == 0:
+                if len(mylazdata) == 0:
                     continue
 
                 # Test codes
                 data = {}
                 for curcode in used_codes:
-                    data[curcode] = self.mylazdata[self.mylazdata[:, 3] == curcode]
+                    data[curcode] = mylazdata[mylazdata[:, 3] == curcode]
 
                 # Treat data for each code
                 for curdata in data.values():
@@ -5699,7 +5760,7 @@ class WolfMapViewer(wx.Frame):
                         logging.info(_('Code {} : {} points'.format(curdata[0,3], curdata.shape[0])))
 
                     # get i,j from x,y
-                    i,j = array.get_ij_from_xy(curdata[:, 0], curdata[:, 1]) #= np.float32(self.mylazdata[:, 2])
+                    i,j = array.get_ij_from_xy(curdata[:, 0], curdata[:, 1])
 
                     # keep only valid points -- inside the array
                     used = np.where((i >=0) & (i < array.nbx) & (j >=0) & (j < array.nby))[0]
@@ -5766,6 +5827,7 @@ class WolfMapViewer(wx.Frame):
         """
 
         if self.mylazgrid is None:
+            logging.info(_('No laz grid - Aborting !'))
             return
 
         if array is None:
@@ -5801,15 +5863,15 @@ class WolfMapViewer(wx.Frame):
                 curbounds = [[curx, curx + chunk_size], [cury, cury + chunk_size]]
 
                 logging.info(_('Scan {}-{}  {}-{}').format(curbounds[0][0],curbounds[0][1],curbounds[1][0],curbounds[1][1]))
-                self.mylazdata = self.mylazgrid.scan(curbounds)
+                mylazdata = self.mylazgrid.scan(curbounds)
 
-                if len(self.mylazdata) == 0:
+                if len(mylazdata) == 0:
                     continue
 
                 # Test codes
                 data = {}
                 for curcode in used_codes:
-                    data[curcode] = self.mylazdata[self.mylazdata[:, 3] == curcode]
+                    data[curcode] = mylazdata[mylazdata[:, 3] == curcode]
 
                 # Treat data for each code
                 for curdata in data.values():
@@ -5820,7 +5882,7 @@ class WolfMapViewer(wx.Frame):
                         logging.info(_('Code {} : {} points'.format(curdata[0,3], curdata.shape[0])))
 
                     # get i,j from x,y
-                    i,j = array.get_ij_from_xy(curdata[:, 0], curdata[:, 1]) #= np.float32(self.mylazdata[:, 2])
+                    i,j = array.get_ij_from_xy(curdata[:, 0], curdata[:, 1])
 
                     # keep only valid points -- inside the array
                     used = np.where((i >=0) & (i < array.nbx) & (j >=0) & (j < array.nby))[0]
@@ -5877,26 +5939,48 @@ class WolfMapViewer(wx.Frame):
 
         logging.info(_('Counting done'))
 
-    def init_laz_from_numpy(self, fn=None):
-        """ Read LAZ data stored in numpy array"""
+    def init_laz_from_lazlasnpz(self, fn=None):
+        """ Read LAZ data stored in one file
+
+        :param fn: filename (extension .laz, .las, .npz)
+        """
 
         if fn is None:
             filternpz = "npz (*.npz)|*.npz|LAZ (*.laz)|*.laz|LAS (*.las)|*.las|all (*.*)|*.*"
-            dlg = wx.FileDialog(None, _('Choose LAS file'), wildcard=filternpz)
+            dlg = wx.FileDialog(None, _('Choose a file containing LAS data'), wildcard=filternpz)
             ret = dlg.ShowModal()
             if ret != wx.ID_OK:
+                dlg.Destroy()
                 return
 
             fn = dlg.GetPath()
+            dlg.Destroy()
+
+        self.mylazdata.append(Wolf_LAZ_Data())
+        self.active_laz = self.mylazdata[-1]
+        self.active_laz.from_file(fn)
 
-        self.mylazdata = read_laz(fn)
-        # self.mylazdata_colors = Classification_LAZ()
-        # self.mylazdata_colors.init_2023()
+        logging.info(_('LAZ data read from file : ')+ fn)
+        logging.info(_('Stored in internal variable'))
 
         if self.linked:
             if len(self.linkedList) > 0:
                 for curframe in self.linkedList:
-                    curframe.mylazdata = self.mylazdata
+                    if not curframe is self:
+                        curframe.mylazdata.append(self.active_laz)
+
+    def _choice_laz_classification(self):
+
+        dlg = wx.SingleChoiceDialog(None, _('Choose the classification'), _('Classification'), ['SPW-Geofit 2023', 'SPW 2013-2014'], wx.CHOICEDLG_STYLE)
+        ret = dlg.ShowModal()
+        if ret != wx.ID_OK:
+            dlg.Destroy()
+            return None
+
+        classification = dlg.GetStringSelection()
+        dlg.Destroy()
+
+        return classification
 
     def init_laz_from_gridinfos(self, dirlaz:str = None, classification:Literal['SPW-Geofit 2023', 'SPW 2013-2014'] = 'SPW-Geofit 2023'):
 
@@ -5911,15 +5995,13 @@ class WolfMapViewer(wx.Frame):
         self.mylazgrid = xyz_laz_grids(dirlaz)
 
         if classification not in ['SPW-Geofit 2023', 'SPW 2013-2014']:
-            dlg = wx.SingleChoiceDialog(None, _('Choose the classification'), _('Classification'), ['SPW-Geofit 2023', 'SPW 2013-2014'], wx.CHOICEDLG_STYLE)
-            ret = dlg.ShowModal()
-            if ret != wx.ID_OK:
-                dlg.Destroy()
-                return
-            classification = dlg.GetStringSelection()
-            dlg.Destroy()
 
-        if classification == 'SPW 2013-2014':
+            classification = self._choice_laz_classification()
+
+        if classification is None:
+            logging.warning(_('No classification chosen - Abort !'))
+            return
+        elif classification == 'SPW 2013-2014':
             self.mylazgrid.colors.init_2013()
         else:
             self.mylazgrid.colors.init_2023()
@@ -6129,15 +6211,23 @@ class WolfMapViewer(wx.Frame):
     def _select_laz_source(self):
         """ Select laz source """
 
-        if self.mylazdata is None and self.mylazgrid is None:
-            logging.warning(_('No LAZ data loaded !'))
+        if self.active_laz is None and self.mylazgrid is None:
+            logging.warning(_('No LAZ data loaded/initialized !'))
             return None
-        elif self.mylazdata is None:
+        elif self.active_laz is None:
+            # No active laz data
             laz_source = self.mylazgrid
         elif self.mylazgrid is None:
-            laz_source = self.mylazdata
+            # No laz grid
+            laz_source = self.active_laz
         else:
-            choices = [_('From current loaded data'), _('From GridInfos')]
+            # 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:
@@ -6149,12 +6239,46 @@ class WolfMapViewer(wx.Frame):
             dlg.Destroy()
 
             if idx == 0:
-                laz_source = self.mylazdata
-            else:
+                laz_source = self.active_laz
+            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
 
+    def _choice_laz_colormap(self) -> int:
+
+        choices, ass_values = choices_laz_colormap()
+        dlg = wx.SingleChoiceDialog(None, _("Pick a colormap"), "Choices", choices)
+
+        if self.active_laz is not None:
+            dlg.SetSelection(ass_values.index(self.active_laz.associated_color))
+
+        ret = dlg.ShowModal()
+        if ret == wx.ID_CANCEL:
+            dlg.Destroy()
+            return
+
+        colormap = dlg.GetStringSelection()
+        idx = choices.index(colormap)
+        dlg.Destroy()
+
+        return ass_values[idx]
+
+
     def OnMenubar(self, event: wx.MenuEvent):
         """
         Gestion des clicks sur le menu quel que soit le niveau
@@ -6498,7 +6622,13 @@ class WolfMapViewer(wx.Frame):
 
                 dlg.Destroy()
 
-            fig, ax = self.active_vector.plot_mpl(True, False)
+            # 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)
 
             linkedarrays = self.get_linked_arrays()
 
@@ -6528,8 +6658,10 @@ class WolfMapViewer(wx.Frame):
                     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()
+                # fig.canvas.draw()
+                # fig.canvas.flush_events()
+
+            figmpl.Show()
 
         elif itemlabel == _("Compute and apply unique colormap on all..."):
             self.uniquecolormap()
@@ -6550,6 +6682,7 @@ 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
@@ -6579,7 +6712,14 @@ class WolfMapViewer(wx.Frame):
                 logging.info(_('Sole polygon detected'))
                 plotzone = [self.active_zone]
 
-            fig, ax = plt.subplots(1, 1)
+            # 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 = {}
 
@@ -6620,9 +6760,12 @@ class WolfMapViewer(wx.Frame):
                 # sole polygon
                 plotzone[0].plot_linked_polygons(fig, ax, linkedarrays, linked_vec=linkedvecs)
 
-            ax.grid()
-            ax.legend()
-            fig.show()
+            # ax.grid()
+            # ax.legend()
+            # fig.show()
+
+            figmpl.Show()
+            figmpl.CenterOnScreen()
 
         elif itemlabel == _("Manage banks..."):
 
@@ -6801,18 +6944,20 @@ class WolfMapViewer(wx.Frame):
 
             self.save_project(filename, absolute= abspath)
 
-        elif itemlabel == _('Initialize from npz'):
-            self.init_laz_from_numpy()
+        elif itemlabel == _('Initialize from laz, las or npz'):
+            self.init_laz_from_lazlasnpz()
 
-        elif itemlabel == _('Initialize from GridInfos'):
+        elif itemlabel == _('Initialize from directory'):
             self.init_laz_from_gridinfos()
 
         elif itemlabel == _('Create cloud points from bridges'):
-            if self.mylazdata is None:
-                self.init_laz_from_numpy()
 
-            mybridges = self.mylazdata[np.where(self.mylazdata[:, 3] == 10)]
+            if self.active_laz is None:
+                self.init_laz_from_lazlasnpz()
+
+            mybridges = self.active_laz.get_data_class(10)
             mycloud = cloud_vertices()
+
             mycloud.init_from_nparray(mybridges)
             mycloud.myprop.style = 2
             mycloud.myprop.color = getIfromRGB([255, 102, 102])
@@ -6827,11 +6972,12 @@ class WolfMapViewer(wx.Frame):
 
         elif itemlabel == _('Create cloud points from buildings'):
 
-            if self.mylazdata is None:
-                self.init_laz_from_numpy()
+            if self.active_laz is None:
+                self.init_laz_from_lazlasnpz()
 
-            mybuildings = self.mylazdata[np.where(self.mylazdata[:, 3] == 1)]
+            mybuildings = self.active_laz.get_data_class(1)
             mycloud = cloud_vertices()
+
             mycloud.init_from_nparray(mybuildings)
             mycloud.myprop.style = 2
             mycloud.myprop.color = getIfromRGB([102, 102, 102])
@@ -6843,23 +6989,15 @@ class WolfMapViewer(wx.Frame):
             else:
                 self.add_object('cloud', newobj=mycloud, ToCheck=True, id='Buildings')
 
+        elif itemlabel == _('Create cloud points from specified classes'):
+            pass
+
         elif itemlabel == _('Create LAZ viewer'):
 
             laz_source = self._select_laz_source()
             if laz_source is None:
                 return
 
-            choices, ass_values = choices_laz_colormap()
-            dlg = wx.SingleChoiceDialog(None, _("Pick a colormap"), "Choices", choices)
-            ret = dlg.ShowModal()
-            if ret == wx.ID_CANCEL:
-                dlg.Destroy()
-                return
-
-            colormap = dlg.GetStringSelection()
-            idx = choices.index(colormap)
-            dlg.Destroy()
-
             if laz_source is self.mylazgrid:
                 if self.mylazgrid is None:
                     logging.warning(_('No gridded LAZ data loaded !'))
@@ -6867,9 +7005,43 @@ class WolfMapViewer(wx.Frame):
                 autoscale=False
                 self.clip_laz_gridded()
 
-                self.myviewer = myviewer(self.mylazdata, ass_values[idx], palette_classif = self.mylazgrid.colors)
+                self.active_laz.create_viewer(self._choice_laz_colormap(), self.mylazgrid.colors)
+                self.myviewerslaz.append(self.active_laz.viewer)
+                self.active_viewerlaz = self.myviewerslaz[-1]
+
+                # self.myviewer = myviewer(self.active_laz.data, ass_values[idx], palette_classif = self.mylazgrid.colors)
             else:
-                self.myviewer = myviewer(laz_source, ass_values[idx]) #, palette_classif = self.mylazdata_colors)
+                self.active_laz.create_viewer(classification= self.mylazgrid.colors)
+                self.myviewerslaz.append(self.active_laz.viewer)
+                self.active_viewerlaz = self.myviewerslaz[-1]
+
+                # self.myviewer = myviewer(laz_source.data, ass_values[idx], palette_classif= laz_source.classification)
+
+        elif itemlabel == _('Filter data based on codes'):
+
+            self.filter_active_laz()
+
+        elif itemlabel == _('Descimate LAZ data'):
+
+            if self.active_laz is None:
+                return
+
+            # Choose a decimation factor - integer
+            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()
+
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            descimate_fact = dlg.GetValue()
+            dlg.Destroy()
+
+            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'):
 
@@ -6879,14 +7051,15 @@ class WolfMapViewer(wx.Frame):
 
             self.clip_laz_gridded()
 
-            if self.mylazdata is None:
+            if self.active_laz is None:
+                logging.error(_('No data found'))
                 return
 
-            if self.mylazdata.shape[0] > 100_000_000:
+            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()
 
@@ -6894,11 +7067,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'):
 
@@ -7991,7 +8164,7 @@ class WolfMapViewer(wx.Frame):
                                  'weirs',
                                  'vector',
                                  'tiles', 'tilescomp'
-                                 'cloud',
+                                 'cloud', 'laz',
                                  'triangulation',
                                  'cross_sections',
                                  'other',
@@ -8011,12 +8184,13 @@ class WolfMapViewer(wx.Frame):
         Add object to current Frame/Drawing area
         """
 
-        filterArray = "All supported formats|*.bin;*.tif;*.tiff;*.top;*.flt;*.npy;*.npz|bin (*.bin)|*.bin|Elevation WOLF2D (*.top)|*.top|Geotif (*.tif)|*.tif|Float ESRI (*.flt)|*.flt|Numpy (*.npy)|*.npy|Numpy named arrays(*.npz)|*.npz|all (*.*)|*.*"
+        filterArray = "All supported formats|*.bin;*.tif;*.tiff;*.top;*.flt;*.npy;*.npz;*.vrt|bin (*.bin)|*.bin|Elevation WOLF2D (*.top)|*.top|Geotif (*.tif)|*.tif|Float ESRI (*.flt)|*.flt|Numpy (*.npy)|*.npy|Numpy named arrays(*.npz)|*.npz|all (*.*)|*.*"
         filterjson = "json (*.json)|*.json|all (*.*)|*.*"
         filterall = "all (*.*)|*.*"
         filterres2d = "all (*.*)|*.*"
         filterVector = "All supported formats|*.vec;*.vecz;*.dxf;*.shp|vec (*.vec)|*.vec|vecz (*.vecz)|*.vecz|dxf (*.dxf)|*.dxf|shp (*.shp)|*.shp|all (*.*)|*.*"
         filterCloud = "xyz (*.xyz)|*.xyz|dxf (*.dxf)|*.dxf|text (*.txt)|*.txt|shp (*.shp)|*.shp|all (*.*)|*.*"
+        filterlaz = "laz (*.laz)|*.laz|las (*.las)|*.las|Numpy (*.npz)|*.npz|all (*.*)|*.*"
         filtertri = "tri (*.tri)|*.tri|text (*.txt)|*.txt|dxf (*.dxf)|*.dxf|gltf (*.gltf)|*.gltf|gltf binary (*.glb)|*.glb|*.*'all (*.*)|*.*"
         filterCs = "vecz WOLF (*.vecz)|*.vecz|txt 2022 (*.txt)|*.txt|WOLF (*.sxy)|*.sxy|text 2000 (*.txt)|*.txt|all (*.*)|*.*"
         filterimage = "Geotif (*.tif)|*.tif|all (*.*)|*.*"
@@ -8043,6 +8217,8 @@ class WolfMapViewer(wx.Frame):
                 file = wx.FileDialog(self, "Choose file", wildcard=filterVector)
             elif which.lower() == 'cloud':
                 file = wx.FileDialog(self, "Choose file", wildcard=filterCloud)
+            elif which.lower() == 'laz':
+                file = wx.FileDialog(self, "Choose file", wildcard=filterlaz)
             elif which.lower() == 'triangulation':
                 file = wx.FileDialog(self, "Choose file", wildcard=filtertri)
             elif which.lower() == 'cross_sections':
@@ -8543,6 +8719,19 @@ class WolfMapViewer(wx.Frame):
             self.myvectors.append(newobj)
             newobj.mapviewer = self
 
+        elif which.lower() =='laz':
+            curdict = self.mylazdata
+            curtree = self.myitemslaz
+
+            if newobj is None:
+                newobj = Wolf_LAZ_Data(mapviewer=self)
+                newobj.from_file(filename)
+
+            self.mylazdata.append(newobj)
+            self.active_laz = newobj
+
+            newobj.set_mapviewer(self)
+
         elif which.lower() == 'cloud':
 
             curdict = self.myclouds
@@ -8784,6 +8973,8 @@ class WolfMapViewer(wx.Frame):
             return self.mywmsfore
         elif drawing_type == draw_type.IMAGESTILES:
             return self.myimagestiles
+        elif drawing_type == draw_type.LAZ:
+            return self.mylazdata
         else:
             logging.error('Unknown drawing type : ' + drawing_type)
             return None
@@ -9214,10 +9405,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]:
+            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):
@@ -9365,6 +9566,158 @@ class WolfMapViewer(wx.Frame):
                     self.selected_object.export_active_zone_to_shapefile(fdlg.GetPath())
                 fdlg.Destroy()
 
+        elif _('Set colormap') in text:
+
+            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, Wolf_LAZ_Data):
+                self.selected_object.interactive_update_colors()
+
+        elif _('Set classification') in text:
+
+            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, 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)
+                    ret = dlg.ShowModal()
+
+                    if ret != wx.ID_YES:
+                        dlg.Destroy()
+
+                        return
+
+                newcloud = cloud_vertices()
+                newcloud.init_from_nparray(self.selected_object.xyz)
+                self.add_object('cloud', newobj=newcloud, id=self.selected_object.idx + '_cloud')
+
+        elif _('Selection to cloud') in text:
+
+            if isinstance(self.selected_object, Wolf_LAZ_Data):
+
+                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
+
+                newcloud = cloud_vertices()
+                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, 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, 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:
+                    self.selected_object.record_flight(dlg.GetPath())
+
+                dlg.Destroy()
+
+        elif _('Load flight') in text:
+
+            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())
+
+                dlg.Destroy()
+
+        elif _('Save flight') in text:
+
+            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())
+
+                dlg.Destroy()
 
     def OnClose(self, event):
         """ Close the application """
@@ -10078,14 +10431,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):
 
@@ -10151,6 +10517,13 @@ class WolfMapViewer(wx.Frame):
             if ctrl:
                 myobj.show_properties()
 
+        elif type(myobj) == Wolf_LAZ_Data:
+
+            self.active_laz = myobj
+
+            if ctrl:
+                myobj.show_properties()
+
         elif type(myobj) == Bridge:
             self.active_bridge = myobj
 
@@ -11825,6 +12198,10 @@ class WolfMapViewer(wx.Frame):
                 self.mousex = self.mousex + self.width / 10.
                 self.setbounds()
 
+            elif key == ord('A'):
+                if self.active_laz is not None:
+                    self.active_laz.add_pose_in_memory()
+
     def paste_values(self,fromarray:WolfArray):
         """ Paste selected values from a WolfArray to the active array """
 
@@ -11875,6 +12252,20 @@ class WolfMapViewer(wx.Frame):
             tracks.append(_('Export active zone to Shape file'))
             tracks.append(_('Rebin'))
             tracks.append(_('Set NullValue'))
+            tracks.append(_('Set colormap'))
+            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'))
+
+            tracks.append(_('Colormap'))
+            tracks.append(_('Movie'))
+            tracks.append(_('Play'))
+            tracks.append(_('Record'))
+            tracks.append(_('Load flight'))
+            tracks.append(_('Save flight'))
 
             # Récupération des items du menu contextuel
             menuitems = self.popupmenu.GetMenuItems()
@@ -11917,6 +12308,33 @@ 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, Wolf_LAZ_Data):
+
+                colrmapmenu = wx.Menu()
+                self.popupmenu.AppendSubMenu(colrmapmenu, _('Colormap'))
+
+                colrmapmenu.Append(wx.ID_ANY, _('Set colormap'), _('Change colormap'))
+                colrmapmenu.Append(wx.ID_ANY, _('Edit colormap'), _('Edit colormap'))
+                colrmapmenu.Append(wx.ID_ANY, _('Set classification'), _('Change classification'))
+
+                converttomenu  = wx.Menu()
+                self.popupmenu.AppendSubMenu(converttomenu, _('Convert to...'))
+
+                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, _('Load flight'), _('Load flight'))
+                moviemenu.Append(wx.ID_ANY, _('Save flight'), _('Save flight'))
+
             self.treelist.PopupMenu(self.popupmenu)
 
     def update(self):