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

wolfhece/lazviewer/laz_viewer.py

@@ -5,7 +5,7 @@ from PIL import Image
 from os.path import exists,join
 import matplotlib.pyplot as plt
 from os import stat,remove,listdir,scandir, makedirs
-import pathlib
+from pathlib import Path
 import math
 from time import sleep
 from typing import Literal, Union
@@ -22,8 +22,10 @@ from . import viewer
 from ..PyWMS import getWalonmap
 from ..PyTranslate import _
 from ..color_constants import Colors
-from ..PyParams import Wolf_Param
+from ..PyParams import Wolf_Param, Type_Param
 from ..matplotlib_fig import Matplotlib_Figure as mplfig
+from ..drawing_obj import Element_To_Draw
+from ..CpGrid import CpGrid
 
 """
 Importation et visualisation de données LAS et LAZ
@@ -43,16 +45,20 @@ class Colors_Lazviewer(Enum):
 class Classification_LAZ():
 
     def __init__(self) -> None:
+
+        self.class_name = 'SPW-Geofit 2023'
         self.classification:dict[str,str,list[float,float,float,float]] = {}
         self.test_wx()
 
         self._choose_colors = None
+        self._viewer = None
 
     def test_wx(self):
         self.wx_exists = wx.App.Get() is not None
 
     def init_2013(self):
 
+        self.class_name = 'SPW 2013-2014'
         self.classification={
             0  : ['0', 'Pas de classification', Colors.rgb_withalpha_float('black',.2),],
             1  : ['Hors-sol', 'building, toits et autres', Colors.rgb_withalpha_float('white',.2),],
@@ -63,6 +69,7 @@ class Classification_LAZ():
 
     def init_2023(self):
 
+        self.class_name = 'SPW-Geofit 2023'
         self.classification={
             0  : ['0', 'Pas de classification', Colors.rgb_withalpha_float('black',.2),],
             1  : ['Défaut', 'Voiture, câbles électrique, points de végétation diffus, Sursol non utile', Colors.rgb_withalpha_float('white',.2),],
@@ -72,6 +79,7 @@ class Classification_LAZ():
             9  : ['Eau', 'Points de la surface d\’eau brute mesurés par le scanner 2',Colors.rgb_withalpha_float('royalblue',.3)],
             10 : ['Ponts', 'Les ponts ont été classés à part pour améliorer la définition du MNT. Ils ont été ouverts grâce',Colors.rgb_withalpha_float('lightyellow1',1.)],
             11 : ['Mur de berges', 'Mur et muret en berge de la Vesdre dépassant le sol à des vocation de réaliser une modélisation 3D hydraulique avec ces obstacles.',Colors.rgb_withalpha_float('red1',1.)],
+            13 : ['Inconnu', 'A vérifier auSPW', Colors.rgb_withalpha_float('lightslategray',.2)],
             15 : ['Tranche d\'eau', 'Echo intermédiaire dans l\’eau n\’appartenant ni à la surface d\’eau ni au fond du lit', Colors.rgb_withalpha_float('lightblue',.2)],
             16 : ['Surface bathymétrique', 'Fond du lit de la Vesdre et de ses affluents et des autres surfaces d\’eau mesurées à partir du scanner 3 FWF discrétisé',Colors.rgb_withalpha_float('sandybrown',1.)],
             17 : ['Surface bathymétrique incertaine', 'Surface bathymétrique sur les zones peu profondes principalement sous végétation où les intensités des échos sont parfois trop faibles pour avoir la certitude qu\’ils représentent le fond de rivière. La classe 17 est néanmoins plus certaine que la classe 18. Elle est utilisée dans la génération des MNT par défaut.',Colors.rgb_withalpha_float('rosybrown',.5)],
@@ -142,7 +150,7 @@ class xyz_laz():
                 self.data = []
                 return
 
-            last_part = pathlib.Path(fn).name
+            last_part = Path(fn).name
             parts = last_part.split('_')
 
             # L'origine est codée dans le nom de fichier
@@ -153,7 +161,7 @@ class xyz_laz():
             dy = 3500.
 
             # Récupération du lien vers le fichier GridInfo.txt
-            gridinfo=join(pathlib.Path(fn).parent,'gridinfo.txt')
+            gridinfo=join(Path(fn).parent,'gridinfo.txt')
 
             if exists(gridinfo):
                 with open(gridinfo,'r') as f:
@@ -240,8 +248,8 @@ class xyz_laz():
         if exists(fn+'.zip'):
             with zipfile.ZipFile(fn+'.zip','r') as zip_file:
                 fn = zip_file.namelist()[0]
-                zip_file.extract(fn, path=pathlib.Path(fn).parent)
-                fn = join(pathlib.Path(fn).parent, fn)
+                zip_file.extract(fn, path=Path(fn).parent)
+                fn = join(Path(fn).parent, fn)
         elif not exists(fn):
             return
 
@@ -391,7 +399,7 @@ class xyz_laz_grid():
         xloc = np.linspace(xbounds[0], xbounds[1], gridsize[0]+1)
         yloc = np.linspace(ybounds[0], ybounds[1], gridsize[1]+1)
 
-        dirout = pathlib.Path(fn_out).parent
+        dirout = Path(fn_out).parent
         fn=join(dirout,'gridinfo.txt')
 
         if exists(fn):
@@ -401,7 +409,7 @@ class xyz_laz_grid():
             f.write(str(int(xbounds[0]))+','+str(int(xbounds[1]))+'\n')
             f.write(str(int(ybounds[0]))+','+str(int(ybounds[1]))+'\n')
             f.write(str(int(gridsize[0]))+','+str(int(gridsize[1]))+'\n')
-            f.write(pathlib.Path(fn_out).name+'_'+'x1'+'_'+'y1'+'_xyz.bin'+'\n')
+            f.write(Path(fn_out).name+'_'+'x1'+'_'+'y1'+'_xyz.bin'+'\n')
             if force_format == np.float64:
                 f.write('xy_float64')
             else:
@@ -477,7 +485,7 @@ class xyz_laz_grid():
                     if force_format == np.float64:
                         fnzip = fn + '.zip'
                         with zipfile.ZipFile(fnzip,'w',zipfile.ZIP_DEFLATED) as zip_file:
-                            zip_file.write(fn, pathlib.Path(fn).name)
+                            zip_file.write(fn, Path(fn).name)
                         remove(fn)
 
 
@@ -678,6 +686,639 @@ class xyz_laz_grids():
                                                             gridsize=[max(int(dx/ds),1), max(int(dy/ds),1)],
                                                             force_format=force_format))
 
+
+class Base_LAZ_Data(Element_To_Draw):
+
+    def __init__(self, idx:str = '', plotted:bool = False, mapviewer = None, need_for_wx:bool = False) -> None:
+
+        self._bounds = [[0.,0.],[0.,0.]] # [[xmin,xmax],[ymin,ymax]]
+        super().__init__(idx, plotted, mapviewer, need_for_wx)
+
+        self.lazfile:Path = None
+        self._data:np.ndarray = None
+        self.classification = Classification_LAZ()
+
+        self.associated_color:int = Colors_Lazviewer.CODE_2023.value
+
+        self.viewer:viewer = None
+        self._colors:np.ndarray = None
+
+        self._point_size = .05
+
+        self._memory = []
+
+        self._myprops = None
+
+        self._bg_color = [0,0,0,255]
+        self._bg_color_top = [0,0,0,255]
+        self._bg_color_bottom = [0,0,0,255]
+
+        self._floor_level = 0.
+        self._floor_color = [0,0,0,255]
+
+        self._show_grid = True
+        self._show_axis = True
+        self._show_info = True
+
+        self._select_only_codes = []
+
+        self._xls:CpGrid = None
+        self._xlsFrame:wx.Frame = None
+
+        # self._auto_update_properties = False
+        # self._auto_update_interval = 100 # ms
+        # self._timer = None
+
+    def filter_data(self, codes:list[int]):
+        self._data = self._data[np.isin(self._data[:,3],codes)]
+
+    def bg_color(self, value):
+        if self.viewer is not None:
+            return self.viewer.set(bg_color = value)
+
+    def bg_color_top(self, value):
+        if self.viewer is not None:
+            return self.viewer.set(bg_color_top = value)
+
+    def bg_color_bottom(self, value):
+        if self.viewer is not None:
+            return self.viewer.set(bg_color_bottom = value)
+
+    def floor_level(self, value):
+        if self.viewer is not None:
+            return self.viewer.set(floor_level = value)
+
+    def floor_color(self, value):
+        if self.viewer is not None:
+            return self.viewer.set(floor_color = value)
+
+    def show_grid(self, value:bool):
+        if self.viewer is not None:
+            return self.viewer.set(show_grid = value)
+
+    def show_axis(self, value:bool):
+        if self.viewer is not None:
+            return self.viewer.set(show_axis = value)
+
+    def show_info(self, value:bool):
+        if self.viewer is not None:
+            return self.viewer.set(show_info = value)
+
+    @property
+    def selected(self):
+        if self.viewer is None:
+            return None
+        return self.viewer.get('selected')
+
+    @property
+    def xyz_selected(self) -> np.ndarray:
+        if self.viewer is None:
+            return None
+
+        if self.selected.shape[0] == 0:
+            return np.ndarray((0,3))
+
+        if len(self._select_only_codes)>0:
+            return self.data[self.selected,:3][np.isin(self.data[self.selected,3],self._select_only_codes)]
+        else:
+            return self.data[self.selected,:3]
+
+    @property
+    def code_selected(self) -> np.ndarray:
+        if self.viewer is None:
+            return None
+
+        if self.selected.shape[0] == 0:
+            return np.ndarray((0,1))
+
+        if len(self._select_only_codes)>0:
+            return self.data[self.selected,3][np.isin(self.data[self.selected,3],self._select_only_codes)]
+        else:
+            return self.data[self.selected,3]
+
+    @property
+    def num_points(self):
+        """ Number of points """
+        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')
+
+        return nb1
+
+    @property
+    def nb_points(self):
+        """ Number of points """
+        return self.num_points
+
+    @property
+    def nb(self):
+        """ Number of points """
+        return self.num_points
+
+    @property
+    def right(self):
+        """Camera Right vector """
+        return self.viewer.get('right')
+
+    @property
+    def mvp(self):
+        if self.viewer is None:
+            return None
+        return self.viewer.get('mvp')
+
+    @property
+    def eye(self):
+        if self.viewer is None:
+            return None
+        return self.viewer.get('eye')
+
+    @property
+    def lookat(self):
+        if self.viewer is None:
+            return None
+        return self.viewer.get('lookat')
+
+    @property
+    def phi(self):
+        if self.viewer is None:
+            return None
+        return self.viewer.get('phi')[0]
+
+    @property
+    def theta(self):
+        if self.viewer is None:
+            return None
+        return self.viewer.get('theta')[0]
+
+    @property
+    def r(self):
+        if self.viewer is None:
+            return None
+        return self.viewer.get('r')[0]
+
+    @phi.setter
+    def phi(self, value):
+        if self.viewer is None:
+            return None
+        self.viewer.set(phi=value)
+
+    @theta.setter
+    def theta(self, value):
+        if self.viewer is None:
+            return None
+        self.viewer.set(theta=value)
+
+    @r.setter
+    def r(self, value):
+        if self.viewer is None:
+            return None
+        self.viewer.set(r=value)
+
+    @lookat.setter
+    def lookat(self, value):
+        if self.viewer is None:
+            return None
+        self.viewer.set(lookat=value)
+
+    @eye.setter
+    def eye(self, value):
+        if self.viewer is None:
+            return None
+        x,y,z = value
+        lx, ly, lz = self.lookat
+        right = self.right
+
+        # Compute phi, theta, r based on eye and lookat and right vector
+        r = np.sqrt((x-lx)**2 + (y-ly)**2 + (z-lz)**2)
+        self.r =r
+        self.phi = np.arccos((z-lz)/r)
+        self.theta = np.arctan2((y-ly),(x-lx))
+
+    @property
+    def point_size(self):
+        return self._point_size
+
+    @point_size.setter
+    def point_size(self, value):
+        self._point_size = value
+        if self.viewer is not None:
+            self.viewer.set(point_size=value)
+
+    @property
+    def xyz(self):
+        return self.data[:,:3]
+
+    @property
+    def codes(self):
+        return self.data[:,3]
+
+    def codes_unique(self):
+        return list(np.unique(self.codes).astype(int))
+
+    def create_viewer(self, color_code:Colors_Lazviewer = None, classification:Classification_LAZ = None):
+        """ Create a viewer for las data """
+
+        if color_code is not None:
+            self.associated_color = color_code
+
+        if classification is not None:
+            self.classification = classification
+
+        self._colors = get_colors(self.data, self.associated_color, palette_classif= self.classification)
+
+        self.viewer = viewer(self.xyz, self._colors)
+        self.viewer.set(point_size= self._point_size)
+
+        return self.viewer
+
+    def interactive_update_colors(self):
+
+        self.classification.interactive_update_colors()
+
+        self.classification._choose_colors.SetTitle(_('Colors of ') + self.idx)
+
+        def new_callback_colors():
+            self.classification.callback_colors()
+            self.set_colors()
+
+        self.classification._choose_colors.callback = new_callback_colors
+
+    def set_colors(self):
+        if self.viewer is not None:
+            self._colors = get_colors(self.data, self.associated_color, palette_classif= self.classification)
+            self.viewer.attributes(self._colors)
+
+    def set_classification(self, classification:str = None):
+
+        if classification is None:
+            logging.warning(_('No classification chosen - Abort !'))
+        elif classification == 'SPW 2013-2014':
+            self.classification.init_2013()
+        else:
+            self.classification.init_2023()
+
+    def find_minmax(self, update=False):
+        if self.data is not None:
+            self.bounds = [[np.min(self.data[:,0]), np.max(self.data[:,0])],[np.min(self.data[:,1]), np.max(self.data[:,1])]]
+
+    @property
+    def xmin(self):
+        return self.bounds[0][0]
+
+    @xmin.setter
+    def xmin(self, value):
+        self._bounds[0][0] = value
+
+    @property
+    def xmax(self):
+        return self.bounds[0][1]
+
+    @xmax.setter
+    def xmax(self, value):
+        self._bounds[0][1] = value
+
+    @property
+    def ymin(self):
+        return self.bounds[1][0]
+
+    @ymin.setter
+    def ymin(self, value):
+        self._bounds[1][0] = value
+
+    @property
+    def ymax(self):
+        return self.bounds[1][1]
+
+    @ymax.setter
+    def ymax(self, value):
+        self._bounds[1][1] = value
+
+    @property
+    def data(self):
+        return self._data
+
+    @data.setter
+    def data(self, value):
+        self._data = value
+
+    @property
+    def bounds(self):
+        return self._bounds
+
+    @bounds.setter
+    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]]]):
+
+        self.bounds = bounds
+        self.data = grid.scan(bounds)
+
+    def from_file(self, fn:str):
+
+        self.data = read_laz(fn)
+        self.bounds = [[np.min(self.data[:,0]), np.max(self.data[:,0])],[np.min(self.data[:,1]), np.max(self.data[:,1])]]
+
+    def decimate(self, step:int):
+        self.data = self.data[::step]
+
+    def get_data_class(self, key:int):
+        return self.data[self.data[:,3] == key]
+
+    def add_pose_in_memory(self, key_time:float = 1.):
+        if self.viewer is not None:
+            lookat = self.lookat
+            new_pose = (lookat[0], lookat[1], lookat[2], self.phi, self.theta, self.r)
+            self._memory.append((new_pose, key_time))
+
+    def play_flight(self, tlim=[-np.inf, np.inf], repeat=False, interp='cubic_natural'):
+
+        if self.viewer is not None:
+            if len(self._memory)>0:
+                poses = [cur[0] for cur in self._memory]
+                times = [0.]
+                for i in range(1,len(self._memory)):
+                    times.append(times[-1]+self._memory[i][1])
+                self.viewer.play(poses, times, tlim, repeat, interp)
+
+    def set_times(self, times:np.ndarray):
+        if len(self._memory)>0:
+            self._memory = [(self._memory[i][0], times[i]) for i in range(len(self._memory))]
+
+    def set_times_increment(self, increment:float):
+        if len(self._memory)>0:
+            self._memory = [(self._memory[i][0], increment*i) for i in range(len(self._memory))]
+
+    def get_times(self):
+        return np.asarray([cur[1] for cur in self._memory])
+
+    def record_flight(self, dirout:str, tlim=[-np.inf, np.inf], interp='cubic_natural', fps=24, prefix:str = 'laz_', ext:str = '.png'):
+        if self.viewer is not None:
+            if len(self._memory)>0:
+                poses = [cur[0] for cur in self._memory]
+                times = [0.]
+                for i in range(1,len(self._memory)):
+                    times.append(times[-1]+self._memory[i][1])
+                self.viewer.record(dirout, poses, times, tlim, interp, fps=fps, prefix=prefix, ext=ext)
+
+    def save_flight(self, fn:str):
+        """ Write memory to file JSON """
+        import json
+
+        if len(self._memory)>0:
+            with open(fn,'w') as f:
+                json.dump(self._memory, f, indent=2)
+
+    def load_flight(self, fn:str):
+        """ Load memory from file JSON """
+        import json
+
+        if exists(fn):
+            with open(fn,'r') as f:
+                self._memory = json.load(f)
+
+
+    def _callback_props(self):
+
+        self._update_props()
+
+    def _callback_destroy_props(self):
+
+        if self._myprops is not None:
+            self._callback_props()
+            self._myprops.Destroy()
+            self._myprops = None
+
+    def _create_props(self):
+
+        if self._myprops is not None:
+            return
+
+        self._myprops = Wolf_Param(None, title=_('Properties of ') + self.idx,
+                            to_read=False, force_even_if_same_default= True)
+
+        props = self._myprops
+
+        props.set_callbacks(self._callback_props, self._callback_destroy_props)
+        props.hide_selected_buttons()
+
+
+        ret = props.addparam('Camera', 'X', self.eye[0], Type_Param.Float, 'eye_x')
+        ret = props.addparam('Camera', 'Y', self.eye[1], Type_Param.Float, 'eye_y')
+        ret = props.addparam('Camera', 'Z', self.eye[2], Type_Param.Float, 'eye_z')
+
+        ret = props.addparam('Look at', 'X', self.lookat[0], Type_Param.Float, 'lookat_x')
+        ret = props.addparam('Look at', 'Y', self.lookat[1], Type_Param.Float, 'lookat_y')
+        ret = props.addparam('Look at', 'Z', self.lookat[2], Type_Param.Float, 'lookat_z')
+
+        ret = props.addparam('Relative Position', 'Phi', self.phi, Type_Param.Float, 'azimuthal angle (radians) - (phi, theta, r) are spherical coordinates specifying camera position relative to the look at position.')
+        ret = props.addparam('Relative Position', 'Theta', self.theta, Type_Param.Float, 'elevation angle (radians) - (phi, theta, r) are spherical coordinates specifying camera position relative to the look at position.')
+        ret = props.addparam('Relative Position', 'R', self.r, Type_Param.Float, 'distance to look-at point - (phi, theta, r) are spherical coordinates specifying camera position relative to the look at position.')
+
+        ret = props.addparam('Background', 'Color', self._bg_color, Type_Param.Color, 'Background color')
+        ret = props.addparam('Background', 'Top Color', self._bg_color_top, Type_Param.Color, 'Top Background color')
+        ret = props.addparam('Background', 'Bottom Color', self._bg_color_bottom, Type_Param.Color, 'Bottom Background color')
+
+        ret = props.addparam('Floor', 'Level', self._floor_level, Type_Param.Float, 'Floor level')
+        ret = props.addparam('Floor', 'Color', self._floor_color, Type_Param.Color, 'Floor color')
+
+        ret = props.addparam('Infos', 'Grid', self._show_grid, Type_Param.Logical, 'Show grid')
+        ret = props.addparam('Infos', 'Axis', self._show_axis, Type_Param.Logical, 'Show axis')
+        ret = props.addparam('Infos', 'values', self._show_info, Type_Param.Logical, 'Show info')
+
+        ret = props.addparam('Points', 'Size', self._point_size, Type_Param.Float, 'Point size')
+
+        codes_sel = ''
+        for curcode in self._select_only_codes:
+            codes_sel += str(curcode) + ','
+        ret = props.addparam('Selection', 'Codes', codes_sel, Type_Param.String, 'Codes to select')
+
+        # ret = props.addparam('Auto Update', 'Active', self._auto_update_properties, Type_Param.Logical, 'Auto update properties')
+        # ret = props.addparam('Auto Update', 'Interval', self._auto_update_interval, Type_Param.Integer, 'Auto update interval (ms)')
+
+        props.Populate()
+
+        updatebutton = wx.Button(props, label=_('Update from viewer'))
+        props.sizerbut.Add(updatebutton,1,wx.EXPAND)
+        props.Bind(wx.EVT_BUTTON, self._fill_props, updatebutton)
+
+        getselection = wx.Button(props, label=_('Get selection'))
+        props.sizerbut.Add(getselection,1,wx.EXPAND)
+        props.Bind(wx.EVT_BUTTON, self._get_selection, getselection)
+
+        props.Layout()
+
+    def _get_selection(self, event):
+
+        if self.viewer is None:
+            logging.warning(_('No viewer'))
+            return
+
+        xyz = self.xyz_selected
+
+        if xyz.shape[0]==0:
+            logging.warning(_('No points selected'))
+            return
+
+        if self._xls is None:
+            self._xlsFrame = wx.Frame(None, wx.ID_ANY, _('Selected points - ') + self.idx)
+            self._xls = CpGrid(self._xlsFrame, wx.ID_ANY, style = wx.WANTS_CHARS)
+
+            sizer = wx.BoxSizer(wx.VERTICAL)
+            sizer.Add(self._xls, 1, wx.EXPAND)
+
+            nbclass = len(self.classification.classification)
+            self._xls.CreateGrid(xyz.shape[0] + nbclass +1, 4)
+
+            self._xlsFrame.SetSizer(sizer)
+            self._xlsFrame.Layout()
+            self._xlsFrame.Show()
+
+        else:
+            self._xls.ClearGrid()
+            if self._xls.NumberRows < xyz.shape[0]:
+                self._xls.AppendRows(xyz.shape[0]-self._xls.NumberRows)
+
+        self._xls.SetColLabelValue(0, 'X')
+        self._xls.SetColLabelValue(1, 'Y')
+        self._xls.SetColLabelValue(2, 'Z')
+        self._xls.SetColLabelValue(3, 'Code')
+
+        codes = self.code_selected
+
+        for i in range(xyz.shape[0]):
+            self._xls.SetCellValue(i,0,str(xyz[i,0]))
+            self._xls.SetCellValue(i,1,str(xyz[i,1]))
+            self._xls.SetCellValue(i,2,str(xyz[i,2]))
+            self._xls.SetCellValue(i,3,str(codes[i]))
+
+        # Copy classification under the values
+        for i, (key, val) in enumerate(self.classification.classification.items()):
+            self._xls.SetCellValue(xyz.shape[0]+i+1,0,str(key))
+            self._xls.SetCellValue(xyz.shape[0]+i+1,1,val[0])
+            self._xls.SetCellValue(xyz.shape[0]+i+1,2,val[1])
+            self._xls.SetCellValue(xyz.shape[0]+i+1,3,str(key))
+
+        self._xlsFrame.Show()
+
+        # Mettre la fenêtre au premier plan et centrée
+        self._xlsFrame.Raise()
+        self._xlsFrame.Center()
+
+    def _update_props(self):
+
+        if self._myprops is None:
+            return
+
+        if self.viewer is None:
+            return
+
+        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')])
+
+        color = np.asarray(props[('Background', 'Color')])
+        self.bg_color(color / 255.)
+        color = np.asarray(props[('Background', 'Top Color')])
+        self.bg_color_top(color / 255.)
+        color = np.asarray(props[('Background', 'Bottom Color')])
+        self.bg_color_bottom(color / 255.)
+
+        self.floor_level(props[('Floor', 'Level')])
+        color = np.asarray(props[('Floor', 'Color')])
+        self.floor_color(color / 255.)
+
+        self.show_grid(props[('Infos', 'Grid')])
+        self.show_axis(props[('Infos', 'Axis')])
+        self.show_info(props[('Infos', 'values')])
+
+        self.point_size = props[('Points', 'Size')]
+
+        codes_sel = props[('Selection', 'Codes')]
+        codes_sel = codes_sel.split(',')
+        try:
+            self._select_only_codes = list(set([int(curcode) for curcode in codes_sel]))
+        except Exception as e:
+            logging.error(e)
+            logging.warning(_('Nullify selection filter - Check your input'))
+            self._select_only_codes = []
+
+        # self._auto_update_interval = props[('Auto Update', 'Interval')]
+        # self._auto_update_properties = props[('Auto Update', 'Active')]
+
+        # if self._auto_update_properties:
+        #     self.SetTimer(self._auto_update_interval)
+        # else:
+        #     if self._timer is not None:
+        #         self._timer.Stop()
+
+    def _fill_props(self, full:bool = False):
+
+        if self._myprops is None:
+            return
+
+        props = self._myprops
+
+        props[('Look at', 'X')] = self.lookat[0]
+        props[('Look at', 'Y')] = self.lookat[1]
+        props[('Look at', 'Z')] = self.lookat[2]
+
+        props[('Camera', 'X')] = self.eye[0]
+        props[('Camera', 'Y')] = self.eye[1]
+        props[('Camera', 'Z')] = self.eye[2]
+
+        props[('Relative Position', 'Phi')] = self.phi
+        props[('Relative Position', 'Theta')] = self.theta
+        props[('Relative Position', 'R')] = self.r
+
+        if full:
+
+            props[('Background', 'Color')] = self._bg_color
+            props[('Background', 'Top Color')] = self._bg_color_top
+            props[('Background', 'Bottom Color')] = self._bg_color_bottom
+
+            props[('Floor', 'Level')] = self._floor_level
+            props[('Floor', 'Color')] = self._floor_color
+
+            props[('Infos', 'Grid')] = self._show_grid
+            props[('Infos', 'Axis')] = self._show_axis
+            props[('Infos', 'values')] = self._show_info
+
+            props[('Points', 'Size')] = self._point_size
+
+            # props[('Auto Update', 'Interval')] = self._auto_update_interval
+            # props[('Auto Update', 'Active')] = self._auto_update_properties
+
+        props.Populate()
+
+    # def _fill_handler(self, event):
+
+    #     if self.viewer is None:
+    #         return
+
+    #     self._fill_props(full = False)
+
+    # def SetTimer(self, interval:int):
+
+    #     if self.viewer is None:
+    #         return
+
+    #     if self._timer is None:
+    #         self._timer = wx.Timer(self._myprops)
+    #         self._myprops.Bind(wx.EVT_TIMER, self._fill_handler, self._timer)
+
+    #     self._timer.Start(interval)
+
+    def show_properties(self):
+
+        if self.viewer is None:
+            return
+
+        self._create_props()
+        self._myprops.Show()
+
 def find_pointsXYZ(xyz:np.ndarray, bounds:Union[tuple[tuple[float,float],tuple[float,float]], list[list[float, float],list[float, float]]]) -> np.ndarray:
 
     xb=bounds[0]
@@ -1092,7 +1733,7 @@ def myviewer(las:Union[np.ndarray, list[laspy.LasData], laspy.LasData], which_co
 
     colors = get_colors(las, which_colors, fname=fname, palette_classif= palette_classif)
 
-    v=viewer(xyz,colors)
+    v = viewer(xyz,colors)
     v.set(point_size=.05)
     return v