wolfhece 2.1.114__py3-none-any.whl → 2.1.115__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
@@ -3321,6 +3337,8 @@ class WolfMapViewer(wx.Frame):
                     wx.TheClipboard.SetData(dataobj)
                     wx.TheClipboard.Close()
 
+                    fig.set_visible(False)
+
                     buf.close()
 
                     return fig, ax, im
@@ -4828,195 +4846,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.set_compare(ListCompare)
+                return
 
-                        self.add_object('cross_sections', newobj=mycs, id=curid)
+        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)
 
-            if myproject.get_group('tiles') 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')
+        if myproject.get_group('tiles') is not None:
 
-                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)
+            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 myproject.get_group('laz_grid') is not None:
+            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)
 
-                curdatadir = myproject.get_param('laz_grid', 'data_dir')
+        if myproject.get_group('laz_grid') is not None:
 
-                self.init_laz_from_gridinfos(curdatadir)
+            curdatadir = myproject.get_param('laz_grid', 'data_dir')
 
-            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])
+            self.init_laz_from_gridinfos(curdatadir)
 
-            if 'array' in myproject.myparams.keys():
-                for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
+        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 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 'array' in myproject.myparams.keys():
+            for curid, curname in zip(myproject.myparams['array'].keys(), myproject.myparams['array'].values()):
 
-            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 '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)
@@ -5765,8 +5789,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
@@ -7581,7 +7607,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 +7850,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 +7868,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 +8657,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 +8779,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 +8809,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()
 
@@ -8856,7 +8894,7 @@ class WolfMapViewer(wx.Frame):
 
         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 +8905,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 +9132,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 +9147,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 +9187,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 +9400,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 +9444,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 +9454,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 +9701,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 +10187,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 +10202,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 +10230,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.
@@ -10827,7 +10883,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:
@@ -11355,7 +11411,7 @@ class WolfMapViewer(wx.Frame):
                 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'))
 
-            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 +11864,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 +12019,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 +12041,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):