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

wolfhece/PyDraw.py

@@ -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 """
 
@@ -1232,6 +1270,8 @@ class WolfMapViewer(wx.Frame):
         self.linkedList = None
         self.link_params = None
 
+        self.project_pal = None
+
         self.forcemimic = True
         self.currently_readresults = False
 
@@ -1269,8 +1309,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 complete 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'))
@@ -1517,6 +1557,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'))
@@ -4872,258 +4913,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'))
+
+        # LINKS
+        curgroup = PROJECT_PALETTE_ARRAY
+        if myproject.is_in(curgroup):
+            if check_params(myproject, curgroup):
+                curarray: WolfArray
+                if self.project_pal is not None:
 
-                    self.add_object('res2d', newobj=curwolf, id=curid)
+                    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,11 +5517,8 @@ 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 """
@@ -5163,10 +5532,11 @@ class WolfMapViewer(wx.Frame):
 
         logging.info(_('Clip LAZ grid on current zoom {}-{}  {}-{}').format(curbounds[0][0],curbounds[0][1],curbounds[1][0],curbounds[1][1]))
 
-    def decimate_data(self, factor:int = 10):
+    def decimate_laz_data(self, factor:int = 10):
         """ Decimate data """
 
         if self.mylazdata is None:
+            logging.warning(_('No laz data'))
             return
 
         self.mylazdata = self.mylazdata[::factor]
@@ -5528,7 +5898,7 @@ class WolfMapViewer(wx.Frame):
                 for curframe in self.linkedList:
                     curframe.mylazdata = self.mylazdata
 
-    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 +5910,20 @@ 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:
+        if classification not in ['SPW-Geofit 2023', 'SPW 2013-2014']:
+            dlg = wx.SingleChoiceDialog(None, _('Choose the classification'), _('Classification'), ['SPW-Geofit 2023', 'SPW 2013-2014'], wx.CHOICEDLG_STYLE)
+            ret = dlg.ShowModal()
+            if ret != wx.ID_OK:
+                dlg.Destroy()
+                return
+            classification = dlg.GetStringSelection()
             dlg.Destroy()
-            return
 
-        if dlg.GetStringSelection() == 'SPW 2013-2014':
+        if 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:
@@ -5806,12 +6177,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 +6200,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 +6239,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 +6251,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 +6305,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 +6359,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 +6392,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 +6421,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 +6457,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 +6532,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 +6625,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 +6636,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 +6659,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 +6674,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 +6692,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 +6714,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 +6729,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 +6740,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 +6769,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,18 +6793,21 @@ 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 GridInfos'):
-            autoscale=False
             self.init_laz_from_gridinfos()
 
         elif itemlabel == _('Create cloud points from bridges'):
-            autoscale=False
             if self.mylazdata is None:
                 self.init_laz_from_numpy()
 
@@ -6487,7 +6826,7 @@ 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()
 
@@ -6506,8 +6845,6 @@ class WolfMapViewer(wx.Frame):
 
         elif itemlabel == _('Create LAZ viewer'):
 
-            autoscale = False
-
             laz_source = self._select_laz_source()
             if laz_source is None:
                 return
@@ -6535,10 +6872,11 @@ class WolfMapViewer(wx.Frame):
                 self.myviewer = myviewer(laz_source, ass_values[idx]) #, palette_classif = self.mylazdata_colors)
 
         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:
@@ -6560,9 +6898,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 +6909,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 +6920,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 +6930,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 +6946,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 +6993,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 +7011,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 +7029,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 +7115,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 +7138,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 +7162,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 +7185,6 @@ class WolfMapViewer(wx.Frame):
             newmanager.Show()
 
         elif itemlabel==_('Create BC manager Wolf2D...'):
-            autoscale = False
 
             if self.active_array is not None:
 
@@ -6885,27 +7217,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 +7255,6 @@ class WolfMapViewer(wx.Frame):
                 obj.saveas()
 
         elif itemlabel == 'Save to image...':
-            autoscale = False
 
             fn, ds = self.save_canvasogl(mpl=True)
 
@@ -6932,11 +7262,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 +7314,7 @@ class WolfMapViewer(wx.Frame):
                 del wait
 
         elif itemlabel == _('Import...'):
-            autoscale = False
+
             curarray: WolfArray
 
             msg = ''
@@ -7038,7 +7368,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 +7385,6 @@ class WolfMapViewer(wx.Frame):
             self.update_blender_sculpting()
 
         elif itemlabel == _('Update...'):
-            autoscale = False
 
             msg = ''
             if self.active_array is None:
@@ -7071,7 +7400,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 +7424,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()