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

wolfhece/PyDraw.py

@@ -84,7 +84,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, Base_LAZ_Data, viewer as viewerlaz
     from . import Lidar2002
     from .picc import Picc_data, Cadaster_data
     from .wolf_zi_db import ZI_Databse_Elt, PlansTerrier
@@ -129,6 +129,44 @@ ID_PLOTCS = 1003   #Manageactions ID for profile plots
 
 LIST_1TO9 = [wx.WXK_NUMPAD1, wx.WXK_NUMPAD2, wx.WXK_NUMPAD3, wx.WXK_NUMPAD4, wx.WXK_NUMPAD5, wx.WXK_NUMPAD6, wx.WXK_NUMPAD7, wx.WXK_NUMPAD8, wx.WXK_NUMPAD9 ] + [ord(str(cur)) for cur in range(1,10)]
 
+PROJECT_ACTION = 'action'
+PROJECT_CS     = 'cross_sections'
+PROJECT_VECTOR = 'vector'
+PROJECT_ARRAY  = 'array'
+PROJECT_TILES  = 'tiles'
+PROJECT_LAZ    = 'laz_grid'
+PROJECT_CLOUD  = 'cloud'
+PROJECT_WOLF2D = 'wolf2d'
+PROJECT_GPU2D  = 'gpu2d'
+PROJECT_PALETTE = 'palette'
+PROJECT_PALETTE_ARRAY = 'palette-array'
+PROJECT_LINK_CS = 'cross_sections_link'
+PROJECT_LINK_VEC_ARRAY = 'vector_array_link'
+
+PROJECT_GROUP_KEYS = {PROJECT_ACTION : {'which': 'compare_arrays'},
+                      PROJECT_CS: {'id - file': 'id to use - full or relative path to CS file',
+                                          'format': '(mandatory) 2000, 2022, vecz, sxy',
+                                          'dirlaz': 'Path to LAZ data (prepro Numpy)'},
+                      PROJECT_VECTOR: {'id - file': 'id to use - full or relative path to vector file (.vec, .vecz, .shp)'},
+                      PROJECT_ARRAY: {'id - file': 'id to use - full or relative path to array file (.bin, .tif, .npy, .npz)'},
+                      PROJECT_TILES : {'id': '(mandatory) id to use',
+                                  'tiles_file': '(mandatory) Path to tiles file',
+                                  'data_dir': '(mandatory) Path to data directory',
+                                  'comp_dir': 'Path to comparison directory'},
+                      PROJECT_LAZ: {'data_dir': '(mandatory) Path to data directory (prepro Numpy)',
+                                    'classification': 'Color classification for LAZ data - default SPW-Geofit 2023',},
+                      PROJECT_CLOUD: {'id - file': 'id to use - full or relative path to cloud file (.xyz, .txt)'},
+                      PROJECT_WOLF2D: {'id - dir': 'id to use - full or relative path to wolf2d simulation directory'},
+                      PROJECT_GPU2D: {'id - dir': 'id to use - full or relative path to gpu2d simulation directory'},
+                      PROJECT_PALETTE : {'id - file': 'id to use - full or relative path to palette file (.pal)'},
+                      PROJECT_PALETTE_ARRAY : {'idarray - idpal': 'id of array - id of palette to link'},
+                      PROJECT_LINK_CS : {'linkzones' : '(mandatory) id of vector to link to cross sections',
+                                                'sortzone' : '(mandatory) id of the zone to use for sorting',
+                                                'sortname' : '(mandatory) id of the polyline to use for sorting',
+                                                'downfirst' : 'is the first vertex downstream or upstream? (1 is True, 0 is False - default is False)'},
+                      PROJECT_LINK_VEC_ARRAY : {'id - id vector': 'id of array/wolf2d/gpu2d - id of vector to link (only 1 vector in 1 zone)'},
+                    }
+
 class Memory_View():
     """ Memory view """
 
@@ -519,6 +557,7 @@ class draw_type(Enum):
     WMSFORE = 'wms-foreground'
     TILES = 'tiles'
     IMAGESTILES = 'imagestiles'
+    LAZ = 'laz'
 
 class Colors_1to9(wx.Frame):
 
@@ -1133,6 +1172,8 @@ class WolfMapViewer(wx.Frame):
     myimagestiles: list[ImagesTiles]
     mypartsystems: list[Particle_system]
     myviewers3d:list[Wolf_Viewer3D]
+    mylazdata:list[Base_LAZ_Data]
+
     sim_explorers: dict[Wolfresults_2D:Sim_Explorer]
 
     canvas: GLCanvas  # canvas OpenGL
@@ -1158,10 +1199,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 : Base_LAZ_Data
 
     def __init__(self,
                  wxparent = None,
@@ -1232,12 +1275,12 @@ class WolfMapViewer(wx.Frame):
         self.linkedList = None
         self.link_params = None
 
+        self.project_pal = None
+
         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)
 
@@ -1269,8 +1312,8 @@ class WolfMapViewer(wx.Frame):
         self.menuimagestiles = None
 
         self.filemenu = wx.Menu()
-        openitem = self.filemenu.Append(wx.ID_OPEN, _('Open project'), _('Open a complete project from file'))
-        saveproject = self.filemenu.Append(wx.ID_ANY, _('Save project'), _('Save the current project to 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'))
         saveasitem = self.filemenu.Append(wx.ID_SAVEAS, _('Save as...'), _('Save all checked arrays or vectors to new files --> one file dialog per data'))
@@ -1495,6 +1538,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
@@ -1503,6 +1547,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
@@ -1517,6 +1562,7 @@ class WolfMapViewer(wx.Frame):
         # Help
         self.helpmenu = wx.Menu()
         self.helpmenu.Append(wx.ID_ANY, _('Shortcuts'), _('Shortcuts'))
+        self.helpmenu.Append(wx.ID_ANY, _('Project .proj'), _('A project file ".proj", what is it?'))
         self.helpmenu.Append(wx.ID_ANY, _('Show logs/informations'), _('Logs'))
         self.helpmenu.Append(wx.ID_ANY, _('Show values'), _('Data/Values'))
         self.helpmenu.Append(wx.ID_ANY, _('About'), _('About'))
@@ -1550,14 +1596,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"))
 
@@ -1881,17 +1928,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'),)
@@ -3849,10 +3899,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'))
@@ -4872,258 +4925,589 @@ class WolfMapViewer(wx.Frame):
         """
         curdir = Path(os.getcwd())
 
-        myproject = Wolf_Param(None, filename=fn, toShow=False)
-
-        mykeys = ['cross_sections', 'vector', 'array']
+        real_ids = {}
 
-        if 'which' in myproject.myparams.keys():
-            which = myproject.myparams['which']['action'][key_Param.VALUE]
-            if which == 'compare':
-                ListCompare = []
-                if 'array' in myproject.myparams.keys():
-                    for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
-                        ListCompare.append(WolfArray(normpath(curname[key_Param.VALUE])))
+        myproject = Wolf_Param(None, filename=fn, toShow=False)
 
-                self.set_compare(ListCompare)
-                return
+        def check_params(myproject, curgroup) -> bool:
 
-        if 'cross_sections' in myproject.myparams.keys():
-            for curid, curname in zip(myproject.myparams['cross_sections'].keys(),
-                                    myproject.myparams['cross_sections'].values()):
-                if curid != 'format' and curid != 'dirlaz':
-                    mycs = crosssections(curname[key_Param.VALUE],
-                                        format=myproject.myparams['cross_sections']['format'][key_Param.VALUE],
-                                        dirlaz=myproject.myparams['cross_sections']['dirlaz'][key_Param.VALUE],
-                                        mapviewer = self)
+            check = True
+            pot_keys = list(PROJECT_GROUP_KEYS[curgroup].keys())
 
-                    self.add_object('cross_sections', newobj=mycs, id=curid)
+            for curkey in pot_keys:
+                if 'mandatory' in PROJECT_GROUP_KEYS[curgroup][curkey]:
+                    if not myproject.is_in(curgroup, curkey):
+                        logging.warning(_('Missing key : ')+ curkey)
+                        check = False
+            return check
 
+        def sanit_id(id:str, drawtype:draw_type) -> str:
+            existing_id = self.get_list_keys(drawtype, None)
 
-        if myproject.get_group('tiles') is not None:
+            while id in existing_id:
+                logging.warning(_('ID already exists - Changing it...'))
+                id = id + '_'
 
-            curid = myproject.get_param('tiles', 'id')
-            curfile = myproject.get_param('tiles', 'tiles_file')
-            curdatadir = myproject.get_param('tiles', 'data_dir')
-            curcompdir = myproject.get_param('tiles', 'comp_dir')
+            return id
 
-            if exists(curfile):
-                mytiles = Tiles(filename= curfile, parent=self, linked_data_dir=curdatadir)
-                mytiles.set_comp_dir(curcompdir)
-                self.add_object('tiles', newobj=mytiles, id=curid)
-            else:
-                logging.info(_('Bad parameter in project file - tiles : ')+ curfile)
+        # COMPLEX ACTIONS
+        curgroup = PROJECT_ACTION
+        if myproject.is_in(curgroup):
 
-        if myproject.get_group('laz_grid') is not None:
+            pot_keys = list(PROJECT_GROUP_KEYS[curgroup].keys())
 
-            curdatadir = myproject.get_param('laz_grid', 'data_dir')
+            for curkey in pot_keys:
+                which = myproject[(curgroup, curkey)]
 
-            self.init_laz_from_gridinfos(curdatadir)
+                pot_val = list(PROJECT_GROUP_KEYS[curgroup][curkey].keys())
 
-        if 'vector' in myproject.myparams.keys():
-            for curid, curname in zip(myproject.myparams['vector'].keys(), myproject.myparams['vector'].values()):
-                if exists(curname[key_Param.VALUE]):
-                    myvec = Zones(curname[key_Param.VALUE], parent=self, mapviewer = self)
-                    self.add_object('vector', newobj=myvec, id=curid)
-                else:
-                    logging.info(_('Bad parameter in project file - vector : ')+ curname[key_Param.VALUE])
+                if which in pot_val:
+                    if which == 'compare_arrays':
 
-        if 'array' in myproject.myparams.keys():
-            for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
+                        # Comparaison de plusieurs matrices
 
-                if exists(curname[key_Param.VALUE]):
-                    curarray = WolfArray(curname[key_Param.VALUE], mapviewer=self)
-                    self.add_object('array', newobj=curarray, id=curid)
-                else:
-                    logging.info(_('Bad parameter in project file - array : ')+ curname[key_Param.VALUE])
+                        logging.info(_('Compare action - Searching for arrays to compare...'))
+                        ListCompare = []
+                        if myproject.is_in('array'):
+                            for curval in myproject.get_group('array').values():
+                                curid = curval[key_Param.NAME]
+                                logging.info(_('Array to compare : ')+ curid)
+                                ListCompare.append(WolfArray(Path(myproject[('array', curid)])))
+                        else:
+                            logging.warning(_('No array to compare - Aborting !'))
+                            return
 
-        if 'cloud' in myproject.myparams.keys():
-            for curid, curname in zip(myproject.myparams['cloud'].keys(), myproject.myparams['cloud'].values()):
-                if exists(curname[key_Param.VALUE]):
-                    mycloud = cloud_vertices(curname[key_Param.VALUE], mapviewer=self)
-                    self.add_object('cloud', newobj=mycloud, id=curid)
+                        logging.info(_('Setting compare...'))
+                        self.set_compare(ListCompare)
+                        logging.info(_('Compare set !'))
+                        return
                 else:
-                    logging.info(_('Bad parameter in project file - cloud : ')+ curname[key_Param.VALUE])
+                    logging.error(_('Bad parameter in project file - action : ')+ which)
+
+        # CROSS SECTIONS
+        curgroup = PROJECT_CS
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                for curval in myproject.get_group(curgroup).values():
+                    curid = curval[key_Param.NAME]
+                    if curid != 'format' and curid != 'dirlaz':
+                        mycs = crosssections(myproject[(curgroup, curid)],
+                                            format = myproject[(curgroup, 'format')],
+                                            dirlaz = myproject[(curgroup, 'dirlaz')],
+                                            mapviewer = self)
+
+                        locid = real_ids[(draw_type.VECTORS, curid)] = sanit_id(curid, draw_type.VECTORS)
+
+                        self.add_object(curgroup, newobj=mycs, id=locid)
+            else:
+                logging.warning(_('Bad parameter in project file - cross_sections'))
+
+        # TILES
+        curgroup = PROJECT_TILES
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                curid      = myproject.get_param(curgroup, 'id')
+                curfile    = myproject.get_param(curgroup, 'tiles_file')
+                curdatadir = myproject.get_param(curgroup, 'data_dir')
+                curcompdir = myproject.get_param(curgroup, 'comp_dir')
+
+                if exists(curfile):
+                    try:
+                        mytiles = Tiles(filename= curfile, parent=self, linked_data_dir=curdatadir)
+                        mytiles.set_comp_dir(curcompdir)
 
-        if 'wolf2d' in myproject.myparams.keys():
-            for curid, curname in zip(myproject.myparams['wolf2d'].keys(), myproject.myparams['wolf2d'].values()):
-                if exists(curname[key_Param.VALUE]):
-                    curwolf = Wolfresults_2D(curname[key_Param.VALUE], mapviewer=self)
-                    self.add_object('res2d', newobj=curwolf, id=curid)
+                        locid = real_ids[(draw_type.TILES, curid)] = sanit_id(curid, draw_type.TILES)
+                        self.add_object(curgroup, newobj=mytiles, id=locid)
+                    except Exception as e:
+                        logging.error(_('Error in tiles import : ')+ str(e))
                 else:
-                    logging.info(_('Bad parameter in project file - wolf2d : ')+ curname[key_Param.VALUE])
+                    logging.warning(_('File does not exist : ')+ curfile)
+            else:
+                logging.warning(_('Bad parameter in project file - tiles'))
 
-            self.menu_wolf2d()
+        # LAZ GRID
+        curgroup = PROJECT_LAZ
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                try:
+                    self.init_laz_from_gridinfos(myproject[curgroup, 'data_dir'], myproject[(curgroup, 'classification')])
+                except Exception as e:
+                    logging.error(_('Error in laz_grid import : ')+ str(e))
+            else:
+                logging.warning(_('Bad parameter in project file - laz_grid'))
+
+        # VECTOR DATA
+        curgroup = PROJECT_VECTOR
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                for curval in myproject.get_group(curgroup).values():
+                    curid = curval[key_Param.NAME]
+                    name  = curval[key_Param.VALUE]
+                    if exists(name):
+                        try:
+                            myvec = Zones(name, parent = self, mapviewer = self)
+
+                            locid = real_ids[(draw_type.VECTORS, curid)] = sanit_id(curid, draw_type.VECTORS)
+                            self.add_object(curgroup, newobj = myvec, id = locid)
+                        except Exception as e:
+                            logging.error(_('Error in vector import : ')+ str(e))
+                    else:
+                        logging.info(_('File does not exist : ') + name)
+            else:
+                logging.warning(_('Bad parameter in project file - vector'))
+
+        # ARRAY DATA
+        curgroup = PROJECT_ARRAY
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                for curval in myproject.get_group(curgroup).values():
+                    curid = curval[key_Param.NAME]
+                    name  = curdir / Path(curval[key_Param.VALUE])
+                    if exists(name):
+                        try:
+                            curarray = WolfArray(name, mapviewer = self)
+
+                            locid = real_ids[(draw_type.ARRAYS, curid)] = sanit_id(curid, draw_type.ARRAYS)
+                            self.add_object('array', newobj=curarray, id = locid)
+                        except Exception as e:
+                            logging.error(_('Error in array import : ')+ str(e))
+                    else:
+                        logging.info(_('File does not exist : ') + name)
+            else:
+                logging.warning(_('Bad parameter in project file - array'))
+
+        # CLOUD DATA
+        curgroup = PROJECT_CLOUD
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                for curval in myproject.get_group(curgroup).values():
+                    curid = curval[key_Param.NAME]
+                    name  = curval[key_Param.VALUE]
+                    if exists(name):
+                        try:
+                            mycloud = cloud_vertices(name, mapviewer = self)
+
+                            locid = real_ids[(draw_type.CLOUD, curid)] = sanit_id(curid, draw_type.CLOUD)
+                            self.add_object('cloud', newobj = mycloud, id = locid)
+                        except Exception as e:
+                            logging.error(_('Error in cloud import : ') + str(e))
+                    else:
+                        logging.info(_('File does not exist : ') + name)
+            else:
+                logging.warning(_('Bad parameter in project file - cloud'))
+
+        # 2D RESULTS
+
+        # CPU code
+        curgroup = PROJECT_WOLF2D
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                for curval in myproject.get_group(curgroup).values():
+                    curid  = curval[key_Param.NAME]
+                    simdir = Path(curval[key_Param.VALUE])
+                    if simdir.exists():
+                        try:
+                            curwolf = Wolfresults_2D(simdir, mapviewer = self)
+
+                            locid = real_ids[(draw_type.RES2D, curid)] = sanit_id(curid, draw_type.RES2D)
+                            self.add_object('res2d', newobj = curwolf, id = locid)
+                        except Exception as e:
+                            logging.error(_('Error in wolf2d import : ')+ str(e))
+                    else:
+                        logging.info(_('Directory does not exist ')) + simdir
 
-        if 'gpu2d' in myproject.myparams.keys():
+                self.menu_wolf2d()
+            else:
+                logging.warning(_('Bad parameter in project file - wolf2d'))
+
+        # GPU code
+        curgroup = PROJECT_GPU2D
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+
+                pgbar = wx.ProgressDialog(_('Loading GPU results'), _('Loading GPU results'), maximum=len(myproject.myparams[curgroup].keys()), parent=self, style=wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
+
+                for curval in myproject.get_group(curgroup).values():
+                    curid  = curval[key_Param.NAME]
+                    simdir = Path(curval[key_Param.VALUE])
+                    if simdir.exists():
+                        try:
+                            curwolf = wolfres2DGPU(curdir / simdir, mapviewer = self)
+
+                            locid = real_ids[(draw_type.RES2D, curid)] = sanit_id(curid, draw_type.RES2D)
+                            self.add_object('res2d', newobj = curwolf, id = locid)
+                        except Exception as e:
+                            logging.error(_('Error in gpu2d import : ')+ str(e))
+                    else:
+                        logging.info(_('Bad directory : ') + simdir)
 
-            pgbar = wx.ProgressDialog(_('Loading GPU results'), _('Loading GPU results'), maximum=len(myproject.myparams['gpu2d'].keys()), parent=self, style=wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
+                    pgbar.Update(pgbar.GetValue() + 1)
 
-            for curid, curname in zip(myproject.myparams['gpu2d'].keys(), myproject.myparams['gpu2d'].values()):
-                if exists(curname[key_Param.VALUE]):
+                pgbar.Destroy()
 
-                    if 'simul_gpu_results' in curname[key_Param.VALUE]:
-                        curwolf = wolfres2DGPU(curdir / Path(curname[key_Param.VALUE]), mapviewer=self)
-                    else:
-                        if exists(join(curname[key_Param.VALUE], 'simul_gpu_results')):
-                            curwolf = wolfres2DGPU(curdir / Path(join(curname[key_Param.VALUE], 'simul_gpu_results')), mapviewer=self)
+                self.menu_wolf2d()
+                self.menu_2dgpu()
+            else:
+                logging.warning(_('Bad parameter in project file - gpu2d'))
+
+        # PALETTE/COLORMAP
+        curgroup = PROJECT_PALETTE
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                self.project_pal = {}
+                for curval in myproject.get_group(curgroup).values():
+                    curid = curval[key_Param.NAME]
+                    name  = Path(curval[key_Param.VALUE])
+                    if name.exists():
+                        if name.suffix == '.pal':
+                            mypal = wolfpalette(None, '')
+                            mypal.readfile(name)
+                            mypal.automatic = False
+
+                            self.project_pal[curid] = mypal
                         else:
-                            logging.info(_('Bad directory : ')+ curname[key_Param.VALUE])
+                            logging.warning(_('Bad palette file : ')+ name)
+                    else:
+                        logging.info(_('Bad parameter in project file - palette : ')+ name)
+            else:
+                logging.warning(_('Bad parameter in project file - palette'))
 
-                    self.add_object('res2d', newobj=curwolf, id=curid)
+        # LINKS
+        curgroup = PROJECT_PALETTE_ARRAY
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                curarray: WolfArray
+                if self.project_pal is not None:
+
+                    for curval in myproject.get_group(curgroup).keys():
+                        id_array = curval[key_Param.NAME]
+                        id_pal = curval[key_Param.VALUE]
+                        if id_pal in self.project_pal.keys():
+                            try:
+                                curarray = self.getobj_from_id(real_ids[(draw_type.ARRAYS, id_array)])
+                                if curarray is not None:
+                                    mypal:wolfpalette
+                                    mypal = self.project_pal[id_pal]
+                                    curarray.mypal = mypal
+                                    if mypal.automatic:
+                                        curarray.myops.palauto.SetValue(1)
+                                    else:
+                                        curarray.myops.palauto.SetValue(0)
+                                    curarray.updatepalette(0)
+                                    curarray.reset_plot()
+                                else:
+                                    logging.warning(_('Bad parameter in project file - palette-array : ')+ id_array)
+                            except Exception as e:
+                                logging.error(_('Error in palette-array link : ')+ str(e))
+                        else:
+                            logging.warning(_('Bad parameter in project file - palette-array : ')+ id_pal)
                 else:
-                    logging.info(_('Bad directory : ')+ curname[key_Param.VALUE])
+                    logging.warning(_('No palettes found in project file ! -- Add palette group in the .proj'))
+            else:
+                logging.warning(_('Bad parameter in project file - palette-array'))
 
-                pgbar.Update(pgbar.GetValue() + 1)
+        curgroup = PROJECT_LINK_CS
+        if myproject.is_in(curgroup):
+            if self.active_cs is not None:
+                if check_params(myproject, curgroup):
 
-            pgbar.Destroy()
+                    idx = real_ids[(draw_type.VECTORS, myproject[(curgroup, 'linkzones')])]
+                    curzones = self.get_obj_from_id(idx, draw_type.VECTORS)
 
-            self.menu_wolf2d()
-            self.menu_2dgpu()
+                    if curzones is not None:
+                        self.active_cs.link_external_zones(curzones)
+
+                    zonename = myproject[(curgroup, 'sortzone')]
+                    vecname  = myproject[(curgroup, 'sortname')]
+                    downfirst = myproject[(curgroup, 'downfirst')]
 
-        if 'palette' in myproject.myparams.keys():
-            self.project_pal = {}
-            for curid, curname in zip(myproject.myparams['palette'].keys(), myproject.myparams['palette'].values()):
-                if exists(curname[key_Param.VALUE]):
-                    mypal = wolfpalette(None, '')
-                    mypal.readfile(curname[key_Param.VALUE])
-                    mypal.automatic = False
+                    downfirst = False
+                    if downfirst == 1 or str(downfirst).lower() == 'true':
+                        downfirst = True
 
-                    self.project_pal[curid] = mypal
+                    if zonename != '' and vecname != '':
+                        curvec = curzones[(zonename, vecname)]
+                        if curvec is not None:
+                            try:
+                                self.active_cs.sort_along(curvec.asshapely_ls(), curvec.myname, downfirst)
+                            except Exception as e:
+                                logging.error(_('Error in cross_sections_link sorting : ')+ str(e))
+                        else:
+                            logging.warning(_('Bad id for sorting vector in project file - cross_sections_link'))
                 else:
-                    logging.info(_('Bad parameter in project file - palette : ')+ curname[key_Param.VALUE])
+                    logging.warning(_('Bad parameter in project file - cross_sections_link'))
+            else:
+                logging.warning(_('No active cross section to link !'))
 
-        if 'palette-array' in myproject.myparams.keys():
-            curarray: WolfArray
-            if self.project_pal is not None:
-                for curid, curname in zip(myproject.myparams['palette-array'].keys(),
-                                        myproject.myparams['palette-array'].values()):
-                    if curname[key_Param.VALUE] in self.project_pal.keys():
-                        curarray = self.getobj_from_id(curid)
-                        if curarray is not None:
-                            mypal:wolfpalette
-                            mypal = self.project_pal[curname[key_Param.VALUE]]
-                            curarray.mypal = mypal
-                            if mypal.automatic:
-                                curarray.myops.palauto.SetValue(1)
+        curgroup = PROJECT_LINK_VEC_ARRAY
+        # Useful to mask data outside of the linked contour
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                for curval in myproject.get_group(curgroup).keys():
+
+                    id_array = real_ids[(draw_type.ARRAYS, curval[key_Param.NAME])]
+                    id_zones = real_ids[(draw_type.VECTORS, curval[key_Param.VALUE])]
+
+                    locarray:WolfArray
+                    locvec:Zones
+
+                    locarray = self.get_obj_from_id(id_array, draw_type.ARRAYS)
+                    if locarray is None:
+                        locarray = self.get_obj_from_id(id_array, draw_type.RES2D)
+
+                    locvec   = self.get_obj_from_id(id_zones, draw_type.VECTORS)
+
+                    if locvec is not None and locarray is not None:
+                        try:
+                            if locvec.nbzones == 1:
+                                if locvec.myzones[0].nbvectors == 1:
+                                    locarray.linkedvec = locvec.myzones[0].myvectors[0]
+                                else:
+                                    logging.warning(_('In vec-array association, You must have only 1 zone and 1 polyline !'))
                             else:
-                                curarray.myops.palauto.SetValue(0)
-                            curarray.updatepalette(0)
-                            curarray.delete_lists()
-                        else:
-                            logging.warning(_('Bad parameter in project file - palette-array : ')+ curid)
+                                logging.warning(_('In vec-array association, You must have only 1 zone and 1 polyline !'))
 
-        if 'cross_sections_link' in myproject.myparams.keys():
-            if 'linkzones' in myproject.myparams['cross_sections_link'].keys():
-                idx = myproject.myparams['cross_sections_link']['linkzones'][key_Param.VALUE]
+                        except Exception as e:
+                            logging.error(_('Error in vector_array_link : ')+ str(e))
+                    else:
+                        logging.warning(_('Bad vec-array association in project file !'))
+            else:
+                logging.warning(_('Bad parameter in project file - vector_array_link'))
 
-                for curzones in self.iterator_over_objects(draw_type.VECTORS):
-                    curzones: Zones
-                    if curzones.idx == idx:
-                        self.active_cs.link_external_zones(curzones)
+    def save_project(self, fn, absolute:bool = True):
+        """ Save project file """
 
-                zonename = ''
-                vecname = ''
-
-                if 'sortzone' in myproject.myparams['cross_sections_link'].keys():
-                    zonename = myproject.myparams['cross_sections_link']['sortzone'][key_Param.VALUE]
-                if 'sortname' in myproject.myparams['cross_sections_link'].keys():
-                    vecname = myproject.myparams['cross_sections_link']['sortname'][key_Param.VALUE]
-
-                if zonename != '' and vecname != '':
-                    names = [cur.myname for cur in curzones.myzones]
-                    idx = names.index(zonename)
-                    curzone = curzones.myzones[idx]
-                    names = [cur.myname for cur in curzone.myvectors]
-                    idx = names.index(vecname)
-                    curvec = curzone.myvectors[idx]
-
-                    if curvec is not None:
-                        curvec: vector
-                        self.active_cs.sort_along(curvec.asshapely_ls(), curvec.myname, False)
-
-        if 'vector_array_link' in myproject.myparams.keys():
-            for curid, curname in zip(myproject.myparams['vector_array_link'].keys(), myproject.myparams['vector_array_link'].values()):
-
-                locvec = None
-                locarray = None
-                for curvec in self.myvectors:
-                    if curvec.idx == curname[key_Param.VALUE].lower():
-                        locvec=curvec
-                        break
+        dirproj = Path(fn).parent
 
-                for curarray in self.myarrays:
-                    if curarray.idx == curid.lower():
-                        locarray=curarray
-                        break
+        def new_path(drawtype:draw_type, id:str) -> str:
+            logging.info(_('Empty path but I need a path !'))
 
-                if locvec is not None and locarray is not None:
+            path = ''
 
-                    locarray.linkedvec = locvec.myzones[0].myvectors[0]
+            ext = 'All files (*.*)|*.*'
+            if drawtype == draw_type.ARRAYS:
+                ext += '|Binary files (*.bin)|*.bin|Tiff files (*.tif)|*.tif|Numpy files (*.npy)|*.npy'
+            elif drawtype == draw_type.VECTORS:
+                ext += '|VecZ files (*.vecz)|*.vecz|Vec files (*.vec)|*.vec'
+            elif drawtype == draw_type.CLOUD:
+                ext += '|Cloud files (*.xyz)|*.xyz'
 
-                else:
+            dlg = wx.FileDialog(None, _('Choose a filename for ') + id, str(dirproj), '', ext, wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
+            ret = dlg.ShowModal()
 
-                    logging.warning(_('Bad vec-array association in project file !'))
-                    logging.warning(curid)
-                    logging.warning(curname[key_Param.VALUE])
+            if ret == wx.ID_OK:
+                path = Path(dlg.GetPath())
 
-    def save_project(self, fn):
-        myproject = Wolf_Param(None, toShow=False)
+            return path
+
+        def sanit_path(path:Path, absolute:bool, drawtype:draw_type) -> str:
+
+            path = Path(path)
+
+            if not path.exists():
+                logging.info(_('Path does not exist : ')+ str(path))
+
+            if absolute:
+                return str(path)
+            else:
+                try:
+                    return os.path.relpath(path, dirproj)
+                except:
+                    logging.error(_('Error in relative path : ')+ str(path) + " - " + str(dirproj))
+                    logging.info(_('Returning absolute path instead !'))
+                    return str(path.absolute())
+
+        myproject = Wolf_Param(None, toShow=False, to_read=False, filename=fn, init_GUI=False)
 
-        mykeys = ['cross_sections', 'vector', 'array', 'wolf2d']
-        for curkey in mykeys:
-            myproject[curkey] = {}
-        """
-        # myproject.myparams['which']={}
-        # myproject.myparams['which']['action']={}
-        # myproject.myparams['which']['action'][key_Param.VALUE]
-
-        # mycs = self.active_cs
-        # if mycs is not None:
-        #     myproject.myparams['cross_sections']={}
-        #     myproject.myparams['cross_sections']['mycs']={}
-        #     myproject.myparams['cross_sections']['mycs'][key_Param.VALUE]=mycs.filename
-
-        #     myproject.myparams['vector']={}
-        #     myproject.myparams['vector']['river']={}
-        ##     myproject.myparams['vector']['river'][key_Param.VALUE]=self.added[draw_type.VECTORS.value][0].filename
-
-        # if 'array' in myproject.myparams.key():
-        #     for curid,curname in zip(myproject.myparams['array'].keys(),myproject.myparams['array'].values()):
-        #         curarray=WolfArray(curname[key_Param.VALUE])
-        #         self.add_object('array',newobj=curarray,id=curid)
-        """
         # matrices
         try:
+            curgroup = PROJECT_ARRAY
             for curel in self.iterator_over_objects(draw_type.ARRAYS):
-                myproject['array'][curel.idx] = {}
-                myproject['array'][curel.idx][key_Param.VALUE] = curel.filename
+                curel:WolfArray
+                if curel.filename == '':
+                    newpath =  new_path(draw_type.ARRAYS, curel.idx)
+                    if newpath == '':
+                        logging.warning(_('No path for array : ')+ curel.idx  + _(' - Ignoring it !'))
+                        continue
+                    curel.write_all(newpath)
 
+                curpath = sanit_path(curel.filename, absolute, draw_type.ARRAYS)
+
+                myproject.add_param(curgroup, curel.idx, curpath)
         except:
-            pass
+            logging.error(_('Error in saving arrays'))
 
         # résultats 2D
         try:
+            curgroup = PROJECT_WOLF2D
             for curel in self.iterator_over_objects(draw_type.RES2D):
-                myproject['wolf2d'][curel.idx] = {}
-                myproject['wolf2d'][curel.idx][key_Param.VALUE] = curel.filename
+                if type(curel) == Wolfresults_2D:
+                    myproject.add_param(curgroup, curel.idx, sanit_path(curel.filename, absolute, draw_type.RES2D))
 
+            curgroup = PROJECT_GPU2D
+            for curel in self.iterator_over_objects(draw_type.RES2D):
+                if type(curel) == wolfres2DGPU:
+                    myproject.add_param(curgroup, curel.idx, sanit_path(curel.filename, absolute, draw_type.RES2D))
         except:
-            pass
+            logging.error(_('Error in saving 2D results'))
 
         # vecteurs
         try:
+            curgroup = PROJECT_VECTOR
             for curel in self.iterator_over_objects(draw_type.VECTORS):
-                myproject['vector'][curel.idx] = {}
-                myproject['vector'][curel.idx][key_Param.VALUE] = curel.filename
+                if isinstance(curel, crosssections):
+                    continue
+
+                curel:Zones
+                if curel.filename == '':
+                    newpath =  new_path(draw_type.VECTORS, curel.idx)
+                    if newpath == '':
+                        logging.warning(_('No path for vector : ')+ curel.idx  + _(' - Ignoring it !'))
+                        continue
+                    curel.saveas(newpath)
 
+                myproject.add_param(curgroup, curel.idx, sanit_path(curel.filename, absolute, draw_type.VECTORS))
         except:
-            pass
+            logging.error(_('Error in saving vectors'))
+
+        # cross sections
+        try:
+            curgroup = PROJECT_CS
+            for curel in self.iterator_over_objects(draw_type.VECTORS):
+                if isinstance(curel, crosssections):
+                    myproject.add_param(curgroup, curel.idx, sanit_path(curel.filename, absolute, draw_type.VECTORS))
+        except:
+            logging.error(_('Error in saving cross sections'))
+
+        # nuages de points
+        try:
+            curgroup = PROJECT_CLOUD
+            for curel in self.iterator_over_objects(draw_type.CLOUD):
+                myproject.add_param(curgroup, curel.idx, sanit_path(curel.filename, absolute, draw_type.CLOUD))
+        except:
+            logging.error(_('Error in saving clouds'))
+
+        # palettes
+        try:
+            if self.project_pal is not None:
+                curgroup = PROJECT_PALETTE
+                for curel in self.project_pal.keys():
+                    myproject.add_param(curgroup, curel, sanit_path(self.project_pal[curel].filename, absolute, draw_type.OTHER))
+        except:
+            logging.error(_('Error in saving palettes'))
+
+        # tiles
+        try:
+            curgroup = PROJECT_TILES
+            for curel in self.iterator_over_objects(draw_type.TILES):
+                myproject.add_param(curgroup, curel.idx, sanit_path(curel.filename, absolute, draw_type.OTHER))
+                myproject.add_param(curgroup, 'data_dir', sanit_path(curel.linked_data_dir, absolute, draw_type.OTHER))
+                myproject.add_param(curgroup, 'comp_dir', sanit_path(curel.linked_data_dir_comp, absolute, draw_type.OTHER))
+        except:
+            logging.error(_('Error in saving tiles'))
+
+        # LAZ GRID
+        try:
+            if self.mylazgrid is not None:
+                curgroup = PROJECT_LAZ
+                myproject.add_param(curgroup, 'data_dir', sanit_path(self.mylazgrid.dir, absolute, draw_type.OTHER))
+                myproject.add_param(curgroup, 'classification', self.mylazgrid.colors.class_name)
+        except:
+            logging.error(_('Error in saving laz grid'))
+
+        myproject.Save(fn)
+
+
+    def help_project(self):
+        """ Help for project file.
+
+        Define which elements can be saved in a project file.
+
+        """
+
+        logging.info(_('Project file help'))
+
+        logging.info(_('Project file is a file containing some information about the current project.'))
+
+        logging.info(_('It can contain the following informations :'))
+
+        logging.info(_(' - Arrays :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
+
+        logging.info(_(' - Cross sections :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
+
+        logging.info(_(' - Vectors :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
+
+        logging.info(_(' - Clouds :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
+
+        logging.info(_(' - Tiles :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
+
+        logging.info(_(' - LAZ grid :'))
+        logging.info(_('   - data_dir : directory containing the NUMPY grid'))
+        logging.info(_('   - classification : classification of the laz files'))
+
+        logging.info(_(' - Palettes :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
+
+        logging.info(_(' - Wolf2D CPU results :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
+
+        logging.info(_(' - Wolf2D GPU results :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
+
+        logging.info(_(' - Palette-Array links :'))
+        logging.info(_('   - id of the array'))
+        logging.info(_('   - id of the palette'))
+
+        logging.info(_(' - Vector-Array links :'))
+        logging.info(_('   - id of the array'))
+        logging.info(_('   - id of the vector (containing only 1 zone and 1 vector)'))
+
+        logging.info(_(' - Cross section links :'))
+        logging.info(_('   - id of the cross section'))
+        logging.info(_('   - id of the vector to sort along'))
+        logging.info(_('   - id of the zone to link'))
+        logging.info(_('   - downfirst : True or False'))
+
+        logging.info('')
+        logging.info(_('A tabulation is used to separate the value and the key.'))
+        logging.info('')
+
+        logging.info(_('Exemple :'))
+
+        logging.info('')
+
+        logging.info('array:')
+        logging.info('myid1\tmyfilename_array1')
+        logging.info('myid2\tmy../filename_array2')
+        logging.info('vector:')
+        logging.info('myvec1\tmy../../filename_vecz1')
+        logging.info('myvec2\tmyfilename_vecz2')
+        logging.info('laz_grid:')
+        logging.info('data_dir\tD:\\MODREC-Vesdre\\LAZ_Vesdre\\2023\\grids_flt32')
+        logging.info('classification\tSPW-Geofit 2023')
 
     def plot_laz_around_active_vec(self):
+        """ Plot laz data around active vector """
+
         if self.active_vector is None:
+            logging.warning(_('Please activate a vector'))
             return
 
         if self.mylazgrid is None:
+            logging.warning(_('No laz grid'))
             return
 
         dlg = wx.NumberEntryDialog(None, _('Enter the size of the window around the active vector [cm]'), _('Window size'),_('Window size'), 500, 0, 2000)
@@ -5145,31 +5529,73 @@ class WolfMapViewer(wx.Frame):
             s,z = copy_vec.get_sz()
             notmasked = np.where(z != -99999.)
 
-            fig.plot(s,z, c='black', linewidth=2.0)
-
-            # ax.plot(s[notmasked], z[notmasked], c='black', linewidth=2.0)
+            fig.plot(s[notmasked],z[notmasked], c='black', linewidth=2.0)
 
-        # fig.show()
 
     def clip_laz_gridded(self):
         """ 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 = Base_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 = Base_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'))
+        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 filter_active_laz(self):
+        """ Filter active laz data """
+
+        if self.active_laz is None:
+            logging.warning(_('No laz data'))
+            return
+
+        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(_('Clip LAZ grid on current zoom {}-{}  {}-{}').format(curbounds[0][0],curbounds[0][1],curbounds[1][0],curbounds[1][1]))
+                logging.info(_('Filter done - Nb points : {}').format(self.active_laz.num_points))
+            else:
+                logging.info(_('Filter cancelled'))
 
-    def decimate_data(self, factor:int = 10):
+    def decimate_laz_data(self, factor:int = 10):
         """ Decimate data """
 
-        if self.mylazdata is None:
+        if self.active_laz is None:
+            logging.warning(_('No laz data'))
             return
 
-        self.mylazdata = self.mylazdata[::factor]
+        self.active_laz.decimate(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
@@ -5178,6 +5604,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:
@@ -5211,19 +5638,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
 
@@ -5246,6 +5673,7 @@ class WolfMapViewer(wx.Frame):
         """
 
         if self.mylazgrid is None:
+            logging.info(_('No laz grid - Aborting !'))
             return
 
         if array is None:
@@ -5309,16 +5737,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():
@@ -5329,7 +5757,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]
@@ -5396,6 +5824,7 @@ class WolfMapViewer(wx.Frame):
         """
 
         if self.mylazgrid is None:
+            logging.info(_('No laz grid - Aborting !'))
             return
 
         if array is None:
@@ -5431,15 +5860,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():
@@ -5450,7 +5879,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]
@@ -5507,28 +5936,50 @@ 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 = read_laz(fn)
-        # self.mylazdata_colors = Classification_LAZ()
-        # self.mylazdata_colors.init_2023()
+        self.mylazdata.append(Base_LAZ_Data())
+        self.active_laz = self.mylazdata[-1]
+        self.active_laz.from_file(fn)
+
+        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):
+    def init_laz_from_gridinfos(self, dirlaz:str = None, classification:Literal['SPW-Geofit 2023', 'SPW 2013-2014'] = 'SPW-Geofit 2023'):
 
         if dirlaz is None:
             dlg = wx.DirDialog(None, _('Choose directory where LAZ data/gridinfo are stored'))
@@ -5540,19 +5991,18 @@ class WolfMapViewer(wx.Frame):
 
         self.mylazgrid = xyz_laz_grids(dirlaz)
 
-        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
+        if classification not in ['SPW-Geofit 2023', 'SPW 2013-2014']:
+
+            classification = self._choice_laz_classification()
 
-        if dlg.GetStringSelection() == 'SPW 2013-2014':
+        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()
 
-        dlg.Destroy()
-
         if self.linked:
             if len(self.linkedList) > 0:
                 for curframe in self.linkedList:
@@ -5758,15 +6208,15 @@ class WolfMapViewer(wx.Frame):
     def _select_laz_source(self):
         """ Select laz source """
 
-        if self.mylazdata is None and self.mylazgrid is None:
+        if self.active_laz is None and self.mylazgrid is None:
             logging.warning(_('No LAZ data loaded !'))
             return None
-        elif self.mylazdata is None:
+        elif self.active_laz is None:
             laz_source = self.mylazgrid
         elif self.mylazgrid is None:
-            laz_source = self.mylazdata
+            laz_source = self.active_laz
         else:
-            choices = [_('From current loaded data'), _('From GridInfos')]
+            choices = [_('From active LAZ data'), _('From newly extracted data')]
             dlg = wx.SingleChoiceDialog(None, _("Pick a data source"), "Choices", choices)
             ret = dlg.ShowModal()
             if ret == wx.ID_CANCEL:
@@ -5778,12 +6228,32 @@ class WolfMapViewer(wx.Frame):
             dlg.Destroy()
 
             if idx == 0:
-                laz_source = self.mylazdata
+                laz_source = self.active_laz
             else:
                 laz_source = self.mylazgrid
 
         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(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
@@ -5806,12 +6276,14 @@ class WolfMapViewer(wx.Frame):
 
         itemlabel = item.ItemLabel
 
-        autoscale = True
+        autoscale = False
 
         if id == wx.ID_OPEN:
+            autoscale = True
             filterProject = "proj (*.proj)|*.proj|param (*.param)|*.param|all (*.*)|*.*"
             file = wx.FileDialog(self, "Choose file", wildcard=filterProject)
-            if file.ShowModal() == wx.ID_CANCEL:
+            ret = file.ShowModal()
+            if ret == wx.ID_CANCEL:
                 file.Destroy()
                 return
             else:
@@ -5827,30 +6299,28 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel == _('Shortcuts'):
             # show shortcuts in log
             self.print_shortcuts(True)
-            autoscale = False
+
+        elif itemlabel == _('Project .proj'):
+            # show shortcuts in log
+            self.help_project()
 
         elif itemlabel == _('Show logs/informations'):
             self.check_logging()
-            autoscale = False
 
         elif itemlabel == _('Show values'):
             self.check_tooltip()
-            autoscale = False
 
         elif itemlabel == _('About'):
             #print About Frame
             self.print_About()
-            autoscale = False
 
         elif itemlabel == _('Check for updates'):
             # check for new version
 
             self.check_for_updates()
-            autoscale = False
 
         elif itemlabel == _("Plot integrated Q along active vector..."):
             """ Integrate Q along active vector """
-            autoscale = False
 
             if self.active_vector is None:
                 logging.warning(_('No active vector !'))
@@ -5868,7 +6338,6 @@ class WolfMapViewer(wx.Frame):
 
         elif itemlabel == _("Plot integrated Q along active zone..."):
             """ Integrate Q along active zone """
-            autoscale = False
 
             if self.active_zone is None:
                 logging.warning(_('No active zone !'))
@@ -5881,7 +6350,6 @@ class WolfMapViewer(wx.Frame):
             self.active_res2d.plot_q(self.active_zone.myvectors, ['border'] * self.active_zone.nbvectors, toshow=True)
 
         elif itemlabel == _("Export integrated Q along active vector..."):
-            autoscale = False
 
             if self.active_vector is None:
                 logging.warning(_('No active vector !'))
@@ -5936,7 +6404,6 @@ class WolfMapViewer(wx.Frame):
 
 
         elif itemlabel == _("Export integrated Q along all vectors in active zone..."):
-            autoscale = False
 
             if self.active_zone is None:
                 logging.warning(_('No active zone !'))
@@ -5991,7 +6458,6 @@ class WolfMapViewer(wx.Frame):
 
 
         elif itemlabel == _("Plot stats unknown (selected nodes)..."):
-            autoscale = False
 
             if self.active_res2d is None:
                 logging.warning(_('No active 2D result !'))
@@ -6025,7 +6491,6 @@ class WolfMapViewer(wx.Frame):
                 fig.show()
 
         elif itemlabel == _("Plot stats unknown (inside active vector)..."):
-            autoscale = False
 
             if self.active_res2d is None:
                 logging.warning(_('No active 2D result !'))
@@ -6055,7 +6520,6 @@ class WolfMapViewer(wx.Frame):
             fig, ax = self.active_res2d.plot_h(self.active_vector, unknown, toshow=True)
 
         elif itemlabel == _("Plot stats unknown (inside active zone)..."):
-            autoscale = False
 
             if self.active_res2d is None:
                 logging.warning(_('No active 2D result !'))
@@ -6092,7 +6556,6 @@ class WolfMapViewer(wx.Frame):
 
         elif itemlabel == _("Plot active vector..."):
             """ Plot data along active vector """
-            autoscale = False
 
             if self.active_vector is None:
                 logging.warning(_('No active vector !'))
@@ -6168,36 +6631,24 @@ class WolfMapViewer(wx.Frame):
                 fig.canvas.flush_events()
 
         elif itemlabel == _("Compute and apply unique colormap on all..."):
-            autoscale = False
-
             self.uniquecolormap()
 
         elif itemlabel == _("Load and apply unique colormap on all..."):
-            autoscale = False
-
             self.uniquecolormap(True)
 
         elif itemlabel == _("Force uniform in parts on all..."):
-            autoscale = False
             self.uniforminparts_all(True)
 
         elif itemlabel == _("Force linear interpolation on all..."):
-            autoscale = False
             self.uniforminparts_all(False)
 
         elif itemlabel == _("Load and apply mask (nap)..."):
-            autoscale = False
-
             self.loadnap_and_apply()
 
         elif itemlabel == _("Filter inundation arrays..."):
-            autoscale = False
-
             self.filter_inundation()
 
         elif itemlabel == _("Plot active polygons..."):
-            autoscale = False
-
             if self.active_zone is None:
                 logging.warning(_('No active zone ! -- please select a zone containing polygons !'))
                 return
@@ -6273,7 +6724,7 @@ class WolfMapViewer(wx.Frame):
             fig.show()
 
         elif itemlabel == _("Manage banks..."):
-            autoscale = False
+
             if self.active_vector is None:
                 msg = _('Active vector is None\nPlease activate the one desired')
                 msg += _('\n')
@@ -6284,13 +6735,11 @@ class WolfMapViewer(wx.Frame):
             self.managebanks()
 
         elif itemlabel == _("Create banks from vertices..."):
-            autoscale = False
 
             self.active_cs.create_zone_from_banksbed()
             self.active_cs.linked_zones.showstructure()
 
         elif itemlabel == _("Link cross sections to active zones"):
-            autoscale = False
 
             if self.active_cs is None:
                 msg = _('Active cross sections is None\nPlease activate the one desired')
@@ -6309,7 +6758,6 @@ class WolfMapViewer(wx.Frame):
             self.active_cs.link_external_zones(self.active_zones)
 
         elif itemlabel == _("Rename cross sections..."):
-            autoscale = False
 
             dlg = wx.TextEntryDialog(None, _('Which starting point?'))
             ret = dlg.ShowModal()
@@ -6325,15 +6773,12 @@ class WolfMapViewer(wx.Frame):
         #     self.import_3dfaces()
 
         elif itemlabel == _("Interpolate on active triangulation..."):
-            autoscale = False
             self.interpolate_triangulation()
 
         elif itemlabel==_("Compare cloud to array..."):
-            autoscale = False
             self.compare_cloud2array()
 
         elif itemlabel==_("Split cloud..."):
-            autoscale = False
 
             if self.active_cloud is None:
                 logging.warning(_('No active cloud !'))
@@ -6346,26 +6791,21 @@ class WolfMapViewer(wx.Frame):
             self.split_cloud_by_vector()
 
         elif itemlabel==_("Compare triangles to array..."):
-            autoscale = False
             self.compare_tri2array()
 
         elif itemlabel ==  _("Move triangles..."):
-            autoscale = False
             self.move_triangles()
 
         elif itemlabel == _("Rotate triangles..."):
-            autoscale = False
             self.rotate_triangles()
 
         elif itemlabel ==  _("Create contour from checked arrays..."):
-            autoscale = False
 
             # Create contour from checked arrays and add it to the list of objects
             newzones = self.create_Zones_from_arrays(self.get_list_objects(draw_type.ARRAYS, checked_state=True))
             self.add_object('vector', newobj=newzones, ToCheck=True, id='Contours from arrays')
 
         elif itemlabel == _("Calculator..."):
-            autoscale = False
 
             if self.calculator is None:
                 self.calculator = Calculator(mapviewer = self)
@@ -6373,12 +6813,10 @@ class WolfMapViewer(wx.Frame):
                 self.calculator.Show()
 
         elif itemlabel == _('Image digitizer...'):
-            autoscale = False
 
             new_digitizer = Digitizer()
 
         elif itemlabel == _("Memory views..."):
-            autoscale = False
 
             if self.memory_views is None:
                 self.memory_views = Memory_Views()
@@ -6390,7 +6828,6 @@ class WolfMapViewer(wx.Frame):
                 self._memory_views_gui.Show()
 
         elif itemlabel == _("Create bridge and export gltf..."):
-            autoscale = False
 
             if self.active_cs is None:
                 msg = _('Active cross sections is None\nPlease activate the one desired')
@@ -6402,7 +6839,6 @@ class WolfMapViewer(wx.Frame):
             self.start_action('bridge gltf', _('Create bridge and export gltf...'))
 
         elif itemlabel == _("Export cross sections to gltf..."):
-            autoscale = False
 
             if self.active_cs is None:
                 msg = _('Active cross sections is None\nPlease activate the one desired')
@@ -6432,21 +6868,20 @@ class WolfMapViewer(wx.Frame):
             self.active_cs.export_gltf(zmin, fn)
 
         elif itemlabel == _("New cloud Viewer..."):
-            autoscale = False
+
             if self.myinterp is not None:
                 self.myinterp.viewer_interpolator()
 
         elif itemlabel == _("Interpolate on active array..."):
-            autoscale = False
+
             if self.myinterp is not None:
                 self.interpolate_cs()
 
         elif itemlabel == _("Interpolate active cloud on active array..."):
-            autoscale = False
             self.interpolate_cloud()
 
-        elif itemlabel == _('Save project'):
-            autoscale = False
+        elif itemlabel == _('Save project as...'):
+
             filterProject = "proj (*.proj)|*.proj|param (*.param)|*.param|all (*.*)|*.*"
             file = wx.FileDialog(self, "Name your file", wildcard=filterProject, style=wx.FD_SAVE)
             if file.ShowModal() == wx.ID_CANCEL:
@@ -6457,23 +6892,28 @@ class WolfMapViewer(wx.Frame):
                 filename = file.GetPath()
                 file.Destroy()
 
-            self.save_project(filename)
+            abspath = True
+            dlg = wx.MessageDialog(None, _('Do you want to save the paths in absolute mode ?'), _('Relative paths'), style=wx.YES_NO)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_NO:
+                abspath = False
+
+            self.save_project(filename, absolute= abspath)
 
-        elif itemlabel == _('Initialize from npz'):
-            autoscale=False
-            self.init_laz_from_numpy()
+        elif itemlabel == _('Initialize from laz, las or npz'):
+            self.init_laz_from_lazlasnpz()
 
-        elif itemlabel == _('Initialize from GridInfos'):
-            autoscale=False
+        elif itemlabel == _('Initialize from directory'):
             self.init_laz_from_gridinfos()
 
         elif itemlabel == _('Create cloud points from bridges'):
-            autoscale=False
-            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])
@@ -6487,12 +6927,13 @@ class WolfMapViewer(wx.Frame):
                 self.add_object('cloud', newobj=mycloud, ToCheck=True, id='Bridges')
 
         elif itemlabel == _('Create cloud points from buildings'):
-            autoscale=False
-            if self.mylazdata is None:
-                self.init_laz_from_numpy()
 
-            mybuildings = self.mylazdata[np.where(self.mylazdata[:, 3] == 1)]
+            if self.active_laz is None:
+                self.init_laz_from_lazlasnpz()
+
+            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])
@@ -6504,25 +6945,15 @@ class WolfMapViewer(wx.Frame):
             else:
                 self.add_object('cloud', newobj=mycloud, ToCheck=True, id='Buildings')
 
-        elif itemlabel == _('Create LAZ viewer'):
+        elif itemlabel == _('Create cloud points from specified classes'):
+            pass
 
-            autoscale = False
+        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 !'))
@@ -6530,21 +6961,57 @@ 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 decimate?').format(self.active_laz.num_points),
+                                        _('Decaimate factor'), _('Decimation'), 0, 0, 100)
+
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+
+            decimate_fact = dlg.GetValue()
+            dlg.Destroy()
+
+            if decimate_fact > 0:
+                self.active_laz.decimate(decimate_fact)
+                logging.info(_('New count : {}').format(self.active_laz.num_points))
 
         elif itemlabel == _('Clip LAZ grid on current zoom'):
+
             if self.mylazgrid is None:
                 logging.warning(_('No gridded LAZ data loaded !'))
                 return
-            autoscale=False
+
             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?'),
@@ -6560,9 +7027,10 @@ class WolfMapViewer(wx.Frame):
                 dlg.Destroy()
 
                 if decimate_fact > 0:
-                    self.decimate_data(decimate_fact)
+                    self.decimate_laz_data(decimate_fact)
 
         elif itemlabel == _('Fill active array from LAZ data'):
+
             if self.mylazgrid is None:
                 logging.warning('')
                 return
@@ -6570,10 +7038,10 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No active array -- select an array first and retry!'))
                 return
 
-            autoscale = False
             self.fill_active_array_from_laz(self.active_array)
 
         elif itemlabel == _('Count LAZ data in cells'):
+
             if self.mylazgrid is None:
                 logging.warning('')
                 return
@@ -6581,7 +7049,6 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No active array -- select an array first and retry!'))
                 return
 
-            autoscale = False
             self.count_active_array_from_laz(self.active_array)
 
         elif itemlabel == _('Select cells in array from LAZ data'):
@@ -6592,15 +7059,13 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No active array -- select an array first and retry!'))
                 return
 
-            autoscale = False
             self.select_active_array_from_laz(self.active_array)
 
         elif itemlabel == _('Plot LAZ around active vector'):
-            autoscale = False
             self.plot_laz_around_active_vec()
 
         elif itemlabel == _('Plot LAZ around temporary vector'):
-            autoscale = False
+
             self.active_vector = vector()
             self.active_vector.add_vertex(wolfvertex(0.,0.))
             self.mimicme()
@@ -6610,11 +7075,10 @@ class WolfMapViewer(wx.Frame):
         elif itemlabel == _('Change colors - Classification'):
 
             if self.mylazgrid is not None:
-                autoscale = False
                 self.mylazgrid.colors.interactive_update_colors()
 
         elif itemlabel == _('Multiviewer'):
-            autoscale = False
+
             dlg = wx.NumberEntryDialog(self, _("Additional viewers"), _("How many?"), _("How many additional viewers?"),1, 0, 5)
             ret = dlg.ShowModal()
 
@@ -6658,8 +7122,6 @@ class WolfMapViewer(wx.Frame):
                     self.active_viewer3d.add_array(curarray.idx, curarray._array3d)
                     self.active_viewer3d.autoscale()
 
-            pass
-
         elif itemlabel == _('Create/Open multiblock model'):
 
             self.create_2D_MB_model()
@@ -6678,6 +7140,8 @@ class WolfMapViewer(wx.Frame):
 
         elif itemlabel == _('Set comparison'):
 
+            autoscale = True
+
             # Comparaison de deux résultats ou de deux matrices
 
             self.compare_results = Compare_Arrays_Results(self, share_cmap_array= True, share_cmap_diff= True)
@@ -6694,6 +7158,7 @@ class WolfMapViewer(wx.Frame):
             self.compare_results.bake()
 
         elif id == wx.ID_EXIT:
+
             dlg = wx.MessageDialog(None,_('Do you really want to quit?'), style = wx.YES_NO|wx.NO_DEFAULT)
             ret=dlg.ShowModal()
             if ret == wx.ID_YES:
@@ -6779,6 +7244,7 @@ class WolfMapViewer(wx.Frame):
                 self.add_object(which='array_lidar_second', ToCheck=True)
 
         elif id == wx.ID_FILE5:
+
             def addscandir(mydir):
                 for entry in scandir(mydir):
                     if entry.is_dir():
@@ -6801,7 +7267,7 @@ class WolfMapViewer(wx.Frame):
                                                 ToCheck=True,
                                                 id=join(mydir, entry.name))
 
-                        elif entry.name.endswith('.bin'):
+                        elif entry.name.endswith(('.bin', '.tif', '.npy')):
                             self.add_object(which='array',
                                             filename=join(mydir, entry.name),
                                             ToCheck=True,
@@ -6825,26 +7291,22 @@ class WolfMapViewer(wx.Frame):
             self.add_object('array', newobj=newarray)
 
         elif itemlabel == _('Create view...'):
-            autoscale = False
 
             # Création d'une nouvelle vue
             newview = WolfViews(mapviewer=self)
             self.add_object('views', newobj=newview)
 
         elif itemlabel==_('Create Wolf2D manager ...'):
-            autoscale = False
 
             from .mesh2d.config_manager import config_manager_2D
             newmanager = config_manager_2D(mapviewer=self)
 
         elif itemlabel==_('Create scenarios manager ...'):
-            autoscale = False
 
             from .scenario.config_manager import Config_Manager_2D_GPU
             newmanager = Config_Manager_2D_GPU(mapviewer=self, create_ui_if_wx=True)
 
         elif itemlabel == _('Create acceptability manager...'):
-            autoscale = False
 
             from .acceptability.acceptability_gui import AcceptabilityGui
             newmanager = AcceptabilityGui()
@@ -6852,7 +7314,6 @@ class WolfMapViewer(wx.Frame):
             newmanager.Show()
 
         elif itemlabel==_('Create BC manager Wolf2D...'):
-            autoscale = False
 
             if self.active_array is not None:
 
@@ -6885,27 +7346,26 @@ class WolfMapViewer(wx.Frame):
                 self.active_bc = self.mybc[-1]
 
         elif itemlabel == _('Create Wolf1D...'):
-            autoscale = False
+
             self.frame_create1Dfrom2D = GuiNotebook1D(mapviewer= self)
             logging.info(_(f'New window available - Wolf1D.'))
 
         elif id == wx.ID_FILE7:
-            autoscale = False
+
             # Création de nouveaux vecteurs
             newzones = Zones(parent=self)
             self.add_object('vector', newobj=newzones)
+
         elif id == wx.ID_FILE8:
-            autoscale = False
             # Création d'un nouveau nuage de point
             newcloud = cloud_vertices()
             self.add_object('cloud', newobj=newcloud)
+
         elif id in self.tools.keys():
             # gestion des actions
             self.ManageActions(id)
-            autoscale = False
 
         elif id == wx.ID_SAVE:
-            autoscale = False
 
             for obj in self.iterator_over_objects(draw_type.ARRAYS):
                 obj: WolfArray
@@ -6924,7 +7384,6 @@ class WolfMapViewer(wx.Frame):
                 obj.saveas()
 
         elif itemlabel == 'Save to image...':
-            autoscale = False
 
             fn, ds = self.save_canvasogl(mpl=True)
 
@@ -6932,11 +7391,11 @@ class WolfMapViewer(wx.Frame):
             self.assembly_images(all_images, mode= self.assembly_mode)
 
         elif itemlabel == _('Copy image...'):
-            autoscale = False
+
             self.copy_canvasogl()
 
         elif itemlabel == _('Export...'):
-            autoscale = False
+
             curarray: WolfArray
             curvec: vector
 
@@ -6984,7 +7443,7 @@ class WolfMapViewer(wx.Frame):
                 del wait
 
         elif itemlabel == _('Import...'):
-            autoscale = False
+
             curarray: WolfArray
 
             msg = ''
@@ -7038,7 +7497,7 @@ class WolfMapViewer(wx.Frame):
                 del wait
 
         elif itemlabel == _('Compare...'):
-            autoscale = False
+
             msg = ''
             if self.active_array is None:
                 msg += _('Active array is None\n')
@@ -7055,7 +7514,6 @@ class WolfMapViewer(wx.Frame):
             self.update_blender_sculpting()
 
         elif itemlabel == _('Update...'):
-            autoscale = False
 
             msg = ''
             if self.active_array is None:
@@ -7071,7 +7529,7 @@ class WolfMapViewer(wx.Frame):
             self.update_blender_sculpting()
 
         elif id == wx.ID_SAVEAS:
-            autoscale = False
+
             for obj in self.iterator_over_objects(draw_type.ARRAYS):
                 obj: WolfArray
 
@@ -7095,11 +7553,6 @@ class WolfMapViewer(wx.Frame):
                     if ret == wx.ID_OK:
                         obj.saveas(fdlg.GetPath())
 
-        # elif id == ID_RUN_SIMULATION:
-        #     from ..debug.test_glsim.wolf_gpu import load_sim_to_gpu
-        #     print("Simulation")
-        #     load_sim_to_gpu()
-
         if len(self.myarrays) + len(self.myvectors) + len(self.myclouds) + len(self.mytri) + len(self.myres2D) + len(self.mytiles) + len(self.myimagestiles) + len(self.mypartsystems) == 2 and autoscale:
             # Trouve les bornzs si un seul élément est présent, sinon on conserve l'état du zoom
             self.Autoscale()
@@ -7667,7 +8120,7 @@ class WolfMapViewer(wx.Frame):
                                  'weirs',
                                  'vector',
                                  'tiles', 'tilescomp'
-                                 'cloud',
+                                 'cloud', 'laz',
                                  'triangulation',
                                  'cross_sections',
                                  'other',
@@ -7687,12 +8140,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 (*.*)|*.*"
@@ -7719,6 +8173,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':
@@ -8219,6 +8675,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 = Base_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
@@ -8460,6 +8929,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
@@ -8893,7 +9364,7 @@ class WolfMapViewer(wx.Frame):
         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, Base_LAZ_Data]:
                 myobj.show_properties()
 
             elif isinstance(myobj, cloud_vertices):
@@ -9041,6 +9512,92 @@ 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, Base_LAZ_Data):
+                self.selected_object.associated_color = self._choice_laz_colormap()
+
+        elif _('Edit colormap') in text:
+
+            if isinstance(self.selected_object, Base_LAZ_Data):
+                self.selected_object.interactive_update_colors()
+
+        elif _('Set classification') in text:
+
+            if isinstance(self.selected_object, Base_LAZ_Data):
+                self.selected_object.set_classification(self._choice_laz_classification())
+
+        elif _('All to cloud') in text:
+
+            if isinstance(self.selected_object, Base_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, Base_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 _('Play') in text:
+
+            if isinstance(self.selected_object, Base_LAZ_Data):
+                self.selected_object.play_flight()
+
+        elif _('Record') in text:
+
+            if isinstance(self.selected_object, Base_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, Base_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, Base_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 """
@@ -9827,6 +10384,13 @@ class WolfMapViewer(wx.Frame):
             if ctrl:
                 myobj.show_properties()
 
+        elif type(myobj) == Base_LAZ_Data:
+
+            self.active_laz = myobj
+
+            if ctrl:
+                myobj.show_properties()
+
         elif type(myobj) == Bridge:
             self.active_bridge = myobj
 
@@ -11501,6 +12065,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 """
 
@@ -11551,6 +12119,19 @@ 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(_('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()
@@ -11593,6 +12174,29 @@ 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):
+
+                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'))
+
+                moviemenu = wx.Menu()
+                self.popupmenu.AppendSubMenu(moviemenu, _('Movie'))
+
+                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):