wolfhece 2.2.28__py3-none-any.whl → 2.2.30__py3-none-any.whl

wolfhece/PyConfig.py

@@ -35,6 +35,8 @@ class ConfigurationKeys(Enum):
     DIRECTORY_DEM = "Default DEM directory"
     DIRECTORY_DTM = "Default DTM directory"
     DIRECTORY_LAZ = "Default LAZ directory"
+    ACTIVE_VECTOR_COLOR = "Active vector color"
+    ACTIVE_VECTOR_SIZE_SQUARE = "Active vector square size"
 
 class WolfConfiguration:
     """ Holds the PyWolf configuration """
@@ -82,7 +84,9 @@ class WolfConfiguration:
             ConfigurationKeys.TICKS_FONTSIZE.value: 12,
             ConfigurationKeys.DIRECTORY_DEM.value: "",
             ConfigurationKeys.DIRECTORY_DTM.value: "",
-            ConfigurationKeys.DIRECTORY_LAZ.value: ""
+            ConfigurationKeys.DIRECTORY_LAZ.value: "",
+            ConfigurationKeys.ACTIVE_VECTOR_COLOR.value: [0, 0, 0, 255],
+            ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE.value: 5
 
         }
         self._types = {
@@ -98,7 +102,9 @@ class WolfConfiguration:
             ConfigurationKeys.TICKS_FONTSIZE.value: int,
             ConfigurationKeys.DIRECTORY_DEM.value: str,
             ConfigurationKeys.DIRECTORY_DTM.value: str,
-            ConfigurationKeys.DIRECTORY_LAZ.value: str
+            ConfigurationKeys.DIRECTORY_LAZ.value: str,
+            ConfigurationKeys.ACTIVE_VECTOR_COLOR.value: list,
+            ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE.value: int
         }
 
         self._check_config()
@@ -145,7 +151,7 @@ class GlobalOptionsDialog(wx.Dialog):
         super(GlobalOptionsDialog, self).__init__(*args, **kw)
 
         self.InitUI()
-        self.SetSize((600, 500))
+        self.SetSize((600, 550))
         self.SetTitle(_("Global options"))
 
     def push_configuration(self, configuration):
@@ -161,6 +167,8 @@ class GlobalOptionsDialog(wx.Dialog):
         self.cfg_directory_dem.SetValue(str(configuration[ConfigurationKeys.DIRECTORY_DEM]))
         self.cfg_directory_dtm.SetValue(str(configuration[ConfigurationKeys.DIRECTORY_DTM]))
         self.cfg_directory_laz.SetValue(str(configuration[ConfigurationKeys.DIRECTORY_LAZ]))
+        self.cfg_vector_color.SetColour(configuration[ConfigurationKeys.ACTIVE_VECTOR_COLOR])
+        self.cfg_square_size.SetValue(str(configuration[ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE]))
 
     def pull_configuration(self, configuration):
         configuration[ConfigurationKeys.PLAY_WELCOME_SOUND] = self.cfg_welcome_voice.IsChecked()
@@ -175,6 +183,8 @@ class GlobalOptionsDialog(wx.Dialog):
         configuration[ConfigurationKeys.DIRECTORY_DEM] = str(self.cfg_directory_dem.Value)
         configuration[ConfigurationKeys.DIRECTORY_DTM] = str(self.cfg_directory_dtm.Value)
         configuration[ConfigurationKeys.DIRECTORY_LAZ] = str(self.cfg_directory_laz.Value)
+        configuration[ConfigurationKeys.ACTIVE_VECTOR_COLOR] = list(self.cfg_vector_color.GetColour())
+        configuration[ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE] = int(self.cfg_square_size.Value)
 
     def InitUI(self):
 
@@ -298,6 +308,20 @@ class GlobalOptionsDialog(wx.Dialog):
         sbs.Add(dir_dtm, 1, wx.EXPAND, 5)
         sbs.Add(dir_laz, 1, wx.EXPAND, 5)
 
+        # Vector color
+        color_vector = wx.BoxSizer(wx.HORIZONTAL)
+        self.label_vector_color = wx.StaticText(pnl, label=_('Default vector color'))
+        self.cfg_vector_color = wx.ColourPickerCtrl(pnl, colour=(0, 0, 0, 255))
+        self.cfg_vector_color.SetToolTip(_('Color for active vector in the viewer'))
+
+        self.cfg_square_size = wx.TextCtrl(pnl, value='5', style=wx.TE_CENTRE)
+        self.cfg_square_size.SetToolTip(_('Size of the square for active vector in the viewer'))
+
+        color_vector.Add(self.label_vector_color, 1, wx.EXPAND, 2)
+        color_vector.Add(self.cfg_vector_color, 1, wx.EXPAND, 5)
+        color_vector.Add(self.cfg_square_size, 1, wx.EXPAND, 5)
+        sbs.Add(color_vector, 1, wx.EXPAND, 5)
+
         pnl.SetSizer(sbs)
         pnl.Layout()
 

wolfhece/PyCrosssections.py

@@ -1759,8 +1759,9 @@ class crosssections(Element_To_Draw):
                 f=open(myfile,'r')
                 lines=f.read().splitlines()
                 f.close()
-            else:
-                lines=[]
+        # For other formats (e.g.  vecz)
+        else:
+            lines=[]
 
         self.myprofiles={}
         self.mygenprofiles={}
@@ -1880,36 +1881,6 @@ class crosssections(Element_To_Draw):
                             logging.debug(name)
 
                     nameprev=name
-            elif format=='vecz' or format=='zones':
-
-                if isinstance(myfile, Zones):
-                    self.filename=myfile.filename
-                    tmpzones=myfile
-                elif isinstance(myfile, str):
-                    self.filename=myfile
-                    tmpzones=Zones(myfile, find_minmax=False)
-
-                curzone:zone
-                curvec:vector
-                curzone=tmpzones.myzones[0]
-                index=0
-                for curvec in curzone.myvectors:
-
-                    self.myprofiles[curvec.myname]={}
-                    curdict=self.myprofiles[curvec.myname]
-
-                    curdict['index']=index
-                    curdict['left']=None
-                    curdict['bed']=None
-                    curdict['right']=None
-
-                    index+=1
-                    curdict['cs']=profile(name=curvec.myname,parent=self)
-                    cursect:profile
-                    cursect=curdict['cs']
-
-                    cursect.myvertices = curvec.myvertices
-
             elif format=='sxy':
                 self.format='sxy'
                 nbpotsect = int(lines[0])
@@ -1982,6 +1953,38 @@ class crosssections(Element_To_Draw):
                         cursect.bankright=wolfvertex(rbs,rbz)
                         curdict['right']=cursect.bankright
 
+        # To make a distinction between cases for vecz
+        elif len(lines)==0:
+            if format=='vecz' or format=='zones':
+
+                if isinstance(myfile, Zones):
+                    self.filename=myfile.filename
+                    tmpzones=myfile
+                elif isinstance(myfile, str):
+                    self.filename=myfile
+                    tmpzones=Zones(myfile, find_minmax=False)
+
+                curzone:zone
+                curvec:vector
+                curzone=tmpzones.myzones[0]
+                index=0
+                for curvec in curzone.myvectors:
+
+                    self.myprofiles[curvec.myname]={}
+                    curdict=self.myprofiles[curvec.myname]
+
+                    curdict['index']=index
+                    curdict['left']=None
+                    curdict['bed']=None
+                    curdict['right']=None
+
+                    index+=1
+                    curdict['cs']=profile(name=curvec.myname,parent=self)
+                    cursect:profile
+                    cursect=curdict['cs']
+
+                    cursect.myvertices = curvec.myvertices
+
         self.verif_bed()
         self.find_minmax(True)
         self.init_cloud()
@@ -2506,7 +2509,7 @@ class crosssections(Element_To_Draw):
             self.xmax = 0
             self.ymax = 0
             return
-
+        
         if update:
             for idx,vect in self.myprofiles.items():
                 vect['cs'].find_minmax(only_firstlast = True)

wolfhece/PyDraw.py

@@ -76,7 +76,7 @@ try:
     from .PyPalette import wolfpalette
     from .wolfresults_2D import Wolfresults_2D, views_2D, Extractable_results
     from .PyTranslate import _
-    from .PyVertex import cloud_vertices, getIfromRGB
+    from .PyVertex import cloud_vertices, getIfromRGB, getRGBfromI
     from .RatingCurve import SPWMIGaugingStations, SPWDCENNGaugingStations
     from .wolf_array import WOLF_ARRAY_MB, SelectionData, WolfArray, WolfArrayMB, CropDialog, header_wolf, WolfArrayMNAP, WOLF_ARRAY_FULL_SINGLE, WOLF_ARRAY_FULL_INTEGER8, WOLF_ARRAY_FULL_INTEGER16, WOLF_ARRAY_FULL_DOUBLE, WOLF_ARRAY_FULL_INTEGER
     from .PyParams import Wolf_Param, key_Param, Type_Param
@@ -2306,10 +2306,15 @@ class WolfMapViewer(wx.Frame):
 
         self.analyzesimsheet.Append(wx.ID_ANY, _("Active simulation..."), _("Generate a summary PDF report for the active simulation"))
         self.analyzesimsheet.Append(wx.ID_ANY, _("All checked simulations..."), _("Generate a summary PDF report for all checked simulations"))
+        self.analyzesimsheet.AppendSeparator()
+        self.analyzesimsheet.Append(wx.ID_ANY, _("One simulation from disk..."), _("Generate a summary PDF report for one simulation"))
         self.analyzesimsheet.Append(wx.ID_ANY, _("All simulations in directory..."), _("Generate a summary PDF report for all simulations in the current directory"))
         self.analyzesimsheet.AppendSeparator()
         self.analyzesimsheet.Append(wx.ID_ANY, _("Compare checked simulations..."), _("Generate a summary PDF report for all the loaded simulations"))
         self.analyzesimsheet.Append(wx.ID_ANY, _("Compare all simulations in a directory..."), _("Generate a summary PDF report for all the simulations in a directory"))
+        self.analyzesimsheet.AppendSeparator()
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Compare arrays..."), _("Generate a summary PDF report for two loaded arrays"))
+        self.analyzesimsheet.Append(wx.ID_ANY, _("Compare arrays from files..."), _("Generate a summary PDF report for two arrays from files"))
 
 
         self.analyzeinpaint.Append(wx.ID_ANY, _("Inpaint active array..."), _("Inpaint active array"))
@@ -4194,6 +4199,24 @@ class WolfMapViewer(wx.Frame):
         else:
             return None
 
+    @property
+    def active_vector_color(self) -> list[int]:
+        """ Return the active vector color from configs """
+        config = self.get_configuration()
+        if config is None:
+            return [0, 0, 0, 255]  # Default black color
+        else:
+            return config[ConfigurationKeys.ACTIVE_VECTOR_COLOR]
+
+    @property
+    def active_vector_square_size(self) -> list[int]:
+        """ Return the active vector square size from configs """
+        config = self.get_configuration()
+        if config is None:
+            return 0
+        else:
+            return config[ConfigurationKeys.ACTIVE_VECTOR_SIZE_SQUARE]
+
     @property
     def default_dem(self) -> Path:
         """ Return the default DEM file from configs """
@@ -7710,6 +7733,78 @@ class WolfMapViewer(wx.Frame):
         self.menu_dike()
         autoscale = True
 
+    def _run_compare_arrays(self, dlg):
+        """ Run the comparison of two arrays"""
+
+        from .ui.wolf_multiselection_collapsiblepane import Wolf_CompareArrays_Selection
+
+        assert isinstance(dlg, Wolf_CompareArrays_Selection), 'Dialog must be a wx.Dialog instance'
+
+        dlg: Wolf_CompareArrays_Selection
+
+        vals = dlg.get_values()
+        id1 = vals[_('Reference array')][0]
+        id2 = vals[_('Comparison array')][0]
+        min_area = dlg.get_min_area()
+        threshold = dlg.get_threshold()
+        nb_patches = dlg.get_max_patches()
+
+        ref:WolfArray
+        comp:WolfArray
+        ref = self.get_obj_from_id(id1, draw_type.ARRAYS)
+        comp = self.get_obj_from_id(id2, draw_type.ARRAYS)
+
+        if ref is None or comp is None:
+            logging.warning(_('You must select two arrays to compare !'))
+            return
+
+        assert isinstance(ref, WolfArray), 'Reference object must be a WolfArray instance'
+        assert isinstance(comp, WolfArray), 'Comparison object must be a WolfArray instance'
+
+        if not ref.is_like(comp):
+            logging.error(_('The two arrays must have the same shape and type !'))
+            return
+
+        # if only 2 arrays, we can use the CompareArrays_wx directly
+        from .report.compare_arrays import CompareArrays_wx
+
+        try:
+            newsheet = CompareArrays_wx(ref, comp,
+                                        size=(800, 600),
+                                        ignored_patche_area= min_area,
+                                        threshold=threshold,
+                                        nb_max_patches = nb_patches,)
+            newsheet.Show()
+
+            self.add_object('vector', newobj = newsheet.get_zones(), ToCheck = True, id = 'compare_arrays_{}'.format(ref.idx + comp.idx))
+        except:
+            logging.error(_('Error in comparing arrays\n'))
+            dlg.Destroy()
+
+    def _compare_arrays(self):
+        """ Compare two arrays """
+        arrays = self.get_list_keys(draw_type.ARRAYS, checked_state = None)
+
+        if len(arrays) == 0:
+            logging.warning(_('No arrays to compare !'))
+            return
+        elif len(arrays) == 1:
+            logging.warning(_('Only one array to compare - Nothing to do !'))
+            return
+
+        from .ui.wolf_multiselection_collapsiblepane import Wolf_CompareArrays_Selection
+
+        dlg = Wolf_CompareArrays_Selection(parent = self,
+                                            title = _("Choose the arrays to compare"),
+                                            info = _("Select the reference and comparison arrays"),
+                                            values_dict = {_('Reference array'): arrays,
+                                                            _('Comparison array'): arrays},
+                                            callback= self._run_compare_arrays,
+                                            destroyOK = True,
+                                            styles = [wx.LB_SINGLE, wx.LB_SINGLE]
+                                            )
+        dlg.ShowModal()
+
     def OnMenubar(self, event: wx.MenuEvent):
         """
         Gestion des clicks sur le menu quel que soit le niveau
@@ -8354,6 +8449,29 @@ class WolfMapViewer(wx.Frame):
                 else:
                     logging.warning(_('Simulation {} is not a GPU simulation - Not yet implemented for CPU simulations !').format(curmodel.idx))
 
+        elif itemlabel == _("One simulation from disk..."):
+            dlg = wx.DirDialog(None, _('Choose the directory containing the simulation'), style=wx.DD_DEFAULT_STYLE)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+            directory = Path(dlg.GetPath())
+            dlg.Destroy()
+            if not directory.exists():
+                logging.error(_('Directory {} does not exist !').format(directory))
+                wx.MessageBox(_('Directory {} does not exist !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+            if not directory.is_dir():
+                logging.error(_('Path {} is not a directory !').format(directory))
+                wx.MessageBox(_('Path {} is not a directory !').format(directory), _('Error'), wx.OK | wx.ICON_ERROR)
+                return
+
+            from .report.simplesimgpu import SimpleSimGPU_Report_wx
+
+            # check if we want to show all wx reports
+            newsheet = SimpleSimGPU_Report_wx(directory, size=(800, 600), show=True)
+
+
         elif itemlabel == _("All simulations in directory..."):
             dlg = wx.DirDialog(None, _('Choose the directory containing the simulations'), style=wx.DD_DEFAULT_STYLE)
             ret = dlg.ShowModal()
@@ -8372,7 +8490,6 @@ class WolfMapViewer(wx.Frame):
                 return
             from .report.simplesimgpu import SimpleSimGPU_Reports_wx
 
-
             # check if we want to show all wx reports
             dlg = wx.MessageDialog(None, _('Do you want to show all reports ?'), _('Show all reports'), style=wx.YES_NO | wx.YES_DEFAULT)
             ret = dlg.ShowModal()
@@ -8380,6 +8497,50 @@ class WolfMapViewer(wx.Frame):
 
             newsheets = SimpleSimGPU_Reports_wx(directory, show = ret == wx.ID_YES, size=(800, 600))
 
+        elif itemlabel == _("Compare arrays..."):
+
+            self._compare_arrays()
+
+        elif itemlabel == _("Compare arrays from files..."):
+
+            from .report.compare_arrays import CompareArrays_wx
+
+            dlg = wx.FileDialog(None, _('Choose the reference file'), wildcard='*.tif, *.bin, *.npy|*.tif;*.bin;*.npy|all (*.*)|*.*', style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+            ref_filename = dlg.GetPath()
+            dlg.Destroy()
+
+            dlg = wx.FileDialog(None, _('Choose the comparison file'), wildcard='*.tif, *.bin, *.npy|*.tif;*.bin;*.npy|all (*.*)|*.*', style=wx.FD_OPEN | wx.FD_FILE_MUST_EXIST)
+            ret = dlg.ShowModal()
+            if ret == wx.ID_CANCEL:
+                dlg.Destroy()
+                return
+            comp_filename = dlg.GetPath()
+            dlg.Destroy()
+
+            try:
+                wa_ref = WolfArray(ref_filename)
+                wa_comp = WolfArray(comp_filename)
+
+                if not (wa_ref.loaded and wa_comp.loaded):
+                    logging.error(_('Error in loading arrays from files'))
+                    wx.MessageBox(_('Error in loading arrays from files'), _('Error'), wx.OK | wx.ICON_ERROR)
+                    return
+
+                if wa_ref.is_like(wa_comp):
+                    newsheet = CompareArrays_wx(wa_ref, wa_comp, size=(800, 600))
+                    newsheet.Show()
+                else:
+                    logging.error(_('The two arrays are not compatible - Cannot compare !'))
+                    wx.MessageBox(_('The two arrays are not compatible - Cannot compare !'), _('Error'), wx.OK | wx.ICON_ERROR)
+
+                logging.info(_('Arrays {} and {} compared successfully').format(ref_filename, comp_filename))
+            except Exception as e:
+                logging.error(_('Error in comparing arrays from files\n{}'.format(e)))
+
         elif itemlabel == _("Compare checked simulations..."):
 
             sims = self.get_list_keys(draw_type.RES2D, checked_state=True)
@@ -12380,6 +12541,7 @@ class WolfMapViewer(wx.Frame):
                     logging.warning(_('No array available and ctrl is pressed -- Please load a file or create data !'))
 
             self.active_vector.add_vertex(wolfvertex(x, y))
+            self.active_vertex = self.active_vector.myvertices[-1]
 
             self.active_vector.find_minmax()
             self.active_zone.find_minmax()
@@ -12488,6 +12650,7 @@ class WolfMapViewer(wx.Frame):
 
                 if ctrl:
                     if self.active_array is not None:
+                        # Get the value of the array at the position of the vertex
                         z = self.active_array.get_value(x, y)
                         self.active_vertex.z = z
                     else:
@@ -13276,6 +13439,8 @@ class WolfMapViewer(wx.Frame):
                self.action == 'insert vertices':
                 if self.active_vertex is not None:
                     if shiftdown:
+                        # Shift key is pressed
+                        # We move/Insert the vertex along the segment linking the first and last vertices of the active vector
                         ox = self.active_vector.myvertices[0].x
                         oy = self.active_vector.myvertices[0].y
 
@@ -13500,7 +13665,8 @@ class WolfMapViewer(wx.Frame):
 
         if self.action is not None:
             locaction = self.action
-            if 'select by tmp vector' in self.action or 'select by vector' in self.action:
+
+            if 'select by tmp vector' in locaction or 'select by vector' in locaction:
                 inside_under = 'inside' in self.action
 
                 self.end_action(_('End of vector selection'))
@@ -13517,7 +13683,7 @@ class WolfMapViewer(wx.Frame):
                     # we must reset the temporary vector
                     self.active_vector.reset()
 
-            if self.action == 'distance along vector':
+            elif locaction == 'distance along vector':
 
                 dlg = wx.MessageDialog(None, _('Memorize the vector ?'), _('Confirm'), wx.YES_NO | wx.YES_DEFAULT | wx.ICON_QUESTION)
                 ret = dlg.ShowModal()
@@ -13528,17 +13694,17 @@ class WolfMapViewer(wx.Frame):
 
                 self._tmp_vector_distance = None
 
-            elif self.action == 'pick landmap':
+            elif locaction == 'pick landmap':
 
                 self.end_action(_('End of landmap picking'))
 
-            elif self.action == 'laz tmp vector':
+            elif locaction == 'laz tmp vector':
                 self.end_action(_('End of LAZ selection'))
                 self.active_vector.myvertices.pop(-1)
                 self.plot_laz_around_active_vec()
                 self.active_vector.reset()
 
-            elif self.action == 'create polygon - tiles':
+            elif locaction == 'create polygon - tiles':
                 self.end_action(_('End of polygon creation'))
                 self.active_vector.myvertices.pop(-1)
                 self.active_vector.close_force()
@@ -13576,7 +13742,7 @@ class WolfMapViewer(wx.Frame):
 
                 self._create_data_from_tiles_common()
 
-            elif self.action == 'capture vertices':
+            elif locaction == 'capture vertices':
                 self.end_action(_('End of points capturing'))
                 self.active_vector.myvertices.pop(-1)
                 r = wx.MessageDialog(
@@ -13595,7 +13761,7 @@ class WolfMapViewer(wx.Frame):
                 # C'est donc plus lent mais plus sûr pour que l'affichage dynamique soit correct
                 self.active_vector.parentzone.plot(prep = self.linkedList is None or not(self in self.linkedList))
 
-            elif self.action == 'modify vertices':
+            elif locaction == 'modify vertices':
 
                 # end of vertices modification
                 self.end_action(_('End of vertices modification'))
@@ -13609,7 +13775,7 @@ class WolfMapViewer(wx.Frame):
 
                 self.active_vertex = None
 
-            elif self.action == 'insert vertices':
+            elif locaction == 'insert vertices':
                 self.end_action(_('End of vertices insertion'))
 
                 # force to prepare OpenGL to accelerate the plot
@@ -13621,7 +13787,7 @@ class WolfMapViewer(wx.Frame):
 
                 self.active_vertex = None
 
-            elif self.action == 'dynamic parallel':
+            elif locaction == 'dynamic parallel':
                 self.active_vector.myvertices.pop(-1)
                 self.active_zone.parallel_active(self.dynapar_dist)
 
@@ -13638,11 +13804,11 @@ class WolfMapViewer(wx.Frame):
 
                 self.end_action(_('End of dynamic parallel'))
 
-            elif 'select active vector' in self.action:
+            elif 'select active vector' in locaction:
 
                 self.end_action(_('End of vector selection'))
 
-            elif 'select node by node' in self.action:
+            elif 'select node by node' in locaction:
                 self.end_action(_('End of node by node selection'))
 
         self.copyfrom = None
@@ -13910,6 +14076,7 @@ class WolfMapViewer(wx.Frame):
         """ Message to end action """
 
         self.action = None
+        self.active_vertex = None
         logging.info(_('ACTION : ') + _(message) if message != '' else _('ACTION : End of action') )
         self.msg_action(1)
 
@@ -14298,7 +14465,7 @@ class WolfMapViewer(wx.Frame):
                     logging.info(_('Paste selection position'))
 
                     if cursel == 'all':
-                        self.active_array.SelectionData.OnAllSelect(0)
+                        self.active_array.SelectionData.myselection = 'all'
                     elif len(cursel) > 0:
                         self.active_array.SelectionData.myselection = cursel.copy()
                         self.active_array.SelectionData.update_nb_nodes_selection()
@@ -14918,13 +15085,29 @@ class WolfMapViewer(wx.Frame):
             if self._tmp_vector_distance is not None:
                 self._tmp_vector_distance.plot()
 
-            # try:
-            #     if self.active_bc is not None:
-            #         self.active_bc.plot()
-            # except:
-            #     pass
+            if self.active_vector is not None:
+                if getIfromRGB(self.active_vector_color) != self.active_vector.myprop.color:
+                    old = self.active_vector.myprop.color
+                    self.active_vector.myprop.color = getIfromRGB(self.active_vector_color)
+                    self.active_vector.plot()
+                    self.active_vector._plot_square_at_vertices(size = self.active_vector_square_size)
+                    self.active_vector.myprop.color = old
+                else:
+                    self.active_vector._plot_square_at_vertices(size = self.active_vector_square_size)
+
+                if self.active_vector.myprop.plot_indices:
+                    self.active_vector._plot_all_indices(sx = self.sx, sy=self.sy,
+                                                            xmin=self.xmin, ymin=self.ymin,
+                                                            xmax=self.xmax, ymax=self.ymax,
+                                                            size = (self.xmax - self.xmin) / 100.)
+
+                elif self.active_vertex is not None:
+                    self.active_vector._plot_index_vertex(idx = self.active_vector.myvertices.index(self.active_vertex),
+                                                          sx = self.sx, sy=self.sy,
+                                                          xmin=self.xmin, ymin=self.ymin,
+                                                          xmax=self.xmax, ymax=self.ymax,
+                                                          size = (self.xmax - self.xmin) / 100.)
 
-            # glFlush()
             self.canvas.SwapBuffers()
         else:
             raise NameError(
@@ -15156,6 +15339,7 @@ class WolfMapViewer(wx.Frame):
                 self.Active_zone(vect.parentzone)
 
         self.mimicme()
+        self.Paint()
 
     def Active_zone(self, zone: zone):
         """ Active une zone et son parent si existant """