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

wolfhece/PyDraw.py

@@ -682,6 +682,8 @@ class DragdropFileTarget(wx.FileDropTarget):
             else:
                 return False
 
+        pgbar = wx.ProgressDialog(_('Loading files'), _('Loading files'), maximum=len(filenames), parent=self.window, style=wx.PD_APP_MODAL | wx.PD_AUTO_HIDE)
+
         for name in filenames:
 
             if Path(name).is_dir():
@@ -691,7 +693,7 @@ class DragdropFileTarget(wx.FileDropTarget):
                 continue
 
             if test_if_array(name):
-                ids = self.window.get_list_keys(draw_type.ARRAYS)
+                ids = self.window.get_list_keys(draw_type.ARRAYS, checked_state=None)
                 id = Path(name).stem
                 while id in ids:
                     id = id + '_1'
@@ -703,7 +705,7 @@ class DragdropFileTarget(wx.FileDropTarget):
                     logging.error(_('Error while loading array : ') + name)
 
             elif test_if_arrayMB(name):
-                ids = self.window.get_list_keys(draw_type.ARRAYS)
+                ids = self.window.get_list_keys(draw_type.ARRAYS, checked_state=None)
                 id = Path(name).stem
                 while id in ids:
                     id = id + '_1'
@@ -715,7 +717,7 @@ class DragdropFileTarget(wx.FileDropTarget):
                     logging.error(_('Error while loading array : ') + name)
 
             elif test_if_vector(name):
-                ids = self.window.get_list_keys(draw_type.VECTORS)
+                ids = self.window.get_list_keys(draw_type.VECTORS, checked_state=None)
                 id = Path(name).stem
                 while id in ids:
                     id = id + '_1'
@@ -727,7 +729,7 @@ class DragdropFileTarget(wx.FileDropTarget):
                     logging.error(_('Error while loading vector : ') + name)
 
             elif test_if_cloud(name):
-                ids = self.window.get_list_keys(draw_type.CLOUD)
+                ids = self.window.get_list_keys(draw_type.CLOUD, checked_state=None)
                 id = Path(name).stem
                 while id in ids:
                     id = id + '_1'
@@ -738,6 +740,10 @@ class DragdropFileTarget(wx.FileDropTarget):
                 except:
                     logging.error(_('Error while loading cloud : ') + name)
 
+            pgbar.Update(pgbar.GetValue() + 1)
+
+        pgbar.Destroy()
+
         return True
 
 
@@ -1152,6 +1158,10 @@ class WolfMapViewer(wx.Frame):
     active_imagestiles: ImagesTiles
     active_particle_system: Particle_system
     active_viewer3d: Wolf_Viewer3D
+    active_bridges: Bridges
+    active_bridge: Bridge
+    active_weirs : Weirs
+    active_weir : Weir
 
     def __init__(self,
                  wxparent = None,
@@ -1245,6 +1255,8 @@ class WolfMapViewer(wx.Frame):
 
         self.menuwolf2d = None
         self.menu_landmap = None
+        self.menu_bridge = None
+        self.menu_weir = None
         self.menu2d_cache_setup = None
         self.menuparticlesystem = None
         self.menu2dGPU = None
@@ -1487,6 +1499,10 @@ class WolfMapViewer(wx.Frame):
         self.active_tile = None
         self.selected_treeitem = None
         self.selected_object = None
+        self.active_bridges = None
+        self.active_bridge = None
+        self.active_weirs = None
+        self.active_weir = None
 
         curtool = self.tools[ID_SORTALONG] = {}
         curtool['menu'] = self.sortalong
@@ -2267,21 +2283,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:
@@ -2972,6 +3000,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 """
@@ -3166,185 +3214,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()
-
-                    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.
@@ -3400,19 +3273,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()
 
@@ -3562,37 +3438,213 @@ class WolfMapViewer(wx.Frame):
 
             el_time = str(timedelta(seconds=int(times[self.active_res2d.current_result])))
 
-            self.display_canvasogl(fig=fig,
-                                   ax=ax[0],
-                                   title=_('Current time {:0>8} s'.format(el_time)))
+            self.display_canvasogl(fig=fig,
+                                   ax=ax[0],
+                                   title=_('Current time {:0>8} s'.format(el_time)))
+
+        for curmodel in self.iterator_over_objects(draw_type.RES2D):
+            curmodel: Wolfresults_2D
+            curmodel.step_interval_results = 1
+
+
+    def get_canvas_as_image(self) -> Image.Image:
+        """
+        Récupère la fenêtre OpenGL sous forme d'image
+        """
+
+        self.Paint()
+
+        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)
+
+            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()
 
-        for curmodel in self.iterator_over_objects(draw_type.RES2D):
-            curmodel: Wolfresults_2D
-            curmodel.step_interval_results = 1
+                    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())
 
-    def get_canvas_as_image(self) -> Image.Image:
-        """
-        Récupère la fenêtre OpenGL sous forme d'image
-        """
+                    # objet wx exportable via le clipboard
+                    dataobj = wx.BitmapDataObject()
+                    dataobj.SetBitmap(wxbitmap)
 
-        self.Paint()
+                    wx.TheClipboard.SetData(dataobj)
+                    wx.TheClipboard.Close()
 
-        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)
+                    return myimage
 
-            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
 
@@ -3601,6 +3653,7 @@ class WolfMapViewer(wx.Frame):
         :param ds: Ticks interval
         """
 
+        # FIXME : SHOULD BE MERGEd WITH copy_canvasogl
         fn = str(fn)
 
         if fn == '':
@@ -3616,19 +3669,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.:
@@ -3646,69 +3687,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)
+
+                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_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)
+                    #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)))
 
-                ax.set_xlabel('X [m]')
-                ax.set_ylabel('Y [m]')
+                    imnew = Image.new('RGB',(im.size[0]+impal.size[0], im.size[1]), (255,255,255))
 
-                if self.palette_for_copy.values is not None:
-                    self.palette_for_copy.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:
-                    axes[1].clear()
-                    axes[1].axis('off')
+                    imnew = Image.new('RGB', (im.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))
+                    im=imnew
 
-                # self.Paint()
-
-                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
@@ -4828,195 +4870,201 @@ class WolfMapViewer(wx.Frame):
         A compléter...
 
         """
+        curdir = Path(os.getcwd())
+
         myproject = Wolf_Param(None, filename=fn, toShow=False)
 
         mykeys = ['cross_sections', 'vector', 'array']
 
-        with wx.lib.busy.BusyInfo(_('Opening project')):
-            wait = wx.BusyCursor()
-            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])))
-
-                    self.set_compare(ListCompare)
-                    return
+        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])))
 
-            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)
-
-                        self.add_object('cross_sections', newobj=mycs, id=curid)
+                self.set_compare(ListCompare)
+                return
 
+        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)
 
-            if myproject.get_group('tiles') is not None:
+                    self.add_object('cross_sections', newobj=mycs, id=curid)
 
-                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')
 
-                if exists(curfile):
-                    mytiles = Tiles(filename= curfile, parent=self, linked_data_dir=curdatadir)
-                    mytiles.set_comp_dir(curcompdir)
-                    self.add_object('tiles', newobj=mytiles, id=curid)
-                else:
-                    logging.info(_('Bad parameter in project file - tiles : ')+ curfile)
+        if myproject.get_group('tiles') is not None:
 
-            if myproject.get_group('laz_grid') is not None:
+            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')
 
-                curdatadir = myproject.get_param('laz_grid', 'data_dir')
+            if exists(curfile):
+                mytiles = Tiles(filename= curfile, parent=self, linked_data_dir=curdatadir)
+                mytiles.set_comp_dir(curcompdir)
+                self.add_object('tiles', newobj=mytiles, id=curid)
+            else:
+                logging.info(_('Bad parameter in project file - tiles : ')+ curfile)
 
-                self.init_laz_from_gridinfos(curdatadir)
+        if myproject.get_group('laz_grid') is not None:
 
-            if 'vector' in myproject.myparams.keys():
-                for curid, curname in zip(myproject.myparams['vector'].keys(), myproject.myparams['vector'].values()):
-                    if exists(curname[key_Param.VALUE]):
-                        myvec = Zones(curname[key_Param.VALUE], parent=self, mapviewer = self)
-                        self.add_object('vector', newobj=myvec, id=curid)
-                    else:
-                        logging.info(_('Bad parameter in project file - vector : ')+ curname[key_Param.VALUE])
+            curdatadir = myproject.get_param('laz_grid', 'data_dir')
 
-            if 'array' in myproject.myparams.keys():
-                for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
+            self.init_laz_from_gridinfos(curdatadir)
 
-                    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])
+        if 'vector' in myproject.myparams.keys():
+            for curid, curname in zip(myproject.myparams['vector'].keys(), myproject.myparams['vector'].values()):
+                if exists(curname[key_Param.VALUE]):
+                    myvec = Zones(curname[key_Param.VALUE], parent=self, mapviewer = self)
+                    self.add_object('vector', newobj=myvec, id=curid)
+                else:
+                    logging.info(_('Bad parameter in project file - vector : ')+ curname[key_Param.VALUE])
 
-            if '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])
+        if 'array' in myproject.myparams.keys():
+            for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
 
-            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])
+                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])
 
-                self.menu_wolf2d()
+        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])
 
-            if 'gpu2d' in myproject.myparams.keys():
-                for curid, curname in zip(myproject.myparams['gpu2d'].keys(), myproject.myparams['gpu2d'].values()):
-                    if exists(curname[key_Param.VALUE]):
+        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])
 
-                        if 'simul_gpu_results' in curname[key_Param.VALUE]:
-                            curwolf = wolfres2DGPU(Path(curname[key_Param.VALUE]), mapviewer=self)
-                        else:
-                            if exists(join(curname[key_Param.VALUE], 'simul_gpu_results')):
-                                curwolf = wolfres2DGPU(Path(join(curname[key_Param.VALUE], 'simul_gpu_results')), mapviewer=self)
-                            else:
-                                logging.info(_('Bad directory : ')+ curname[key_Param.VALUE])
+            self.menu_wolf2d()
 
-                        self.add_object('res2d', newobj=curwolf, id=curid)
-                    else:
-                        logging.info(_('Bad directory : ')+ curname[key_Param.VALUE])
+        if 'gpu2d' in myproject.myparams.keys():
 
-                self.menu_wolf2d()
-                self.menu_2dgpu()
+            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)
 
-            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
+            for curid, curname in zip(myproject.myparams['gpu2d'].keys(), myproject.myparams['gpu2d'].values()):
+                if exists(curname[key_Param.VALUE]):
 
-                        self.project_pal[curid] = mypal
+                    if 'simul_gpu_results' in curname[key_Param.VALUE]:
+                        curwolf = wolfres2DGPU(curdir / Path(curname[key_Param.VALUE]), mapviewer=self)
                     else:
-                        logging.info(_('Bad parameter in project file - palette : ')+ curname[key_Param.VALUE])
-
-            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)
-
-            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]
+                        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])
 
-                    for curzones in self.iterator_over_objects(draw_type.VECTORS):
-                        curzones: Zones
-                        if curzones.idx == idx:
-                            self.active_cs.link_external_zones(curzones)
+                    self.add_object('res2d', newobj=curwolf, id=curid)
+                else:
+                    logging.info(_('Bad directory : ')+ curname[key_Param.VALUE])
 
-                    zonename = ''
-                    vecname = ''
+                pgbar.Update(pgbar.GetValue() + 1)
 
-                    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]
+            pgbar.Destroy()
 
-                    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]
+            self.menu_wolf2d()
+            self.menu_2dgpu()
 
-                        if curvec is not None:
-                            curvec: vector
-                            self.active_cs.sort_along(curvec.asshapely_ls(), curvec.myname, False)
+        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
 
-            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()):
+                    self.project_pal[curid] = mypal
+                else:
+                    logging.info(_('Bad parameter in project file - palette : ')+ curname[key_Param.VALUE])
 
-                    locvec = None
-                    locarray = None
-                    for curvec in self.myvectors:
-                        if curvec.idx == curname[key_Param.VALUE].lower():
-                            locvec=curvec
-                            break
+        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)
+
+        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]
+
+                for curzones in self.iterator_over_objects(draw_type.VECTORS):
+                    curzones: Zones
+                    if curzones.idx == idx:
+                        self.active_cs.link_external_zones(curzones)
+
+                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
 
-                    for curarray in self.myarrays:
-                        if curarray.idx == curid.lower():
-                            locarray=curarray
-                            break
+                for curarray in self.myarrays:
+                    if curarray.idx == curid.lower():
+                        locarray=curarray
+                        break
 
-                    if locvec is not None and locarray is not None:
+                if locvec is not None and locarray is not None:
 
-                        locarray.linkedvec = locvec.myzones[0].myvectors[0]
+                    locarray.linkedvec = locvec.myzones[0].myvectors[0]
 
-                    else:
+                else:
 
-                        logging.warning(_('Bad vec-array association in project file !'))
-                        logging.warning(curid)
-                        logging.warning(curname[key_Param.VALUE])
-            del wait
+                    logging.warning(_('Bad vec-array association in project file !'))
+                    logging.warning(curid)
+                    logging.warning(curname[key_Param.VALUE])
 
     def save_project(self, fn):
         myproject = Wolf_Param(None, toShow=False)
@@ -5598,7 +5646,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)))
 
@@ -5606,6 +5656,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()
@@ -5765,8 +5819,10 @@ class WolfMapViewer(wx.Frame):
                 filename = file.GetPath()
                 file.Destroy()
 
+            old_dir = os.getcwd()
             os.chdir(os.path.dirname(filename))
             self.read_project(filename)
+            os.chdir(old_dir)
 
         elif itemlabel == _('Shortcuts'):
             # show shortcuts in log
@@ -6568,8 +6624,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'):
 
@@ -7477,6 +7546,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
 
@@ -7492,6 +7599,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:
@@ -7581,7 +7691,7 @@ class WolfMapViewer(wx.Frame):
         filterjson = "json (*.json)|*.json|all (*.*)|*.*"
         filterall = "all (*.*)|*.*"
         filterres2d = "all (*.*)|*.*"
-        filterVector = "vec (*.vec)|*.vec|vecz (*.vecz)|*.vecz|dxf (*.dxf)|*.dxf|shp (*.shp)|*.shp|all (*.*)|*.*"
+        filterVector = "All supported formats|*.vec;*.vecz;*.dxf;*.shp|vec (*.vec)|*.vec|vecz (*.vecz)|*.vecz|dxf (*.dxf)|*.dxf|shp (*.shp)|*.shp|all (*.*)|*.*"
         filterCloud = "xyz (*.xyz)|*.xyz|dxf (*.dxf)|*.dxf|text (*.txt)|*.txt|shp (*.shp)|*.shp|all (*.*)|*.*"
         filtertri = "tri (*.tri)|*.tri|text (*.txt)|*.txt|dxf (*.dxf)|*.dxf|gltf (*.gltf)|*.gltf|gltf binary (*.glb)|*.glb|*.*'all (*.*)|*.*"
         filterCs = "vecz WOLF (*.vecz)|*.vecz|txt 2022 (*.txt)|*.txt|WOLF (*.sxy)|*.sxy|text 2000 (*.txt)|*.txt|all (*.*)|*.*"
@@ -7824,8 +7934,13 @@ class WolfMapViewer(wx.Frame):
                     wait = wx.BusyCursor()
                     newobj = Bridges(filename, mapviewer=self)
                     del wait
+
             self.myvectors.append(newobj)
 
+            self.active_bridges = newobj
+
+            self.menu_bridges()
+
         elif which.lower() == 'weirs':
             curdict = self.myvectors
             curtree = self.myitemsvector
@@ -7837,6 +7952,10 @@ class WolfMapViewer(wx.Frame):
                     del wait
             self.myvectors.append(newobj)
 
+            self.active_weirs = newobj
+
+            self.menu_weirs()
+
         elif which.lower() in ['tiles', 'tilescomp']:
             curdict = self.mytiles
             curtree = self.myitemsvector
@@ -8622,6 +8741,8 @@ class WolfMapViewer(wx.Frame):
                     self.selected_object.write_all()
                 elif type(self.selected_object) is Zones:
                     self.selected_object.saveas()
+                elif type(self.selected_object) in [Bridge, Weir]:
+                    self.selected_object.saveas()
                 elif type(self.selected_object) is Triangulation:
                     self.selected_object.saveas()
                 elif isinstance(self.selected_object, Particle_system):
@@ -8742,7 +8863,7 @@ class WolfMapViewer(wx.Frame):
 
                         self.selected_object.write_all()
                     fdlg.Destroy()
-                elif type(self.selected_object) is Zones:
+                elif type(self.selected_object) in [Zones, Bridge, Weir]:
                     filterArray = "vec (*.vec)|*.vec|vecz (*.vecz)|*.vecz|Shapefile (*.shp)|*.shp|all (*.*)|*.*"
                     fdlg = wx.FileDialog(self, "Choose file name for Vector :" + self.selected_object.idx, wildcard=filterArray,
                                          style=wx.FD_SAVE)
@@ -8772,8 +8893,9 @@ class WolfMapViewer(wx.Frame):
         elif text == _('Properties'):
 
             myobj = self.selected_object
-            if type(myobj) in [WolfArray, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU, Particle_system, Picc_data, Cadaster_data, hydrometry_wolfgui]:
+            if type(myobj) in [WolfArray, WolfArrayMB, WolfArrayMNAP, Zones, Wolfresults_2D, wolfres2DGPU, Particle_system, Picc_data, Cadaster_data, hydrometry_wolfgui, Bridge, Weir]:
                 myobj.show_properties()
+
             elif isinstance(myobj, cloud_vertices):
                 myobj.show_properties()
 
@@ -8820,6 +8942,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):
@@ -8854,9 +8994,33 @@ 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):
+            if isinstance(self.selected_object, Zones | Bridge | Weir):
                 filterArray = "Shapefile (*.shp)|*.shp"
                 fdlg = wx.FileDialog(self, "Choose file name for Zones :" + self.selected_object.idx, wildcard=filterArray,
                                         style=wx.FD_SAVE)
@@ -8867,7 +9031,7 @@ class WolfMapViewer(wx.Frame):
 
         elif _('Export active zone to Shape file') in text:
 
-            if isinstance(self.selected_object, Zones):
+            if isinstance(self.selected_object, Zones | Bridge | Weir):
 
                 filterArray = "Shapefile (*.shp)|*.shp"
                 fdlg = wx.FileDialog(self, "Choose file name for Vector :" + self.selected_object.idx, wildcard=filterArray,
@@ -9094,12 +9258,12 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No triangles selected -- Please select a triangulation first !'))
                 return
 
-            if self.active_tri._start_move is None:
-                self.active_tri._start_move = (x, y)
+            if self.active_tri._move_start is None:
+                self.active_tri._move_start = (x, y)
                 return
 
-            delta_x = x - self.active_tri._start_move[0]
-            delta_y = y - self.active_tri._start_move[1]
+            delta_x = x - self.active_tri._move_start[0]
+            delta_y = y - self.active_tri._move_start[1]
 
             if shiftdown:
                 delta_y = 0.
@@ -9109,7 +9273,7 @@ class WolfMapViewer(wx.Frame):
 
             self.active_tri.move(delta_x, delta_y)
             self.active_tri.reset_plot()
-            self.active_tri._start_move = None
+            self.active_tri._move_start = None
             self.active_tri.clear_cache()
             self.end_action(_('End move triangulation'))
 
@@ -9149,6 +9313,12 @@ class WolfMapViewer(wx.Frame):
                 self.active_landmap.load_texture(x,y, which='low')
             self.Refresh()
 
+        elif self.action == 'pick bridge':
+            self.pick_bridge(x, y)
+
+        elif self.action == 'pick weir':
+            self.pick_weir(x, y)
+
         elif self.action == 'bridge gltf':
             # Create a bridge in gltf format
 
@@ -9356,12 +9526,12 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No vector selected -- Please select a vector first !'))
                 return
 
-            if self.active_vector._start_move is None:
-                self.active_vector._start_move = (x, y)
+            if self.active_vector._move_start is None:
+                self.active_vector._move_start = (x, y)
                 return
 
-            delta_x = x - self.active_vector._start_move[0]
-            delta_y = y - self.active_vector._start_move[1]
+            delta_x = x - self.active_vector._move_start[0]
+            delta_y = y - self.active_vector._move_start[1]
 
             if shiftdown:
                 delta_y = 0.
@@ -9400,8 +9570,8 @@ class WolfMapViewer(wx.Frame):
                 logging.warning(_('No zone selected -- Please select a zone first !'))
                 return
 
-            if self.active_zone._start_move is None:
-                self.active_zone._start_move = (x, y)
+            if self.active_zone._move_start is None:
+                self.active_zone._move_start = (x, y)
                 return
 
             if shiftdown:
@@ -9410,7 +9580,7 @@ class WolfMapViewer(wx.Frame):
             if alt:
                 delta_x = 0.
 
-            self.active_zone.move(x - self.active_zone._start_move[0], y - self.active_zone._start_move[1])
+            self.active_zone.move(x - self.active_zone._move_start[0], y - self.active_zone._move_start[1])
             self.active_zone.clear_cache()
             self.end_action(_('End move zone'))
 
@@ -9657,6 +9827,18 @@ class WolfMapViewer(wx.Frame):
             if ctrl:
                 myobj.show_properties()
 
+        elif type(myobj) == Bridge:
+            self.active_bridge = myobj
+
+            if ctrl:
+                myobj.show_properties()
+
+        elif type(myobj) == Weir:
+            self.active_weir = myobj
+
+            if ctrl:
+                myobj.show_properties()
+
         elif isinstance(myobj, PlansTerrier):
             self.active_landmap = myobj
 
@@ -10131,10 +10313,10 @@ class WolfMapViewer(wx.Frame):
 
             if self.action == 'move vector':
                 if self.active_vector is not None:
-                    if self.active_vector._start_move is not None:
+                    if self.active_vector._move_start is not None:
 
-                        delta_x = x - self.active_vector._start_move[0]
-                        delta_y = y - self.active_vector._start_move[1]
+                        delta_x = x - self.active_vector._move_start[0]
+                        delta_y = y - self.active_vector._move_start[1]
 
                         if shiftdown:
                             delta_y = 0.
@@ -10146,10 +10328,10 @@ class WolfMapViewer(wx.Frame):
 
             if self.action == 'move triangles':
                 if self.active_tri is not None:
-                    if self.active_tri._start_move is not None:
+                    if self.active_tri._move_start is not None:
 
-                        delta_x = x - self.active_tri._start_move[0]
-                        delta_y = y - self.active_tri._start_move[1]
+                        delta_x = x - self.active_tri._move_start[0]
+                        delta_y = y - self.active_tri._move_start[1]
 
                         if shiftdown:
                             delta_y = 0.
@@ -10174,9 +10356,9 @@ class WolfMapViewer(wx.Frame):
 
             if self.action == 'move zone':
                 if self.active_zone is not None:
-                    if self.active_zone._start_move is not None:
-                        delta_x = x - self.active_zone._start_move[0]
-                        delta_y = y - self.active_zone._start_move[1]
+                    if self.active_zone._move_start is not None:
+                        delta_x = x - self.active_zone._move_start[0]
+                        delta_y = y - self.active_zone._move_start[1]
 
                         if shiftdown:
                             delta_y = 0.
@@ -10532,6 +10714,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']
 
@@ -10563,7 +10747,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'),
@@ -10827,7 +11012,7 @@ class WolfMapViewer(wx.Frame):
                     newarray.nullify_border(width=1)
 
                     #keys for arrays
-                    keys = self.get_list_keys(draw_type.ARRAYS, checked_state=False)
+                    keys = self.get_list_keys(draw_type.ARRAYS, checked_state=None)
                     new_key = self.active_array.idx + '_crop'
 
                     while new_key in keys:
@@ -10884,12 +11069,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'))
@@ -10942,7 +11135,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 !'),
@@ -11316,9 +11546,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()
@@ -11345,6 +11577,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):
@@ -11354,8 +11587,9 @@ 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):
+            if isinstance(self.selected_object, Zones | Bridge | Weir):
                 self.popupmenu.Append(wx.ID_ANY, _('Export to Shape file'), _('Export to Shape file'))
                 self.popupmenu.Append(wx.ID_ANY, _('Export active zone to Shape file'), _('Export active zone to Shape file'))
 
@@ -11808,6 +12042,117 @@ class WolfMapViewer(wx.Frame):
             self.zoom_on(zoom)
 
 
+    def menu_bridges(self):
+
+        if self.menu_bridge is None:
+            self.menu_bridge = wx.Menu()
+            self.menubar.Append(self.menu_bridge, _('&Bridges'))
+
+            self._menu_add_bridge = self.menu_bridge.Append(wx.ID_ANY, _('New bridge'), _('Add a new bridge to the active collection...'))
+            self._menu_find_bridge = self.menu_bridge.Append(wx.ID_ANY, _('Pick bridge'), _("Pick the mouse's nearest bridge"))
+            self._menu_edit_bridge = self.menu_bridge.Append(wx.ID_ANY, _('Edit bridge'), _('Edit the active bridge'))
+
+            self.Bind(wx.EVT_MENU, self.OnAddBridge, self._menu_add_bridge)
+            self.Bind(wx.EVT_MENU, self.OnEditBridge, self._menu_edit_bridge)
+            self.Bind(wx.EVT_MENU, self.OnFindBridge, self._menu_find_bridge)
+
+    def OnAddBridge(self, e):
+        """ Add a bridge """
+
+        if self.active_bridges is None:
+            logging.warning(_('No bridge collection !'))
+            return
+
+        newid = wx.TextEntryDialog(None, _('Enter the new bridge id'), _('New bridge id'), 'bridge')
+        if newid.ShowModal() == wx.ID_OK:
+
+            newid = newid.GetValue()
+            while newid in self.get_list_keys(drawing_type=draw_type.VECTORS):
+                newid = newid + '_'
+
+            newbridge = self.active_bridges.addnew(newid)
+            self.add_object('vector', newobj=newbridge, id=newid)
+
+    def OnEditBridge(self, e):
+        """ Edit a bridge """
+
+        if self.active_bridge is None:
+            logging.warning(_('No active bridge to edit !'))
+            return
+
+        keys = self.get_list_keys(drawing_type=draw_type.VECTORS)
+
+        newid = self.active_bridge.idx
+        while newid in keys:
+            newid = newid + '_'
+
+        self.add_object('vector', newobj=self.active_bridge, id= newid)
+
+    def OnFindBridge(self, e):
+        """ Find the nearest bridge """
+
+        self.start_action('Pick bridge', _('Right click to pick the nearest bridge'))
+
+    def pick_bridge(self, x:float, y:float):
+        """ Find the nearest bridge """
+
+        if self.active_bridges is None:
+            logging.warning(_('No bridges to pick !'))
+            return
+
+        self.active_bridge = self.active_bridges.find_nearest(x,y)
+
+    def menu_weirs(self):
+
+        if self.menu_weir is None:
+            self.menu_weir = wx.Menu()
+            self.menubar.Append(self.menu_weir, _('&Weirs'))
+
+            self._menu_add_weir = self.menu_weir.Append(wx.ID_ANY, _('New weir'), _('Add a new weir to the active collection'))
+            self._menu_find_weir = self.menu_weir.Append(wx.ID_ANY, _('Pick weir'), _("Pick the mouse's nearest weir"))
+            self._menu_edit_weir = self.menu_weir.Append(wx.ID_ANY, _('Edit weir'), _('Edit the active weir'))
+
+            self.Bind(wx.EVT_MENU, self.OnAddWeir, self._menu_add_weir)
+            self.Bind(wx.EVT_MENU, self.OnEditWeir, self._menu_edit_weir)
+            self.Bind(wx.EVT_MENU, self.OnFindWeir, self._menu_find_weir)
+
+    def OnAddWeir(self, e):
+        """ Add a weir """
+
+        logging.info(_('!! To be implemented !!'))
+        pass
+
+    def OnEditWeir(self, e):
+        """ Edit a weir """
+
+        if self.active_weir is None:
+            logging.warning(_('No active weir to edit !'))
+            return
+
+        keys = self.get_list_keys(drawing_type=draw_type.VECTORS)
+
+        newid = self.active_weir.idx
+        while newid in keys:
+            newid = newid + '_'
+
+        self.add_object('vector', newobj=self.active_weir, id= newid)
+
+    def OnFindWeir(self, e):
+        """ Find the nearest weir """
+
+        self.start_action('Pick weir', _('Right click to pick the nearest weir'))
+
+    def pick_weir(self, x:float, y:float):
+        """ Find the nearest weir """
+
+        if self.active_weirs is None:
+            logging.warning(_('No weirs to pick !'))
+            return
+
+        self.active_weir = self.active_weirs.find_nearest(x,y)
+
+
+
 class Comp_Type(Enum):
     ARRAYS = 1
     ARRAYS_MB = 2
@@ -11852,6 +12197,21 @@ class Compare_Arrays_Results():
 
             return Comp_Type.RES2D, file
 
+        elif file.suffix in ('.bin', '.tif', '.tiff', '.npy', '.npz', '.top', '.frott', '.nap', '.hbin', '.hbinb', '.qxbin', '.qxbinb', '.qybin', '.qybinb', '.inf') :
+
+            if file.suffix in ('.bin', '.top', '.frott', '.nap', '.hbin', '.hbinb', '.qxbin', '.qxbinb', '.qybin', '.qybinb', '.inf'):
+                if file.with_suffix(file.suffix + '.txt').exists():
+
+                    test = WolfArray(file, preload=False)
+                    test.read_txt_header()
+
+                    mb = test.nb_blocks > 0
+
+                    if mb:
+                        return Comp_Type.ARRAYS_MB, file
+
+            return Comp_Type.ARRAYS, file
+
         elif (file.parent / 'simul_gpu_results').exists():
             file = file.parent / 'simul_gpu_results'
             return Comp_Type.RES2D_GPU, file
@@ -11859,24 +12219,8 @@ class Compare_Arrays_Results():
         elif (file.parent.parent / 'simul_gpu_results').exists():
             file = file.parent.parent / 'simul_gpu_results'
             return Comp_Type.RES2D_GPU, file
-
         else:
-            if file.suffix in ('.bin', '.tif', '.tiff', '.npy', '.npz', '.top', '.frott', '.nap', '.hbin', '.hbinb', '.qxbin', '.qxbinb', '.qybin', '.qybinb', '.inf') :
-
-                if file.suffix in ('.bin', '.top', '.frott', '.nap', '.hbin', '.hbinb', '.qxbin', '.qxbinb', '.qybin', '.qybinb', '.inf'):
-                    if file.with_suffix(file.suffix + '.txt').exists():
-
-                        test = WolfArray(file, preload=False)
-                        test.read_txt_header()
-
-                        mb = test.nb_blocks > 0
-
-                        if mb:
-                            return Comp_Type.ARRAYS_MB, file
-
-                return Comp_Type.ARRAYS, file
-            else:
-                return None, None
+            return None, None
 
     def add(self, file_or_dir:Union[str, Path] = None):