wolfhece 2.1.119__py3-none-any.whl → 2.1.121__py3-none-any.whl

wolfhece/acceptability/func.py

@@ -152,7 +152,7 @@ class Accept_Manager():
 
     def __init__(self,
                  main_dir:str = 'Data',
-                 Study_area:str = 'Bassin_Vesdre.shp',
+                 Study_area = None,
                  scenario = None,
                  Original_gdb:str = 'GT_Resilence_dataRisques202010.gdb',
                  CaPa_Walloon:str = 'Cadastre_Walloon.gpkg',
@@ -171,9 +171,7 @@ class Accept_Manager():
         # If it is a string, concatenate it with the current directory
         if not self.main_dir.is_absolute():
             self.main_dir = Path(os.getcwd()) / self.main_dir
-
-        self._study_area = str(Study_area)
-
+        self._study_area = Study_area
         if Study_area is not None:
             if not str(self._study_area).endswith('.shp'):
                 self._study_area += '.shp'
@@ -391,7 +389,7 @@ class Accept_Manager():
             self._study_area = None
             self._scenario = None
         else:
-            if Study_area in self.get_list_studyareas(with_suffix=True):
+            if Study_area in self.get_list_studyareas(with_suffix=True) or Study_area+".shp" in self.get_list_studyareas(with_suffix=True):
                 self._study_area = Path(Study_area)
             else:
                 logging.error("The study area does not exist in the study area directory")
@@ -474,18 +472,17 @@ class Accept_Manager():
         sims = self.get_sims_files_for_scenario()
 
         if len(sims)==0:
-            logging.info("No simulations found") #no error, need to act if so. See accept manager flow chart
+            logging.info("No simulations found at this stage") 
             return None
 
         if "_h.tif" in sims[0].name:
             for cursim in sims:
-                if cursim.stem.find("_T{}_".format(return_period)) != -1:
+                if cursim.stem.find("_T{}_".format(return_period)) != -1  or cursim.stem.find("_Q{}_".format(return_period))  != -1:
                     return cursim
         else:
             for cursim in sims:
-                if cursim.stem.find("T{}".format(return_period)) != -1:
+                if cursim.stem.find("T{}".format(return_period)) != -1 or cursim.stem.find("Q{}".format(return_period))  != -1:
                     return cursim
-
         return None
 
     def get_types_in_file(self, file:str) -> list[str]:
@@ -560,44 +557,36 @@ class Accept_Manager():
 
         # List files in directory
         sims = self.get_sims_files_for_scenario()
-
+        sims_modif = [
+            os.path.join(os.path.dirname(path), os.path.basename(path).replace("Q", "T"))
+            for path in sims
+            ]
+        
         if len(sims)==0:
-            logging.info("No simulations found")#no error, need to act if so. See accept manager flow chart
+            logging.info("No simulations found at this stage.")
             return []
 
-        # Two cases:
-        # - Return periods are named as T2.tif, T5.tif, T10.tif, ...
-        # - Return periods are named as *_T2_h.tif, *_T5_h.tif, *_T10_h.tif, ...
-
-        if "_h.tif" in sims[0].name:
-
-            # Searching for the position of the return period in the name
-            idx_T = [cursim.name.find("_T") for cursim in sims]
-            idx_h = [cursim.name.find("_h.tif") for cursim in sims]
-
-            assert len(idx_T) == len(idx_h), "The number of T and h are not the same"
-            for curT, curh in zip(idx_T, idx_h):
-                assert curT != -1, "The T is not found"
-                assert curh != -1, "The h is not found"
-                assert curh > curT, "The h is before the T"
-
-            # Create the list of return periods -- only the numeric part
-            sims = [int(cursim.name[idx_T[i]+2:idx_h[i]]) for i, cursim in enumerate(sims)]
-        else:
-            # searching for the position of the return period in the name
-            idx_T = [cursim.name.find("T") for cursim in sims]
-            idx_h = [cursim.name.find(".tif") for cursim in sims]
-
-            assert len(idx_T) == len(idx_h), "The number of T and h are not the same"
-            for curT, curh in zip(idx_T, idx_h):
-                assert curT != -1, "The T is not found"
-                assert curh != -1, "The h is not found"
-                assert curh > curT, "The h is before the T"
-
-            # create the list of return periods -- only the numeric part
-            sims = [int(cursim.name[idx_T[i]+1:idx_h[i]]) for i, cursim in enumerate(sims)]
-
+        # - Return periods are named as T2.tif, T5.tif, T10.tif, ... or with Q instead of T
+        # searching for the position of the return period in the name
+        idx_T = [Path(cursim).name.find("T") for cursim in sims_modif]
+        idx_h = [Path(cursim).name.find(".tif") for cursim in sims_modif]
+        
+        # create the list of return periods -- only the numeric part
+        sims = [int(Path(cursim).name[idx_T[i]+1:idx_h[i]]) for i, cursim in enumerate(sims_modif)]
         return sorted(sims)
+    
+    def get_modifiedrasters(self):
+        folder = Path(self.IN_CH_SA_SC)
+        vuln_tiff_files = [str(file.name) for file in folder.rglob("*.tiff") if file.name.startswith('vuln_')]
+        vuln_tif_files = [str(file.name)for file in folder.rglob("*.tif") if file.name.startswith('vuln_')]
+        vuln_files = vuln_tiff_files + vuln_tif_files  
+
+        folder = Path(self.IN_CH_SA_SC)
+        mnt_tiff_files = [str(file.name) for file in folder.rglob("*.tiff") if file.name.startswith('MNTmodifs_')]
+        mnt_tif_files = [str(file.name) for file in folder.rglob("*.tif") if file.name.startswith('MNTmodifs_')]
+        mnt_files = mnt_tiff_files + mnt_tif_files
+        
+        return vuln_files + mnt_files
 
     def get_ponderations(self) -> pd.DataFrame:
         """ Get the ponderation data from available simulations """
@@ -605,11 +594,11 @@ class Accept_Manager():
         rt = self.get_return_periods()
 
         if len(rt)==0:
-            logging.info("No simulations found")
+            logging.info("No simulations found at this stage.")
             return None
 
         if len(rt)<2:
-            logging.info("There is only one simulation!")
+            logging.info("There is only one simulation! Weigthing coefficient is unique and set to 1.")
             return pd.DataFrame(1, columns=["Ponderation"], index=rt)
 
         else :
@@ -979,7 +968,7 @@ class Accept_Manager():
 
     def select_name_tif(self, path_baseline: Path, folder_path: Path, name) -> list[Path]:
         """
-        Collects and appends all .tiff files starting with 'vuln' from folder_path into a list.
+        Collects and appends all .tiff files starting with 'name' from folder_path into a list.
         """
         files = []
         #first element must be vulnerability_baseline
@@ -991,23 +980,21 @@ class Accept_Manager():
             files.append(tree[-1].as_posix())
         return files
 
-    def check_nodata(self, name):
+    def check_nodata(self, name, path_baseline):
             """ Check nodata in a path """
-
-            list_tif = Accept_Manager.select_name_tif(self, self.OUT_VULN, self.IN_CH_SA_SC, name)
+            list_tif = Accept_Manager.select_name_tif(self, path_baseline, self.IN_CH_SA_SC, name)
             for cur_lst in list_tif:
-                if "Vulnerability.tiff" not in cur_lst:
-                    curarray:WolfArray = WolfArray(cur_lst)
-                    if curarray.nullvalue != 99999.:
-                        curarray.nullvalue = 99999.
-                        curarray.set_nullvalue_in_mask()
-                        curarray.write_all()
-                        logging.warning(_('nodata changed in favor of 99999. value for file {} !'.format(cur_lst)))
+                curarray:WolfArray = WolfArray(cur_lst)
+                if curarray.nullvalue != 99999.:
+                    curarray.nullvalue = 99999.
+                    curarray.set_nullvalue_in_mask()
+                    curarray.write_all()
+                    logging.warning(_('nodata changed in favor of 99999. value for file {} !'.format(cur_lst)))
 
     def create_vrtIfExists(self, fn_baseline, fn_scenario, fn_vrt, name):
         """ Create a vrt file from a path """
         logging.info(_('Checking nodata values...'))
-        self.check_nodata(name)
+        self.check_nodata(name, fn_baseline)
         list_tif = Accept_Manager.select_name_tif(self, fn_baseline, fn_scenario, name)
         #création du fichier vrt - assembly/agglomération
         if len(list_tif)>1:
@@ -1536,7 +1523,8 @@ def match_vulnerability2sim(inRas:Path, outRas:Path, MODREC:Path):
 def update_accept(accept, model_h, ij, bounds, loc_accept):
     for idx in range(len(bounds)):
         for i,j in ij:
-            if bounds[idx,0] < model_h[i,j] <= bounds[idx,1]: #lit dans wd vs Ti où on est et associe son score d'accept
+            #lit dans wd vs Ti où on est et associe son score d'accept
+            if bounds[idx,0] < model_h[i,j] <= bounds[idx,1]: 
                 accept[i,j] = loc_accept[idx]
 
 def compute_acceptability(manager:Accept_Manager,

wolfhece/apps/check_install.py

@@ -58,6 +58,45 @@ def main():
         ret += 'Wolfhece not installed properly\n Please install the VC++ redistributable\n from https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads\n\n'
         ret += 'Error : ' + str(e) + '\n\n'
 
+    from pathlib import Path
+    dirlaz = Path(__file__).parent.parent / 'lazviewer'
+    dirs_to_test =  [dirlaz / 'libs', dirlaz / 'libs/qt_plugins', dirlaz / 'libs/qt_plugins/platforms']
+
+    for d in dirs_to_test:
+        if not d.exists() or not d.is_dir():
+            ret += str(d) + ' does not exist\n\n'
+
+    curdir = dirlaz / 'libs/qt_plugins/platforms'
+    files_to_test = [curdir / 'qwindows.dll']
+
+    for f in files_to_test:
+        if not f.exists() or not f.is_file():
+            ret += str(f) + ' does not exist\n\n'
+
+    curdir = dirlaz / 'libs'
+    files_to_test = [curdir / 'icudt53.dll', curdir / 'icuin53.dll', curdir / 'icuuc53.dll',
+                     curdir / 'msvcp120.dll', curdir / 'msvcr120.dll', curdir / 'Qt5Core.dll',
+                     curdir / 'Qt5Gui.dll', curdir / 'Qt5Network.dll', curdir / 'Qt5Widgets.dll',
+                     curdir / 'tbb.dll', curdir / 'tbbmalloc.dll', curdir / 'vcomp120.dll']
+
+    for f in files_to_test:
+        if not f.exists() or not f.is_file():
+            ret += str(f) + ' does not exist\n\n'
+
+    try:
+        from ..lazviewer.viewer import viewer
+        import numpy as np
+
+        pts = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]])
+        myview = viewer.viewer(pts, debug = True)
+
+        ret += 'LAZ viewer created in debug mode -- check for errors if reported\n\n'
+
+    except ImportError as e:
+        ret += 'Could not import/create LAZ viewer\n\n'
+        ret += 'Wolfhece not installed properly\n Please check if QT \n\n'
+        ret += 'Error : ' + str(e) + '\n\n'
+
     print(ret)
 
 if __name__=='__main__':

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 119
+        self.patch = 121
 
     def __str__(self):
 

wolfhece/lazviewer/_add_path.py

@@ -1,23 +1,23 @@
-import os
-import os.path
-import sys
-import platform
+# import os
+# import os.path
+# import sys
+# import platform
 
 
-def _add_path():
-    _root_dir = os.path.dirname(os.path.realpath(__file__))
+# def _add_path():
+#     _root_dir = os.path.dirname(os.path.realpath(__file__))
 
-    # manual specify list of dll directories, with paths relative to _root_dir
-    _dll_dirs = ['libs']
+#     # manual specify list of dll directories, with paths relative to _root_dir
+#     _dll_dirs = ['libs']
 
-    if platform.system() == 'Windows':
-        os.environ.setdefault('PATH', '')
-        paths = os.environ['PATH'].split(';')
-        for x in _dll_dirs:
-            x = os.path.join(_root_dir, x)
-            if os.path.isdir(x) and x not in paths:
-                paths = [x] + paths
-        os.environ['PATH'] = ';'.join(paths)
+#     if platform.system() == 'Windows':
+#         os.environ.setdefault('PATH', '')
+#         paths = os.environ['PATH'].split(';')
+#         for x in _dll_dirs:
+#             x = os.path.join(_root_dir, x)
+#             if os.path.isdir(x) and x not in paths:
+#                 paths = [x] + paths
+#         os.environ['PATH'] = ';'.join(paths)
 
 
-_add_path()
+# _add_path()

wolfhece/lazviewer/laz_viewer.py

@@ -23,7 +23,7 @@ from ..PyWMS import getWalonmap
 from ..PyTranslate import _
 from ..color_constants import Colors
 from ..PyParams import Wolf_Param, Type_Param
-from ..matplotlib_fig import Matplotlib_Figure as MplFig
+from ..matplotlib_fig import Matplotlib_Figure as MplFig, PRESET_LAYOUTS
 from ..drawing_obj import Element_To_Draw
 from ..CpGrid import CpGrid
 from ..PyVertexvectors import vector, Zones, zone, wolfvertex
@@ -375,6 +375,35 @@ class xyz_laz_grid():
 
         return retdata
 
+    def find_files_in_bounds(self, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
+        """ Find all files in bounds """
+
+        x1=bounds[0][0]
+        x2=bounds[0][1]
+        y1=bounds[1][0]
+        y2=bounds[1][1]
+
+        file1= self.genfile.split('x1')[0]
+        file2= self.genfile.split('y1')[-1]
+
+        files=[]
+
+        for x in range(int(self.origx), int(self.endx), int(self.dx)):
+            for y in range(int(self.origy), int(self.endy), int(self.dy)):
+
+                locbounds=np.float64(((x,x+self.dx),(y,y+self.dy)))
+
+                test = not(x2 < locbounds[0][0] or x1 > locbounds[0][1] or y2 < locbounds[1][0] or y1 > locbounds[1][1])
+
+                if test:
+                    fxyz = file1+str(int(x))+'_'+str(int(y))+file2
+
+                    fn = join(self.mydir,fxyz)
+                    if exists(fn):
+                        files.append(fn)
+
+        return files
+
     def _split_xyz(self, dirout:str, nbparts:int = 10):
         """ Split XYZ file into 'nb' parts along X and Y """
         for entry in scandir(self.mydir):
@@ -494,7 +523,7 @@ class xyz_laz_grids():
     """ Ensemble de grids """
 
     def __init__(self, dir_grids:str, create:bool=False) -> None:
-        self.grids = []
+        self.grids:list[xyz_laz_grid] = []
         self.colors = Classification_LAZ()
         self.colors.init_2023()
 
@@ -527,6 +556,36 @@ class xyz_laz_grids():
             logging.info(_('Data found -- {} points'.format(ret.shape[0])))
             return ret
 
+    def find_files_in_bounds(self, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
+
+        ret = [(cur.mydir, cur.find_files_in_bounds(bounds)) for cur in self.grids]
+        ret = [cur for cur in ret if len(cur[1])>0]
+
+        if len(ret)==0:
+            logging.info(_('No data found'))
+            return []
+        else:
+            logging.info(_('Data found -- {} files'.format(len(ret))))
+            return ret
+
+    def copy_files_in_bounds(self, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]], dirout:str):
+
+        import shutil
+
+        out = Path(dirout)
+        out.mkdir(exist_ok=True)
+
+        files = self.find_files_in_bounds(bounds)
+
+        for curdir, curfiles in files:
+            locdir = dirout / Path(curdir).parent.name
+            locdir.mkdir(exist_ok=True)
+            for curfile in curfiles:
+                shutil.copy(curfile, locdir / Path(curfile).name)
+
+            # copy gridinfo.txt
+            shutil.copy(join(curdir,'gridinfo.txt'), locdir / 'gridinfo.txt')
+
     def read_dir(self, dir_grids):
         dirs = listdir(dir_grids)
 
@@ -637,14 +696,11 @@ class xyz_laz_grids():
 
         (up_s, up_z, up_color), (down_s, down_z, down_color) = self.scan_around(xy, length_buffer)
 
-        figmpl = MplFig()
-        figmpl.presets()
-        fig = figmpl.fig
-        ax = figmpl.cur_ax
+        figmpl = MplFig(PRESET_LAYOUTS.DEFAULT)
 
         logging.info(_('Plotting'))
-        ax.scatter(up_s,   up_z,  c=up_color  ,marker='.')
-        ax.scatter(down_s, down_z,c=down_color,marker='+')
+        figmpl.plot(up_s,   up_z,  c=up_color  ,marker='.')
+        figmpl.plot(down_s, down_z,c=down_color,marker='+')
 
         if show:
             figmpl.Show()
@@ -883,9 +939,12 @@ class Wolf_LAZ_Data(Element_To_Draw):
 
         nb1 = self.data.shape[0]
         if self.viewer is not None:
-            nb2 = self.viewer.get('num_points')[0]
-            assert nb1 == nb2, _('Incoherent number of points')
-
+            try:
+                nb2 = self.viewer.get('num_points')[0]
+                assert nb1 == nb2, _('Incoherent number of points')
+            except:
+                # viewer is not initialized or Destroyed
+                self.viewer = None
         return nb1
 
     @property
@@ -1138,7 +1197,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
     def bounds(self, value):
         self._bounds = value
 
-    def from_grid(self, grid:xyz_laz_grid, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
+    def from_grid(self, grid:xyz_laz_grids, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]):
         """ Create data from grid LAZ """
         self.bounds = bounds
         self.data = grid.scan(bounds)
@@ -1482,7 +1541,7 @@ class Wolf_LAZ_Data(Element_To_Draw):
         props = self._myprops
 
         self.lookat = (props[('Look at', 'X')], props[('Look at', 'Y')], props[('Look at', 'Z')])
-        self.eye = (props[('Camera', 'X')], props[('Camera', 'Y')], props[('Camera', 'Z')])
+        # self.eye = (props[('Camera', 'X')], props[('Camera', 'Y')], props[('Camera', 'Z')])
 
         color = np.asarray(props[('Background', 'Color')])
         self.bg_color(color / 255.)

wolfhece/lazviewer/viewer/qt.conf

@@ -0,0 +1,2 @@
+[Paths]
+Plugins=../libs/qt_plugins

wolfhece/lazviewer/viewer/viewer.py

@@ -12,8 +12,12 @@ _viewer_dir = os.path.dirname(inspect.getfile(inspect.currentframe()))
 if not os.path.isabs(_viewer_dir):
     _viewer_dir = os.path.abspath(_viewer_dir)
 
-__all__ = ['viewer']
+_viewer_libs_dir = os.path.join(_viewer_dir, '../libs')
+
+if not os.path.isabs(_viewer_libs_dir):
+    _viewer_libs_dir = os.path.abspath(_viewer_libs_dir)
 
+__all__ = ['viewer']
 
 class viewer:
     def __init__(self, *args, **kwargs):
@@ -22,7 +26,7 @@ class viewer:
         Examples:
             Create 100 random points
 
-            >>> xyz = pptk.rand(100, 3)
+            >>> xyz = pptk.rand(100, 3)python
 
             Visualize the points
 
@@ -49,10 +53,16 @@ class viewer:
         s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         s.bind(('localhost', 0))
         s.listen(0)
-        self._process = subprocess.Popen(
-            [os.path.join(_viewer_dir, 'viewer'), str(s.getsockname()[1])],
-            stdout=subprocess.PIPE,
-            stderr=(None if debug else subprocess.PIPE))
+
+        env = os.environ.copy()
+        env["PATH"] = _viewer_dir + os.pathsep + _viewer_libs_dir + os.pathsep + env["PATH"]
+        # print(env["PATH"])
+
+        self._process = subprocess.Popen([os.path.join(_viewer_dir, 'viewer'),
+                                          str(s.getsockname()[1])],
+                                          stdout=subprocess.PIPE,
+                                          stderr=(None if debug else subprocess.PIPE),
+                                          env = env)
         if debug:
             print ('Started viewer process: %s' \
                 % os.path.join(_viewer_dir, 'viewer'))

wolfhece/matplotlib_fig.py

@@ -1242,7 +1242,18 @@ class Matplotlib_Figure(wx.Frame):
         size_x, size_y = self.fig.get_size_inches()
 
         if self.wx_exists:
-            wx.Frame.__init__(self, None, -1, 'Matplotlib Figure', size=(size_x*dpi+16, size_y*dpi+240), style=wx.DEFAULT_FRAME_STYLE ^ wx.RESIZE_BORDER)
+            size_x = size_x*dpi+16
+            size_y = size_y*dpi+240
+
+            #compare to screen size
+            screen = wx.Display(0)
+            screen_size = screen.GetGeometry().GetSize()
+            if size_x > screen_size[0]:
+                size_x = screen_size[0]
+            if size_y > screen_size[1]:
+                size_y = screen_size[1]
+
+            wx.Frame.__init__(self, None, -1, 'Matplotlib Figure', size=(size_x, size_y), style=wx.DEFAULT_FRAME_STYLE ^ wx.RESIZE_BORDER)
 
         self.ax_dict:dict[str,Axes] = {}    # dict of axes
         self.ax:list[Axes] = []             # list of axes -- always flatten
@@ -2048,6 +2059,13 @@ class Matplotlib_Figure(wx.Frame):
             return key, list(self.ax_dict.values()).index(key)
 
     def plot(self, x:np.ndarray, y:np.ndarray, ax:Axes | int | str= None, **kwargs):
+        """ Plot x, y on the current ax or on the ax specified
+
+        :param x: x values
+        :param y: y values
+        :param ax: ax to plot on
+        :param kwargs: kwargs for the plot (same as matplotlib.pyplot.plot)
+        """
 
         ax, idx_ax = self.get_ax_idx(ax)
 
@@ -2068,8 +2086,72 @@ class Matplotlib_Figure(wx.Frame):
                 self._line_current.SetSelection(len(ax.get_lines())-1)
 
         self.fig.tight_layout()
+        self.fig.canvas.draw()
         self.update_layout()
 
+    def scatter(self, x:np.ndarray, y:np.ndarray, ax:Axes | int | str= None, **kwargs):
+        """ Scatter Plot x, y on the current ax or on the ax specified
+
+        :param x: x values
+        :param y: y values
+        :param ax: ax to plot on
+        :param kwargs: kwargs for the plot (same as matplotlib.pyplot.plot)
+        """
+
+        ax, idx_ax = self.get_ax_idx(ax)
+
+        ax.scatter(x, y, **kwargs)
+
+        new_props = Matplolib_line_properties(ax.get_lines()[-1], self._axes_properties[idx_ax])
+
+        if self.wx_exists:
+            new_props.add_props_to_sizer(self._collaps_pane.GetPane(), self._sizer_grid_props)
+
+        ax_prop:Matplotlib_ax_properties = self._axes_properties[idx_ax]
+        ax_prop._lines.append(new_props)
+        ax_prop.get_properties()
+
+        if self.wx_exists:
+            if ax == self.cur_ax:
+                self._line_current.SetItems([line.get_label() for line in ax.get_lines()])
+                self._line_current.SetSelection(len(ax.get_lines())-1)
+
+        self.fig.tight_layout()
+        self.fig.canvas.draw()
+        self.update_layout()
+
+    def violinplot(self, dataset:np.ndarray, position:np.ndarray=None, ax:Axes | int | str= None, **kwargs):
+        """ Plot x, y on the current ax or on the ax specified
+
+        :param x: x values
+        :param y: y values
+        :param ax: ax to plot on
+        :param kwargs: kwargs for the plot (same as matplotlib.pyplot.plot)
+        """
+
+        ax, idx_ax = self.get_ax_idx(ax)
+
+        ax.violinplot(dataset, position, **kwargs)
+
+        # new_props = Matplolib_line_properties(ax.get_lines()[-1], self._axes_properties[idx_ax])
+
+        # if self.wx_exists:
+        #     new_props.add_props_to_sizer(self._collaps_pane.GetPane(), self._sizer_grid_props)
+
+        # ax_prop:Matplotlib_ax_properties = self._axes_properties[idx_ax]
+        # ax_prop._lines.append(new_props)
+        # ax_prop.get_properties()
+
+        # if self.wx_exists:
+        #     if ax == self.cur_ax:
+        #         self._line_current.SetItems([line.get_label() for line in ax.get_lines()])
+        #         self._line_current.SetSelection(len(ax.get_lines())-1)
+
+        self.fig.tight_layout()
+        self.fig.canvas.draw()
+        self.update_layout()
+
+
     def to_dict(self) -> dict:
         """ properties to dict """