wolfhece 2.1.115__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'))
@@ -2283,21 +2324,33 @@ class WolfMapViewer(wx.Frame):
                 dlg.Destroy()
                 return
 
-            for curmodel in self.iterator_over_objects(draw_type.RES2D):
+            pgbar = wx.ProgressDialog(_('Setting epsilon'), _('Setting epsilon'), maximum = len(self.myres2D), parent=self, style = wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
+
+            for id, curmodel in enumerate(self.iterator_over_objects(draw_type.RES2D)):
                 curmodel: Wolfresults_2D
                 curmodel.epsilon = neweps
                 curmodel._epsilon_default = neweps
                 curmodel.read_oneresult(curmodel.current_result)
                 curmodel.set_currentview()
 
+                pgbar.Update(id, _('Setting epsilon for result {}'.format(curmodel.idx)))
+
+            pgbar.Destroy()
+
         elif itemlabel == _("Filter independent"):
 
             self.menu_filter_independent.IsChecked = not self.menu_filter_independent.IsChecked
 
-            for curmodel in self.iterator_over_objects(draw_type.RES2D):
+            pgbar = wx.ProgressDialog(_('Filtering independent zones'), _('Filtering independent zones'), maximum = len(self.myres2D), parent=self, style = wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
+
+            for id, curmodel in enumerate(self.iterator_over_objects(draw_type.RES2D)):
                 curmodel: Wolfresults_2D
                 curmodel.to_filter_independent = not self.menu_filter_independent.IsChecked
 
+                pgbar.Update(id, _('Filtering independent zones for result {}'.format(curmodel.idx)))
+
+            pgbar.Destroy()
+
         # elif itemlabel == _("Manage boundary conditions..."):
 
         #     if self.active_res2d is not None:
@@ -2988,6 +3041,26 @@ class WolfMapViewer(wx.Frame):
         else:
             return config[ConfigurationKeys.TICKS_SIZE]
 
+    @property
+    def ticks_xrotation(self) -> float:
+        """ Return the ticks x rotation from configs """
+
+        config = self.get_configuration()
+        if config is None:
+            return 30.
+        else:
+            return config[ConfigurationKeys.TICKS_XROTATION]
+
+    @property
+    def ticks_fontsize(self) -> int:
+        """ Return the ticks font size from configs """
+
+        config = self.get_configuration()
+        if config is None:
+            return 14
+        else:
+            return config[ConfigurationKeys.TICKS_FONTSIZE]
+
     @property
     def assembly_mode(self) -> str:
         """ Return the assembly mode from configs """
@@ -3182,187 +3255,10 @@ class WolfMapViewer(wx.Frame):
             return
         self.start_action('rotate triangles', 'Rotate the current triangulation -- Please select 1 point for the center')
 
-    def copy_canvasogl(self, mpl:bool= True, ds:float= 0., figsizes= [10.,10.], palette:wolfpalette = None):
-        """
-        Generate image based on UI context and copy to the Clipboard
 
-        :param mpl: Using Matplolib as renderer. Defaults to True.
-        :type mpl: bool, optional
-        :parem ds: Ticks size. Defaults to 0..
-        :type ds: float, optional
-        :parem figsizes: fig size in inches
-        :type figsizes: list, optional
-        """
-
-        if wx.TheClipboard.Open():
-            self.Paint()
-
-            if self.SetCurrentContext():
-
-                myimage = self.get_canvas_as_image()
-
-                # # Récupération  du buffer OpenGL
-                # glPixelStorei(GL_PACK_ALIGNMENT, 1)
-                # data = glReadPixels(0, 0, self.canvaswidth, self.canvasheight, GL_RGBA, GL_UNSIGNED_BYTE)
-                # # Création d'une image sur base du buffer
-                # myimage: Image.Image
-                # myimage = Image.frombuffer("RGBA", (self.canvaswidth, self.canvasheight), data)
-                # # On tranpose car OpenGL travaille avec comme référence le coin inférieur gauche
-                # myimage = myimage.transpose(1)
-
-                metadata = PngInfo()
-                metadata.add_text('xmin', str(self.xmin))
-                metadata.add_text('ymin', str(self.ymin))
-                metadata.add_text('xmax', str(self.xmax))
-                metadata.add_text('ymax', str(self.ymax))
-
-                if mpl:
-                    if ds == 0.:
-                        ds = self.ticks_size # Global parameters
-
-                        if ds == 0.:
-                            ds = 100.
-
-                        nb_ticks_x = (self.xmax - self.xmin) // ds
-                        nb_ticks_y = (self.ymax - self.ymin) // ds
-
-                        if nb_ticks_x > 10 or nb_ticks_y > 10:
-                            logging.error(_('Too many ticks for the image. Please raise the ticks size in the global options.'))
-                            return
-
-                    # Création d'une graphique Matplotlib
-                    extent = (self.xmin, self.xmax, self.ymin, self.ymax)
-                    fig, ax = plt.subplots(1, 1)
-
-                    w, h = [self.width, self.height]
-
-                    # neww = figsizes[0]/figsizes[1] *h
-                    neww = figsizes[0]
-                    newh = h/w * figsizes[0]
-
-                    fig.set_size_inches(neww, newh)
-
-                    pos = ax.imshow(myimage,
-                                    origin='upper',
-                                    extent=extent)
-
-                    x1 = np.ceil((self.xmin // ds) * ds)
-                    if x1 < self.xmin:
-                        x1 += ds
-                    x2 = int((self.xmax // ds) * ds)
-                    if x2 > self.xmax:
-                        x2 -= ds
-                    y1 = np.ceil((self.ymin // ds) * ds)
-                    if y1 < self.ymin:
-                        y1 += ds
-                    y2 = int((self.ymax // ds) * ds)
-                    if y2 > self.ymax:
-                        y2 -= ds
-
-                    x_label_list = np.linspace(x1, x2, int((x2 - x1) / ds) + 1, True)
-                    if self.ticks_bounds:
-                        x_label_list = np.insert(x_label_list, 0, self.xmin)
-                        x_label_list = np.insert(x_label_list, -1, self.xmax)
-                        x_label_list = np.unique(x_label_list)
-
-                    y_label_list = np.linspace(y1, y2, int((y2 - y1) / ds) + 1, True)
-                    if self.ticks_bounds:
-                        y_label_list = np.insert(y_label_list, 0, self.ymin)
-                        y_label_list = np.insert(y_label_list, -1, self.ymax)
-                        y_label_list = np.unique(y_label_list)
-
-                    ax.set_xticks(x_label_list)
-                    ax.set_yticks(y_label_list)
-
-                    ax.set_xticklabels(plt.FormatStrFormatter('%.1f').format_ticks(x_label_list), fontsize=14, rotation=30)
-                    ax.set_yticklabels(plt.FormatStrFormatter('%.1f').format_ticks(y_label_list), fontsize=14)
-
-                    ax.set_xlabel('X [m]')
-                    ax.set_ylabel('Y [m]')
-
-                    #création de 2 buffers
-                    buf = io.BytesIO()
-                    #sauvegarde de la figure au format png
-                    fig.tight_layout()
-                    fig.savefig(buf, format='png')
-
-                    #déplacement au début du buffer
-                    buf.seek(0)
-                    #lecture du buffer et conversion en image avec PIL
-                    im = Image.open(buf)
-
-                    if palette is None:
-                        palette = self.palette_for_copy
-                        # if self.active_array is not None:
-                        #     palette = self.active_array.mypal
-                        # elif self.active_res2d is not None:
-                        #     palette = self.active_res2d.mypal
-
-                    if palette is not None:
-                        if palette.values is not None:
-                            bufpal = io.BytesIO()
-                            palette.export_image(bufpal,'v')
-                            bufpal.seek(0)
-
-                            #lecture du buffer et conversion en image avec PIL
-                            impal = Image.open(bufpal)
-                            impal = impal.resize((int(impal.size[0]*im.size[1]*.8/impal.size[1]),int(im.size[1]*.8)))
-
-                            imnew = Image.new('RGB',(im.size[0]+impal.size[0], im.size[1]), (255,255,255))
-
-                            # On colle l'image du buffer et la palette pour ne former qu'une seul image à copier dans le clipboard
-                            imnew.paste(im.convert('RGB'),(0,0))
-                            imnew.paste(impal.convert('RGB'),(im.size[0]-10, int((im.size[1]-impal.size[1])/3)))
-                            im=imnew
-                        else:
-                            imnew = Image.new('RGB', (im.size[0], im.size[1]), (255,255,255))
-
-                            # On colle l'image du buffer et la palette pour ne former qu'une seul image à copier dans le clipboard
-                            imnew.paste(im.convert('RGB'),(0,0))
-                            im=imnew
-                    else:
-                        imnew = Image.new('RGB', (im.size[0], im.size[1]), (255,255,255))
-
-                        # On colle l'image du buffer et la palette pour ne former qu'une seul image à copier dans le clipboard
-                        imnew.paste(im.convert('RGB'),(0,0))
-                        im=imnew
-
-                    #création d'un objet bitmap wx
-                    wxbitmap = wx.Bitmap().FromBuffer(im.width,im.height,im.tobytes())
-
-                    # objet wx exportable via le clipboard
-                    dataobj = wx.BitmapDataObject()
-                    dataobj.SetBitmap(wxbitmap)
-
-                    wx.TheClipboard.SetData(dataobj)
-                    wx.TheClipboard.Close()
-
-                    fig.set_visible(False)
-
-                    buf.close()
-
-                    return fig, ax, im
-
-                else:
-                    """ Création d'un objet bitmap wx sur base du canvas
-                    et copie dans le clipboard
-                    """
-                    # wxbitmap = wx.Bitmap().FromBuffer(myimage.width,myimage.height,myimage.tobytes())
-                    wxbitmap = wx.Bitmap().FromBufferRGBA(myimage.width,myimage.height,myimage.tobytes())
-
-                    # objet wx exportable via le clipboard
-                    dataobj = wx.BitmapDataObject()
-                    dataobj.SetBitmap(wxbitmap)
-
-                    wx.TheClipboard.SetData(dataobj)
-                    wx.TheClipboard.Close()
-
-                    return myimage
-
-        else:
-            wx.MessageBox("Can't open the clipboard", "Error")
-
-    def display_canvasogl(self,mpl =True, ds=0., fig: Figure = None, ax: Axes = None, clear = True, redraw =True, palette=False, title=''):
+    def display_canvasogl(self, mpl =True,
+                          ds=0., fig: Figure = None, ax: Axes = None,
+                          clear = True, redraw =True, palette=False, title=''):
         """
         This method takes a matplotlib figure and axe and,
         returns a clear screenshot of the information displayed in the wolfpy GUI.
@@ -3418,19 +3314,22 @@ class WolfMapViewer(wx.Frame):
                 myax.set_xticks(x_label_list)
                 myax.set_yticks(y_label_list)
 
-                myax.set_xticklabels(FormatStrFormatter('%.1f').format_ticks(x_label_list), fontsize = 'xx-small', rotation = 90)
-                myax.set_yticklabels(FormatStrFormatter('%.1f').format_ticks(y_label_list), fontsize='xx-small')
+                myax.set_xticklabels(FormatStrFormatter('%.1f').format_ticks(x_label_list),
+                                     fontsize = self.ticks_fontsize, rotation = self.ticks_xrotation)
+                myax.set_yticklabels(FormatStrFormatter('%.1f').format_ticks(y_label_list),
+                                     fontsize = self.ticks_fontsize)
                 myax.xaxis.set_ticks_position('top')
                 myax.xaxis.set_label_position('top')
 
-                myax.set_xlabel('X - coordinates ($m$)')
-                myax.set_ylabel('Y - coordinates ($m$)')
+                myax.set_xlabel('X ($m$)')
+                myax.set_ylabel('Y ($m$)')
                 myax.xaxis.set_ticks_position('bottom')
                 myax.xaxis.set_label_position('bottom')
 
                 if title!='':
                     myax.set_title(title)
 
+                fig.tight_layout()
                 fig.canvas.draw()
                 fig.canvas.flush_events()
 
@@ -3605,12 +3504,188 @@ class WolfMapViewer(wx.Frame):
 
             return myimage
 
+    def copy_canvasogl(self, mpl:bool= True, ds:float= 0., figsizes= [10.,10.], palette:wolfpalette = None):
+        """
+        Generate image based on UI context and copy to the Clipboard
+
+        :param mpl: Using Matplolib as renderer. Defaults to True.
+        :type mpl: bool, optional
+        :parem ds: Ticks size. Defaults to 0..
+        :type ds: float, optional
+        :parem figsizes: fig size in inches
+        :type figsizes: list, optional
+        """
+
+        if wx.TheClipboard.Open():
+            self.Paint()
+
+            if self.SetCurrentContext():
+
+                myimage = self.get_canvas_as_image()
+
+                metadata = PngInfo()
+                metadata.add_text('xmin', str(self.xmin))
+                metadata.add_text('ymin', str(self.ymin))
+                metadata.add_text('xmax', str(self.xmax))
+                metadata.add_text('ymax', str(self.ymax))
+
+                if mpl:
+                    if ds == 0.:
+                        ds = self.ticks_size # Global parameters
+
+                        if ds == 0.:
+                            ds = 100.
+
+                        nb_ticks_x = (self.xmax - self.xmin) // ds
+                        nb_ticks_y = (self.ymax - self.ymin) // ds
+
+                        if nb_ticks_x > 10 or nb_ticks_y > 10:
+                            logging.error(_('Too many ticks for the image. Please raise the ticks size in the global options.'))
+                            return
+
+                    # Création d'un graphique Matplotlib
+                    extent = (self.xmin, self.xmax, self.ymin, self.ymax)
+                    fig, ax = plt.subplots(1, 1)
+
+                    w, h = [self.width, self.height]
+
+                    neww = figsizes[0]
+                    newh = h/w * figsizes[0]
+
+                    fig.set_size_inches(neww, newh)
+
+                    pos = ax.imshow(myimage,
+                                    origin='upper',
+                                    extent=extent)
+
+                    x1 = np.ceil((self.xmin // ds) * ds)
+                    if x1 < self.xmin:
+                        x1 += ds
+                    x2 = int((self.xmax // ds) * ds)
+                    if x2 > self.xmax:
+                        x2 -= ds
+                    y1 = np.ceil((self.ymin // ds) * ds)
+                    if y1 < self.ymin:
+                        y1 += ds
+                    y2 = int((self.ymax // ds) * ds)
+                    if y2 > self.ymax:
+                        y2 -= ds
+
+                    x_label_list = np.linspace(x1, x2, int((x2 - x1) / ds) + 1, True)
+                    if self.ticks_bounds:
+                        x_label_list = np.insert(x_label_list, 0, self.xmin)
+                        x_label_list = np.insert(x_label_list, -1, self.xmax)
+                        x_label_list = np.unique(x_label_list)
+
+                    y_label_list = np.linspace(y1, y2, int((y2 - y1) / ds) + 1, True)
+                    if self.ticks_bounds:
+                        y_label_list = np.insert(y_label_list, 0, self.ymin)
+                        y_label_list = np.insert(y_label_list, -1, self.ymax)
+                        y_label_list = np.unique(y_label_list)
+
+                    ax.set_xticks(x_label_list)
+                    ax.set_yticks(y_label_list)
+
+                    ax.set_xticklabels(plt.FormatStrFormatter('%.1f').format_ticks(x_label_list),
+                                       fontsize = self.ticks_fontsize, rotation = self.ticks_xrotation)
+                    ax.set_yticklabels(plt.FormatStrFormatter('%.1f').format_ticks(y_label_list),
+                                       fontsize = self.ticks_fontsize)
+
+                    ax.set_xlabel('X ($m$)')
+                    ax.set_ylabel('Y ($m$)')
+
+                    fig.tight_layout()
+
+                    #création d'un'buffers
+                    buf = io.BytesIO()
+                    #sauvegarde de la figure au format png
+                    fig.savefig(buf, format='png')
+
+                    #déplacement au début du buffer
+                    buf.seek(0)
+                    #lecture du buffer et conversion en image avec PIL
+                    im = Image.open(buf)
+
+                    if palette is None:
+                        palette = self.palette_for_copy
+                        # if self.active_array is not None:
+                        #     palette = self.active_array.mypal
+                        # elif self.active_res2d is not None:
+                        #     palette = self.active_res2d.mypal
+
+                    if palette is not None:
+                        if palette.values is not None:
+                            bufpal = io.BytesIO()
+                            palette.export_image(bufpal,'v')
+                            bufpal.seek(0)
+
+                            #lecture du buffer et conversion en image avec PIL
+                            impal = Image.open(bufpal)
+                            impal = impal.resize((int(impal.size[0]*im.size[1]*.8/impal.size[1]),int(im.size[1]*.8)))
+
+                            imnew = Image.new('RGB',(im.size[0]+impal.size[0], im.size[1]), (255,255,255))
+
+                            # On colle l'image du buffer et la palette pour ne former qu'une seul image à copier dans le clipboard
+                            imnew.paste(im.convert('RGB'),(0,0))
+                            imnew.paste(impal.convert('RGB'),(im.size[0]-10, int((im.size[1]-impal.size[1])/3)))
+                            im=imnew
+                            bufpal.close()
+                        else:
+                            imnew = Image.new('RGB', (im.size[0], im.size[1]), (255,255,255))
+
+                            # On colle l'image du buffer et la palette pour ne former qu'une seul image à copier dans le clipboard
+                            imnew.paste(im.convert('RGB'),(0,0))
+                            im=imnew
+                    else:
+                        imnew = Image.new('RGB', (im.size[0], im.size[1]), (255,255,255))
+
+                        # On colle l'image du buffer et la palette pour ne former qu'une seul image à copier dans le clipboard
+                        imnew.paste(im.convert('RGB'),(0,0))
+                        im=imnew
+
+                    #création d'un objet bitmap wx
+                    wxbitmap = wx.Bitmap().FromBuffer(im.width,im.height,im.tobytes())
+
+                    # objet wx exportable via le clipboard
+                    dataobj = wx.BitmapDataObject()
+                    dataobj.SetBitmap(wxbitmap)
+
+                    wx.TheClipboard.SetData(dataobj)
+                    wx.TheClipboard.Close()
+
+                    fig.set_visible(False)
+
+                    buf.close()
+
+                    return fig, ax, im
+
+                else:
+                    """ Création d'un objet bitmap wx sur base du canvas
+                    et copie dans le clipboard
+                    """
+                    # wxbitmap = wx.Bitmap().FromBuffer(myimage.width,myimage.height,myimage.tobytes())
+                    wxbitmap = wx.Bitmap().FromBufferRGBA(myimage.width,myimage.height,myimage.tobytes())
+
+                    # objet wx exportable via le clipboard
+                    dataobj = wx.BitmapDataObject()
+                    dataobj.SetBitmap(wxbitmap)
+
+                    wx.TheClipboard.SetData(dataobj)
+                    wx.TheClipboard.Close()
+
+                    return myimage
+
+        else:
+            wx.MessageBox("Can't open the clipboard", "Error")
+
     def save_canvasogl(self,
                        fn:str='',
                        mpl:bool=True,
                        ds:float=0.,
                        dpi:int= 300,
-                       add_title:bool = False):
+                       add_title:bool = False,
+                       figsizes= [10.,10.],
+                       arrayid_as_title:bool = False):
         """
         Sauvegarde de la fenêtre d'affichage dans un fichier
 
@@ -3619,6 +3694,7 @@ class WolfMapViewer(wx.Frame):
         :param ds: Ticks interval
         """
 
+        # FIXME : SHOULD BE MERGEd WITH copy_canvasogl
         fn = str(fn)
 
         if fn == '':
@@ -3634,19 +3710,7 @@ class WolfMapViewer(wx.Frame):
             fn += '.png'
 
         if self.SetCurrentContext():
-            # glPixelStorei(GL_PACK_ALIGNMENT, 1)
-            # data = glReadPixels(0, 0, self.canvaswidth, self.canvasheight, GL_RGBA, GL_UNSIGNED_BYTE)
-            # myimage: Image.Image
-            # myimage = Image.frombuffer("RGBA", (self.canvaswidth, self.canvasheight), data)
-            # myimage = myimage.transpose(1)
-
-            myimage = self.get_canvas_as_image()
-
-            metadata = PngInfo()
-            metadata.add_text('xmin', str(self.xmin))
-            metadata.add_text('ymin', str(self.ymin))
-            metadata.add_text('xmax', str(self.xmax))
-            metadata.add_text('ymax', str(self.ymax))
+            self.Paint()
 
             if mpl:
                 if ds == 0.:
@@ -3664,69 +3728,70 @@ class WolfMapViewer(wx.Frame):
                     ds = float(dlg.GetValue())
                     dlg.Destroy()
 
+                # Création d'un graphique Matplotlib
                 extent = (self.xmin, self.xmax, self.ymin, self.ymax)
-                # fig, ax = plt.subplots(1, 1)
-                fig,axes = plt.subplots(1,2, gridspec_kw={'width_ratios': [20, 1]})
+                fig, ax = plt.subplots(1, 1)
+                w, h = [self.width, self.height]
 
-                ax = axes[0]
-                self.display_canvasogl(fig=fig,ax=axes[0])
+                neww = figsizes[0]
+                newh = h/w * figsizes[0]
 
-                # pos = ax.imshow(myimage, origin='upper',
-                #           extent=extent)
-                # fig.colorbar(pos,ax=ax)
+                fig.set_size_inches(neww, newh)
 
-                x1 = np.ceil((self.xmin // ds) * ds)
-                if x1 < self.xmin:
-                    x1 += ds
-                x2 = int((self.xmax // ds) * ds)
-                if x2 > self.xmax:
-                    x2 -= ds
-                y1 = np.ceil((self.ymin // ds) * ds)
-                if y1 < self.ymin:
-                    y1 += ds
-                y2 = int((self.ymax // ds) * ds)
-                if y2 > self.ymax:
-                    y2 -= ds
+                pot_title = self.viewer_name
+                if arrayid_as_title:
+                    pot_title = self.active_array.idx
 
-                x_label_list = np.linspace(x1, x2, int((x2 - x1) / ds) + 1, True)
-                x_label_list = np.insert(x_label_list, 0, self.xmin)
-                x_label_list = np.insert(x_label_list, -1, self.xmax)
-                x_label_list = np.unique(x_label_list)
+                self.display_canvasogl(fig=fig,
+                                       ax=ax,
+                                       title=pot_title if add_title else '',
+                                       ds = ds)
 
-                y_label_list = np.linspace(y1, y2, int((y2 - y1) / ds) + 1, True)
-                y_label_list = np.insert(y_label_list, 0, self.ymin)
-                y_label_list = np.insert(y_label_list, -1, self.ymax)
-                y_label_list = np.unique(y_label_list)
+                #création d'un'buffers
+                buf = io.BytesIO()
+                #sauvegarde de la figure au format png
+                fig.savefig(buf, format='png')
 
-                ax.set_xticks(x_label_list)
-                ax.set_yticks(y_label_list)
+                #déplacement au début du buffer
+                buf.seek(0)
+                #lecture du buffer et conversion en image avec PIL
+                im = Image.open(buf)
 
-                ax.set_xticklabels(plt.FormatStrFormatter('%.1f').format_ticks(x_label_list), fontsize=8, rotation=30)
-                ax.set_yticklabels(plt.FormatStrFormatter('%.1f').format_ticks(y_label_list), fontsize=8)
+                if self.palette_for_copy.values is not None:
+                    bufpal = io.BytesIO()
+                    self.palette_for_copy.export_image(bufpal,'v')
+                    bufpal.seek(0)
 
-                ax.set_xlabel('X [m]')
-                ax.set_ylabel('Y [m]')
+                    #lecture du buffer et conversion en image avec PIL
+                    impal = Image.open(bufpal)
+                    impal = impal.resize((int(impal.size[0]*im.size[1]*.8/impal.size[1]),int(im.size[1]*.8)))
 
-                if self.palette_for_copy.values is not None:
-                    self.palette_for_copy.export_image(None, h_or_v='v', figax=(fig,axes[1]))
-                else:
-                    axes[1].clear()
-                    axes[1].axis('off')
+                    imnew = Image.new('RGB',(im.size[0]+impal.size[0], im.size[1]), (255,255,255))
 
-                # if self.active_array is not None:
-                #     self.active_array.mypal.export_image(None, h_or_v='v', figax=(fig,axes[1]))
-                # elif self.active_res2d is not None:
-                #     self.active_res2d.mypal.export_image(None, h_or_v='v', figax=(fig,axes[1]))
+                    # On colle l'image du buffer et la palette pour ne former qu'une seul image à copier dans le clipboard
+                    imnew.paste(im.convert('RGB'),(0,0))
+                    imnew.paste(impal.convert('RGB'),(im.size[0]-10, int((im.size[1]-impal.size[1])/3)))
+                    im=imnew
+                    bufpal.close()
+                else:
+                    imnew = Image.new('RGB', (im.size[0], im.size[1]), (255,255,255))
 
-                # self.Paint()
+                    # On colle l'image du buffer et la palette pour ne former qu'une seul image à copier dans le clipboard
+                    imnew.paste(im.convert('RGB'),(0,0))
+                    im=imnew
 
-                if add_title:
-                    ax.set_title(self.viewer_name)
-                fig.set_size_inches(12, 10)
-                fig.tight_layout()
+                im.save(fn, dpi=(dpi, dpi))
+                fig.set_visible(False)
+                buf.close()
 
-                fig.savefig(fn, dpi=dpi)
             else:
+                metadata = PngInfo()
+                metadata.add_text('xmin', str(self.xmin))
+                metadata.add_text('ymin', str(self.ymin))
+                metadata.add_text('xmax', str(self.xmax))
+                metadata.add_text('ymax', str(self.ymax))
+
+                myimage = self.get_canvas_as_image()
                 myimage.save(fn, pnginfo=metadata)
 
             return fn, ds
@@ -4848,258 +4913,589 @@ class WolfMapViewer(wx.Frame):
         """
         curdir = Path(os.getcwd())
 
+        real_ids = {}
+
         myproject = Wolf_Param(None, filename=fn, toShow=False)
 
-        mykeys = ['cross_sections', 'vector', 'array']
+        def check_params(myproject, curgroup) -> bool:
 
-        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])))
+            check = True
+            pot_keys = list(PROJECT_GROUP_KEYS[curgroup].keys())
 
-                self.set_compare(ListCompare)
-                return
+            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)
+
+            while id in existing_id:
+                logging.warning(_('ID already exists - Changing it...'))
+                id = id + '_'
+
+            return id
+
+        # COMPLEX ACTIONS
+        curgroup = PROJECT_ACTION
+        if myproject.is_in(curgroup):
 
-        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)
+            pot_keys = list(PROJECT_GROUP_KEYS[curgroup].keys())
 
-                    self.add_object('cross_sections', newobj=mycs, id=curid)
+            for curkey in pot_keys:
+                which = myproject[(curgroup, curkey)]
 
+                pot_val = list(PROJECT_GROUP_KEYS[curgroup][curkey].keys())
 
-        if myproject.get_group('tiles') is not None:
+                if which in pot_val:
+                    if which == 'compare_arrays':
 
-            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')
+                        # Comparaison de plusieurs matrices
 
-            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)
+                        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
+
+                        logging.info(_('Setting compare...'))
+                        self.set_compare(ListCompare)
+                        logging.info(_('Compare set !'))
+                        return
+                else:
+                    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.info(_('Bad parameter in project file - tiles : ')+ curfile)
+                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 myproject.get_group('laz_grid') is not None:
+                        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.warning(_('File does not exist : ')+ curfile)
+            else:
+                logging.warning(_('Bad parameter in project file - tiles'))
 
-            curdatadir = myproject.get_param('laz_grid', 'data_dir')
+        # 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
+
+                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.Update(pgbar.GetValue() + 1)
+
+                pgbar.Destroy()
 
-            self.init_laz_from_gridinfos(curdatadir)
+                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.warning(_('Bad palette file : ')+ name)
+                    else:
+                        logging.info(_('Bad parameter in project file - palette : ')+ name)
+            else:
+                logging.warning(_('Bad parameter in project file - palette'))
 
-        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)
+        # 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 parameter in project file - vector : ')+ 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'))
+
+        curgroup = PROJECT_LINK_CS
+        if myproject.is_in(curgroup):
+            if self.active_cs is not None:
+                if check_params(myproject, curgroup):
+
+                    idx = real_ids[(draw_type.VECTORS, myproject[(curgroup, 'linkzones')])]
+                    curzones = self.get_obj_from_id(idx, draw_type.VECTORS)
+
+                    if curzones is not None:
+                        self.active_cs.link_external_zones(curzones)
+
+                    zonename = myproject[(curgroup, 'sortzone')]
+                    vecname  = myproject[(curgroup, 'sortname')]
+                    downfirst = myproject[(curgroup, 'downfirst')]
+
+                    downfirst = False
+                    if downfirst == 1 or str(downfirst).lower() == 'true':
+                        downfirst = True
+
+                    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.warning(_('Bad parameter in project file - cross_sections_link'))
+            else:
+                logging.warning(_('No active cross section to link !'))
+
+        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:
+                                logging.warning(_('In vec-array association, You must have only 1 zone and 1 polyline !'))
+
+                        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'))
+
+    def save_project(self, fn, absolute:bool = True):
+        """ Save project file """
+
+        dirproj = Path(fn).parent
+
+        def new_path(drawtype:draw_type, id:str) -> str:
+            logging.info(_('Empty path but I need a path !'))
+
+            path = ''
+
+            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'
+
+            dlg = wx.FileDialog(None, _('Choose a filename for ') + id, str(dirproj), '', ext, wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT)
+            ret = dlg.ShowModal()
+
+            if ret == wx.ID_OK:
+                path = Path(dlg.GetPath())
+
+            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)
+
+        # matrices
+        try:
+            curgroup = PROJECT_ARRAY
+            for curel in self.iterator_over_objects(draw_type.ARRAYS):
+                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:
+            logging.error(_('Error in saving arrays'))
+
+        # résultats 2D
+        try:
+            curgroup = PROJECT_WOLF2D
+            for curel in self.iterator_over_objects(draw_type.RES2D):
+                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:
+            logging.error(_('Error in saving 2D results'))
+
+        # vecteurs
+        try:
+            curgroup = PROJECT_VECTOR
+            for curel in self.iterator_over_objects(draw_type.VECTORS):
+                if isinstance(curel, crosssections):
+                    continue
 
-        if 'array' in myproject.myparams.keys():
-            for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
+                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)
 
-                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])
+                myproject.add_param(curgroup, curel.idx, sanit_path(curel.filename, absolute, draw_type.VECTORS))
+        except:
+            logging.error(_('Error in saving vectors'))
 
-        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)
-                else:
-                    logging.info(_('Bad parameter in project file - cloud : ')+ curname[key_Param.VALUE])
+        # 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'))
 
-        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)
-                else:
-                    logging.info(_('Bad parameter in project file - wolf2d : ')+ curname[key_Param.VALUE])
+        # 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'))
 
-            self.menu_wolf2d()
+        # 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'))
 
-        if 'gpu2d' in myproject.myparams.keys():
+        # 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'))
 
-            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)
+        # 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'))
 
-            for curid, curname in zip(myproject.myparams['gpu2d'].keys(), myproject.myparams['gpu2d'].values()):
-                if exists(curname[key_Param.VALUE]):
+        myproject.Save(fn)
 
-                    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)
-                        else:
-                            logging.info(_('Bad directory : ')+ curname[key_Param.VALUE])
 
-                    self.add_object('res2d', newobj=curwolf, id=curid)
-                else:
-                    logging.info(_('Bad directory : ')+ curname[key_Param.VALUE])
+    def help_project(self):
+        """ Help for project file.
 
-                pgbar.Update(pgbar.GetValue() + 1)
+        Define which elements can be saved in a project file.
 
-            pgbar.Destroy()
+        """
 
-            self.menu_wolf2d()
-            self.menu_2dgpu()
+        logging.info(_('Project file help'))
 
-        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
+        logging.info(_('Project file is a file containing some information about the current project.'))
 
-                    self.project_pal[curid] = mypal
-                else:
-                    logging.info(_('Bad parameter in project file - palette : ')+ curname[key_Param.VALUE])
+        logging.info(_('It can contain the following informations :'))
 
-        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)
-                            else:
-                                curarray.myops.palauto.SetValue(0)
-                            curarray.updatepalette(0)
-                            curarray.delete_lists()
-                        else:
-                            logging.warning(_('Bad parameter in project file - palette-array : ')+ curid)
+        logging.info(_(' - Arrays :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
 
-        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]
+        logging.info(_(' - Cross sections :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
 
-                for curzones in self.iterator_over_objects(draw_type.VECTORS):
-                    curzones: Zones
-                    if curzones.idx == idx:
-                        self.active_cs.link_external_zones(curzones)
+        logging.info(_(' - Vectors :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
 
-                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
+        logging.info(_(' - Clouds :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
 
-                for curarray in self.myarrays:
-                    if curarray.idx == curid.lower():
-                        locarray=curarray
-                        break
+        logging.info(_(' - Tiles :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
 
-                if locvec is not None and locarray is not None:
+        logging.info(_(' - LAZ grid :'))
+        logging.info(_('   - data_dir : directory containing the NUMPY grid'))
+        logging.info(_('   - classification : classification of the laz files'))
 
-                    locarray.linkedvec = locvec.myzones[0].myvectors[0]
+        logging.info(_(' - Palettes :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
 
-                else:
+        logging.info(_(' - Wolf2D CPU results :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
 
-                    logging.warning(_('Bad vec-array association in project file !'))
-                    logging.warning(curid)
-                    logging.warning(curname[key_Param.VALUE])
+        logging.info(_(' - Wolf2D GPU results :'))
+        logging.info(_('   - id'))
+        logging.info(_('   - filename in relative or absolute path'))
 
-    def save_project(self, fn):
-        myproject = Wolf_Param(None, toShow=False)
+        logging.info(_(' - Palette-Array links :'))
+        logging.info(_('   - id of the array'))
+        logging.info(_('   - id of the palette'))
 
-        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:
-            for curel in self.iterator_over_objects(draw_type.ARRAYS):
-                myproject['array'][curel.idx] = {}
-                myproject['array'][curel.idx][key_Param.VALUE] = curel.filename
+        logging.info(_(' - Vector-Array links :'))
+        logging.info(_('   - id of the array'))
+        logging.info(_('   - id of the vector (containing only 1 zone and 1 vector)'))
 
-        except:
-            pass
+        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'))
 
-        # résultats 2D
-        try:
-            for curel in self.iterator_over_objects(draw_type.RES2D):
-                myproject['wolf2d'][curel.idx] = {}
-                myproject['wolf2d'][curel.idx][key_Param.VALUE] = curel.filename
+        logging.info('')
+        logging.info(_('A tabulation is used to separate the value and the key.'))
+        logging.info('')
 
-        except:
-            pass
+        logging.info(_('Exemple :'))
 
-        # vecteurs
-        try:
-            for curel in self.iterator_over_objects(draw_type.VECTORS):
-                myproject['vector'][curel.idx] = {}
-                myproject['vector'][curel.idx][key_Param.VALUE] = curel.filename
+        logging.info('')
 
-        except:
-            pass
+        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)
@@ -5121,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 """
@@ -5139,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]
@@ -5504,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'))
@@ -5516,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:
@@ -5622,7 +6017,9 @@ class WolfMapViewer(wx.Frame):
 
         self.currently_readresults = True
 
-        for curmodel in self.iterator_over_objects(draw_type.RES2D):
+        pgbar = wx.ProgressDialog(_('Reading results'), _('Reading results'), maximum=len(self.myres2D), parent=self, style=wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
+
+        for id, curmodel in enumerate(self.iterator_over_objects(draw_type.RES2D)):
             curmodel: Wolfresults_2D
             logging.info(_('Updating {} - Last result'.format(curmodel.idx)))
 
@@ -5630,6 +6027,10 @@ class WolfMapViewer(wx.Frame):
             curmodel.set_currentview()
             self._update_sim_explorer(curmodel)
 
+            pgbar.Update(id + 1, _('Reading results') + ' - ' + curmodel.idx)
+
+        pgbar.Destroy()
+
         self.Refresh()
         self.currently_readresults = False
         self._update_mytooltip()
@@ -5776,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:
@@ -5797,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 !'))
@@ -5838,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 !'))
@@ -5851,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 !'))
@@ -5906,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 !'))
@@ -5961,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 !'))
@@ -5995,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 !'))
@@ -6025,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 !'))
@@ -6062,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 !'))
@@ -6138,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
@@ -6243,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')
@@ -6254,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')
@@ -6279,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()
@@ -6295,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 !'))
@@ -6316,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)
@@ -6343,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()
@@ -6360,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')
@@ -6372,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')
@@ -6402,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:
@@ -6427,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()
 
@@ -6457,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()
 
@@ -6476,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
@@ -6505,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:
@@ -6530,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
@@ -6540,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
@@ -6551,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'):
@@ -6562,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()
@@ -6580,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()
 
@@ -6594,8 +6959,21 @@ class WolfMapViewer(wx.Frame):
 
             nb = dlg.GetValue()
             dlg.Destroy()
-            for i in range(nb):
-                self.add_viewer_and_link()
+
+            if nb > 0:
+
+                # Renaming the current viewer
+                dlg = wx.TextEntryDialog(None, _('New name for the current viewer'), _('Rename'), self.viewer_name, style=wx.OK | wx.CANCEL)
+                ret = dlg.ShowModal()
+                if ret == wx.ID_OK:
+                    self.viewer_name = dlg.GetValue()
+                    self.SetName(self.viewer_name)
+                dlg.Destroy()
+
+                for i in range(nb):
+                    self.add_viewer_and_link()
+            else:
+                logging.warning(_('No additional viewer !'))
 
         elif itemlabel == _('3D viewer'):
 
@@ -6615,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()
@@ -6635,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)
@@ -6651,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:
@@ -6736,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():
@@ -6758,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,
@@ -6782,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()
@@ -6809,7 +7185,6 @@ class WolfMapViewer(wx.Frame):
             newmanager.Show()
 
         elif itemlabel==_('Create BC manager Wolf2D...'):
-            autoscale = False
 
             if self.active_array is not None:
 
@@ -6842,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
@@ -6881,7 +7255,6 @@ class WolfMapViewer(wx.Frame):
                 obj.saveas()
 
         elif itemlabel == 'Save to image...':
-            autoscale = False
 
             fn, ds = self.save_canvasogl(mpl=True)
 
@@ -6889,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
 
@@ -6941,7 +7314,7 @@ class WolfMapViewer(wx.Frame):
                 del wait
 
         elif itemlabel == _('Import...'):
-            autoscale = False
+
             curarray: WolfArray
 
             msg = ''
@@ -6995,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')
@@ -7012,7 +7385,6 @@ class WolfMapViewer(wx.Frame):
             self.update_blender_sculpting()
 
         elif itemlabel == _('Update...'):
-            autoscale = False
 
             msg = ''
             if self.active_array is None:
@@ -7028,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
 
@@ -7052,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()
@@ -7503,6 +7870,44 @@ class WolfMapViewer(wx.Frame):
 
         return ret
 
+    def save_arrays_indep(self, fn:str, mpl:bool= True, ds:float= 0., add_title:bool= True) -> tuple[(str, float), str]:
+        """ Save each array in a separate file
+
+        :param fn: filename without extension -- '.png' will be added
+        :param mpl: save as matplotlib image
+        :param ds: Ticks size for matplotlib image
+        :return: list of tuple ((filename, ds), viewer_name)
+        """
+
+        # Get all checked arrays
+        checked_arrays = self.get_list_keys(drawing_type= draw_type.ARRAYS, checked_state= True)
+        old_active = self.active_array
+
+        if len(checked_arrays) == 0:
+            logging.warning(_('No arrays checked for export'))
+            return
+
+        def uncheck_all():
+            # uncheck arrays
+            for curarray in checked_arrays:
+                self.uncheck_id(curarray, unload= False, forceresetOGL= False)
+
+        fn = str(fn)
+        ret = []
+        for idx, curel in enumerate(checked_arrays):
+            uncheck_all()
+            self.check_id(curel)
+            self.active_array = self.get_obj_from_id(curel, drawtype= draw_type.ARRAYS)
+            ret.append((self.save_canvasogl(fn + '_' + str(idx) + '.png', mpl, ds, add_title= add_title, arrayid_as_title=True), curel))
+
+        self.active_array = old_active
+        for curarray in checked_arrays:
+            self.check_id(curarray)
+
+        self.Refresh()
+
+        return ret
+
     def assembly_images(self, all_images, mode:Literal['horizontal', 'vertical', 'square']= 'square'):
         """ Assembly images
 
@@ -7518,6 +7923,9 @@ class WolfMapViewer(wx.Frame):
 
         images = [Image.open(fn) for (fn, ds), viewername in all_images]
 
+        if len(images) in [1,2] and (mode == 'square' or mode == 2):
+            mode = 'horizontal'
+
         widths, heights = zip(*(i.size for i in images))
 
         if mode == 'horizontal' or mode==0:
@@ -8858,6 +9266,24 @@ class WolfMapViewer(wx.Frame):
             else:
                 logging.warning(_('Rebin not yet implemented for this type of object'))
 
+        elif text == _('Set NullValue'):
+
+            if isinstance(self.selected_object, WolfArray):
+                dlg = wx.TextEntryDialog(self, _('Enter the new null value :'), _('Set NullValue'), str(self.selected_object.array.data[0,0]))
+                if dlg.ShowModal() == wx.ID_OK:
+                    res = dlg.GetValue()
+                    dlg.Destroy()
+
+                    try:
+                        res = float(res)
+                        self.selected_object.nullvalue = res
+                        self.selected_object.mask_data(res)
+                        self.selected_object.reset_plot()
+                        self.Refresh()
+                    except:
+                        logging.warning(_('Invalid value for null value'))
+                        return
+
         elif _('Convert to mono-block') in text:
 
             if isinstance(self.selected_object, WolfArrayMB):
@@ -8892,6 +9318,30 @@ class WolfMapViewer(wx.Frame):
             else:
                 logging.warning(_('Convert to multi-blocks not yet implemented for this type of object'))
 
+        elif _('Extract current step as IC') in text:
+
+            if isinstance(self.selected_object, Wolfresults_2D):
+
+                if self.selected_object.current_result is None or self.selected_object.current_result < 0 :
+                    logging.warning(_('No current step defined'))
+                    return
+
+                import shutil
+
+                logging.info(_('Extracting current step as IC'))
+
+                dir = Path(self.selected_object.filename).parent
+                files = ['h.npy', 'qx.npy', 'qy.npy']
+                for curfile in files:
+                    if (dir / curfile).exists():
+                        # prepend the file with __
+                        logging.info(f'File {curfile} already exists -- renaming it')
+                        shutil.copyfile(dir / curfile, dir / ('__' + curfile))
+
+                logging.info(_('Extracting current step as IC'))
+                self.selected_object.export_as(Path(self.selected_object.filename).parent, [views_2D.WATERDEPTH, views_2D.QX, views_2D.QY], 'numpy', False)
+                logging.info(_('Done !'))
+
         elif _('Export to Shape file') in text:
 
             if isinstance(self.selected_object, Zones | Bridge | Weir):
@@ -10588,6 +11038,8 @@ class WolfMapViewer(wx.Frame):
         #     CTRL+L : chargement d'une matrice sur base du nom de fichier de la tile\n \
         #     \n \
         #     ALT+C : Copy image"
+        #     ALT+SHIFT+C : Copy images from multiviewers \
+        #     CTRL+ALT+SHIFT+C : Copy images from all arrays as independent image \
 
         groups = ['Results', 'Particle system', 'Drawing', 'Arrays', 'Cross sections', 'Zones', 'Action', 'Tree', 'Tiles', 'GLTF/GLB', 'App']
 
@@ -10619,7 +11071,8 @@ class WolfMapViewer(wx.Frame):
                      'Arrows': _('Drawing : lateral movements'),
                      'c or C': _('Drawing : copy canvas to Clipboard wo axes'),
                      'ALT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image'),
-                     'ALT+SHIFT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image with axes - linked arrays'),
+                     'ALT+SHIFT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image with axes - multiviewers'),
+                     'CTRL+ALT+SHIFT+C': _('Drawing : copy canvas to Clipboard as Matplotlib image with axes - all arrays one by one'),
 
                      'CTRL+o': _('Results : increase transparency of the current result'),
                      'CTRL+O': _('Results : decrease transparency of the current result'),
@@ -10940,12 +11393,20 @@ class WolfMapViewer(wx.Frame):
                 # Copie du canvas dans le clipboard pour transfert vers autre application
                 # Copie des canvas liés
 
+                if not self.linked:
+                    logging.error(_('No linked canvas to copy -- calling ALT+C instead'))
+                    self.copy_canvasogl()
+                    return
+
                 from tempfile import TemporaryDirectory
 
                 logging.info(_('Creating images'))
 
                 with TemporaryDirectory() as tmpdirname:
                     all_images = self.save_linked_canvas(Path(tmpdirname) / 'fig', mpl= True, ds= self.ticks_size, add_title= True)
+                    if len(all_images) == 0:
+                        logging.error(_('No image to combine -- aborting !'))
+                        return
                     im_assembly = self.assembly_images(all_images, mode= self.assembly_mode)
 
                 logging.info(_('Creating images - done'))
@@ -10998,7 +11459,44 @@ class WolfMapViewer(wx.Frame):
 
                 logging.info(_('Values copied to clipboard'))
 
-            elif key == ord('C') and ctrldown and altdown:
+            elif key == ord('C') and ctrldown and altdown and shiftdown:
+                # CTRL+ALT+SHIFT+C
+                # Copie du canvas dans le clipboard pour transfert vers autre application
+                # Une matrice est associée à chaque canvas
+
+                from tempfile import TemporaryDirectory
+
+                logging.info(_('Creating images'))
+
+                with TemporaryDirectory() as tmpdirname:
+                    all_images = self.save_arrays_indep(Path(tmpdirname) / 'fig', mpl= True, ds= self.ticks_size, add_title= True)
+                    if len(all_images) == 0:
+                        logging.error(_('No image to combine -- aborting !'))
+                        return
+                    im_assembly = self.assembly_images(all_images, mode= self.assembly_mode)
+
+                logging.info(_('Creating images - done'))
+
+                # Copy image to clipboard
+                if im_assembly is not None:
+                    if wx.TheClipboard.Open():
+
+                        #création d'un objet bitmap wx
+                        wxbitmap = wx.Bitmap().FromBuffer(im_assembly.width, im_assembly.height, im_assembly.tobytes())
+
+                        # objet wx exportable via le clipboard
+                        dataobj = wx.BitmapDataObject()
+                        dataobj.SetBitmap(wxbitmap)
+
+                        wx.TheClipboard.SetData(dataobj)
+                        wx.TheClipboard.Close()
+                        logging.info(_('Image copied to clipboard'))
+                    else:
+                        logging.error(_('Cannot open the clipboard'))
+                else:
+                    logging.error(_('No image to copy to clipboard'))
+
+            elif key == ord('C') and ctrldown and altdown and not shiftdown:
                 if self.active_array is None:
                     dlg = wx.MessageDialog(self,
                                         _('The active array is None - Please active an array from which to copy the selection !'),
@@ -11372,9 +11870,11 @@ class WolfMapViewer(wx.Frame):
             tracks.append(_('Convert to mono-block'))
             tracks.append(_('Convert to mono-block (result)'))
             tracks.append(_('Convert to multi-blocks (result)'))
+            tracks.append(_('Extract current step as IC (result)'))
             tracks.append(_('Export to Shape file'))
             tracks.append(_('Export active zone to Shape file'))
             tracks.append(_('Rebin'))
+            tracks.append(_('Set NullValue'))
 
             # Récupération des items du menu contextuel
             menuitems = self.popupmenu.GetMenuItems()
@@ -11401,6 +11901,7 @@ class WolfMapViewer(wx.Frame):
                     self.popupmenu.Append(wx.ID_ANY, _('Boundary conditions'), _('Boundary conditions'))
                 self.popupmenu.Append(wx.ID_ANY, _('Contours'))
                 self.popupmenu.Append(wx.ID_ANY, _('Rebin'), _('Change the spatial resolution'))
+                self.popupmenu.Append(wx.ID_ANY, _('Set NullValue'), _('Set NullValue'))
 
             # Add specific menu items for WolfArrayMB
             if isinstance(self.selected_object, WolfArrayMB):
@@ -11410,6 +11911,7 @@ class WolfMapViewer(wx.Frame):
             if isinstance(self.selected_object, Wolfresults_2D):
                 self.popupmenu.Append(wx.ID_ANY, _('Convert to mono-block (result)'), _('Convert to mono-block'))
                 self.popupmenu.Append(wx.ID_ANY, _('Convert to multi-blocks (result)'), _('Convert to multi-blocks'))
+                self.popupmenu.Append(wx.ID_ANY, _('Extract current step as IC (result)'), _('Extract current step as IC'))
 
             if isinstance(self.selected_object, Zones | Bridge | Weir):
                 self.popupmenu.Append(wx.ID_ANY, _('Export to Shape file'), _('Export to Shape file'))