wolfhece 2.1.117__py3-none-any.whl → 2.1.119__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,11 @@ from . import viewer
 from ..PyWMS import getWalonmap
 from ..PyTranslate import _
 from ..color_constants import Colors
-from ..PyParams import Wolf_Param
-from ..matplotlib_fig import Matplotlib_Figure as mplfig
+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
+from ..PyVertexvectors import vector, Zones, zone, wolfvertex
 
 """
 Importation et visualisation de données LAS et LAZ
@@ -49,6 +52,7 @@ class Classification_LAZ():
         self.test_wx()
 
         self._choose_colors = None
+        self._viewer = None
 
     def test_wx(self):
         self.wx_exists = wx.App.Get() is not None
@@ -76,6 +80,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)],
@@ -146,7 +151,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
@@ -157,7 +162,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:
@@ -244,8 +249,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
 
@@ -395,7 +400,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):
@@ -405,7 +410,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:
@@ -481,7 +486,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)
 
 
@@ -632,7 +637,7 @@ 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 = MplFig()
         figmpl.presets()
         fig = figmpl.fig
         ax = figmpl.cur_ax
@@ -682,6 +687,873 @@ class xyz_laz_grids():
                                                             gridsize=[max(int(dx/ds),1), max(int(dy/ds),1)],
                                                             force_format=force_format))
 
+
+class Wolf_LAZ_Data(Element_To_Draw):
+    """ Base class for LAZ data which can be imported in Pydraw.Mapviewer.
+    """
+
+    def __init__(self, idx:str = '', plotted:bool = False, mapviewer = None, need_for_wx:bool = False) -> None:
+
+        self._filename:Path = Path('') # filename TODO : improve serialization
+        self._lazfile:Path = None # Not used
+
+        # Bounds must be set before calling super().__init__() because
+        # xmin, xmax, ymin, ymax properties are used and depend on _bounds
+        self._bounds = [[0.,0.],[0.,0.]] # [[xmin,xmax],[ymin,ymax]]
+
+        super().__init__(idx, plotted, mapviewer, need_for_wx)
+
+        self._data:np.ndarray = None    # Numpy data array -- to be plotted
+        self._colors:np.ndarray = None  # NumPy array of colors for each point --> see viewer attributes for details
+        self.classification = Classification_LAZ() # Classification of LAZ data --> defining colors if codification is used
+
+        self._associated_color:int = Colors_Lazviewer.CODE_2023.value # Associated color type for LAZ data
+
+        self.viewer:viewer = None       # PPTK viewer
+
+        self._point_size = .05 # Point size in viewer -- in user units
+
+        self._flight_memory = [] # Flight position
+
+        self._myprops = None # Properties based on Wolf_Param class
+
+        self._bg_color = [int(0.23*255), int(0.23*255), int(.44*255), 255]  # Background color
+        self._bg_color_top = [0, 0, 0, 255]  # Top background color
+        self._bg_color_bottom = [int(0.23*255), int(0.23*255), int(.44*255), 255]  # Bottom background color
+
+        self._floor_level = 0.  # Floor level -- user units
+        self._floor_color = [int(0.3*255), int(0.3*255), int(.3*255), 127] # Floor color
+
+        self._show_grid = True # Show grid in viewer
+        self._show_axis = True # Show axis in viewer
+        self._show_info = True # Show info in viewer
+
+        self._select_only_codes = [] # Codes to be selected -- Defined by user
+
+        self._xls:CpGrid = None # Excel grid for selected data
+        self._xlsFrame:wx.Frame = None # Frame containing the xls grid
+
+    def serialize(self):
+        """ Serialize class : data and attributes """
+        return {'bounds':self._bounds, 'data':str(self._filename) + '.npz', 'associated_color':self._associated_color,
+                'point_size':self._point_size, 'bg_color':self._bg_color, 'bg_color_top':self._bg_color_top,
+                'bg_color_bottom':self._bg_color_bottom, 'floor_level':self._floor_level, 'floor_color':self._floor_color,
+                'show_grid':self._show_grid, 'show_axis':self._show_axis, 'show_info':self._show_info}
+
+    def deserialize(self, data:dict):
+        """ Deserialize class : data and attributes """
+        self._bounds = data['bounds']
+        self._filename = Path(data['data'])
+        self._associated_color = data['associated_color']
+        self._point_size = data['point_size']
+        self._bg_color = data['bg_color']
+        self._bg_color_top = data['bg_color_top']
+        self._bg_color_bottom = data['bg_color_bottom']
+        self._floor_level = data['floor_level']
+        self._floor_color = data['floor_color']
+        self._show_grid = data['show_grid']
+        self._show_axis = data['show_axis']
+        self._show_info = data['show_info']
+
+        self.data = np.load(self._filename)['data']
+
+    def saveas(self, fn:str):
+        """ Save class : data and attributes """
+        import pickle
+
+        self._filename = Path(fn)
+
+        with open(fn,'wb') as f:
+            pickle.dump(self.serialize(),f)
+
+        # save data by numpy
+        np.savez(str(fn) + '.npz', data=self._data)
+
+    def load(self, fn:str):
+        """ Load class : data and attributes """
+        import pickle
+
+        with open(fn,'rb') as f:
+            self.deserialize(pickle.load(f))
+
+    @property
+    def associated_color(self):
+        return self._associated_color
+
+    @associated_color.setter
+    def associated_color(self, value:int):
+        self._associated_color = value
+        self.set_colors()
+
+    def merge(self, other:"Wolf_LAZ_Data"):
+        """ Merge two Wolf_LAZ_Data objects """
+
+        if self._data is None:
+            self._data = other._data
+        else:
+            self._data = np.concatenate((self._data, other._data))
+
+        self.bounds = [[min(self.bounds[0][0],other.bounds[0][0]),max(self.bounds[0][1],other.bounds[0][1])],
+                       [min(self.bounds[1][0],other.bounds[1][0]),max(self.bounds[1][1],other.bounds[1][1])]]
+
+    def filter_data(self, codes:list[int]):
+        """ Filter data by codes """
+        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 = float(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 = bool(value))
+
+    def show_axis(self, value:bool):
+        if self.viewer is not None:
+            return self.viewer.set(show_axis = bool(value))
+
+    def show_info(self, value:bool):
+        if self.viewer is not None:
+            return self.viewer.set(show_info = bool(value))
+
+    def force_view(self, x, y, z = -1):
+        """ Force lookat position """
+        if z == -1:
+            curx,cury,curz = self.lookat
+            self.lookat = [x,y,curz]
+        else:
+            self.lookat = [x,y,z]
+        # self.eye = self._eye_pos()
+
+    @property
+    def selected(self):
+        if self.viewer is None:
+            return None
+        return self.viewer.get('selected')
+
+    @property
+    def xyz_selected(self) -> np.ndarray:
+        """ Extract the selected points from the viewer.
+
+        Filter the selected points by codes if _select_only_codes is not empty."""
+
+        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 - alias of num_points """
+        return self.num_points
+
+    @property
+    def nb(self):
+        """ Number of points - alias of num_points """
+        return self.num_points
+
+    @property
+    def right(self):
+        """Camera Right vector """
+        return self.viewer.get('right')
+
+    @property
+    def mvp(self):
+        """ Model View Projection matrix
+
+        See https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93projection_matrix for details
+        """
+
+        if self.viewer is None:
+            return None
+        return self.viewer.get('mvp')
+
+    @property
+    def eye(self):
+        """ eye/camera position """
+        if self.viewer is None:
+            return None
+        return self.viewer.get('eye')
+
+    @property
+    def lookat(self):
+        """ Lookat position """
+        if self.viewer is None:
+            return None
+        return self.viewer.get('lookat')
+
+    @property
+    def phi(self):
+        """ Azimuth angle (radians) """
+        if self.viewer is None:
+            return None
+        return self.viewer.get('phi')[0]
+
+    @property
+    def theta(self):
+        """ Elevation angle (radians) """
+        if self.viewer is None:
+            return None
+        return self.viewer.get('theta')[0]
+
+    @property
+    def r(self):
+        """ Distance from lookat """
+        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)
+        self._fill_props()
+
+    @theta.setter
+    def theta(self, value):
+        if self.viewer is None:
+            return None
+        self.viewer.set(theta=value)
+        self._fill_props()
+
+    @r.setter
+    def r(self, value):
+        if self.viewer is None:
+            return None
+        self.viewer.set(r=value)
+        self._fill_props()
+
+    @lookat.setter
+    def lookat(self, value):
+        if self.viewer is None:
+            return None
+        self.viewer.set(lookat=value)
+        # self.viewer.set(lookat=value, phi=self.phi, theta=self.theta, r=self.r)
+        self._fill_props()
+
+    def _eye_pos(self):
+        """ Compute eye pos from lookat and r, phi, theta.
+
+        phi is the azimuth angle (radians)
+        theta is the elevation angle (radians)
+        r is the distance from lookat
+        """
+
+        lx, ly, lz = self.lookat
+        r = self.r
+        phi = self.phi
+        theta = self.theta
+
+        x = lx + r*np.sin(phi)*np.cos(theta)
+        y = ly + r*np.cos(phi)*np.cos(theta)
+        z = lz + r*np.sin(theta)
+
+        return [x,y,z]
+
+    @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.theta = np.arcsin((z-lz)/r)
+        self.phi = -np.arctan2((x-lx),(y-ly))
+        self._fill_props()
+
+    @property
+    def point_size(self):
+        """ Point size in viewer -- user units """
+        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)
+            self._fill_props()
+
+    @property
+    def xyz(self):
+        return self.data[:,:3]
+
+    @property
+    def codes(self):
+        return self.data[:,3]
+
+    def codes_unique(self):
+        """ Only unique codes """
+        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 classification is not None:
+            self.classification = classification
+
+        if color_code is not None:
+            self.associated_color = color_code
+
+        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):
+        """ Create a frame to interactively update colors """
+
+        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):
+        """ Set colors in viewer --> using attributes method (not colormap) """
+
+        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):
+        """ Set classification of LAZ data
+
+        TODO : Check if 2020-2022 SPW campaign is the same classification as 2013
+        """
+        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):
+        """ Find min and max of data """
+        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):
+        """ Full data array (x,y,z,code) """
+        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]]]):
+        """ Create data from grid LAZ """
+        self.bounds = bounds
+        self.data = grid.scan(bounds)
+
+    def from_file(self, fn:str):
+        """ Create data from LAZ file """
+        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 descimate(self, step:int):
+        """ Descimate data.
+
+        Conserve only one point every 'step' points.
+
+        :param step: step of descimation
+        """
+        self.data = self.data[::step]
+
+    def get_data_class(self, key:int):
+        """ Get data with a specific code """
+
+        assert isinstance(key, int), _('Key must be an integer')
+
+        return self.data[self.data[:,3] == key]
+
+    def add_pose_in_memory(self, key_time:float = 1.):
+        """ Add current pose in flight memory """
+
+        if self.viewer is not None:
+            lookat = self.lookat
+            new_pose = (lookat[0], lookat[1], lookat[2], self.phi, self.theta, self.r)
+            self._flight_memory.append((new_pose, key_time))
+
+    def play_flight(self, tlim=[-np.inf, np.inf], repeat=False, interp='cubic_natural'):
+        """ Play flight memory """
+        if self.viewer is not None:
+            if len(self._flight_memory)>0:
+                poses = [cur[0] for cur in self._flight_memory]
+                times = [0.]
+                for i in range(1,len(self._flight_memory)):
+                    times.append(times[-1]+self._flight_memory[i][1])
+                self.viewer.play(poses, times, tlim, repeat, interp)
+
+    def set_times(self, times:np.ndarray):
+        """ Set times for flight memory """
+        if len(self._flight_memory)>0:
+            self._flight_memory = [(self._flight_memory[i][0], times[i]) for i in range(len(self._flight_memory))]
+
+    def set_times_increment(self, increment:float):
+        if len(self._flight_memory)>0:
+            self._flight_memory = [(self._flight_memory[i][0], increment*i) for i in range(len(self._flight_memory))]
+
+    def get_times(self):
+        return np.asarray([cur[1] for cur in self._flight_memory])
+
+    def record_flight(self, dirout:str, tlim=[-np.inf, np.inf], interp='cubic_natural', fps=24, prefix:str = 'laz_', ext:str = 'png'):
+        """ Record flight memory in multiple images
+
+        FIXME : FREEZE the app --> to debug
+        """
+        if self.viewer is not None:
+            if len(self._flight_memory)>0:
+                poses = [cur[0] for cur in self._flight_memory]
+                times = [0.]
+                for i in range(1,len(self._flight_memory)):
+                    times.append(times[-1]+self._flight_memory[i][1])
+                self.viewer.record(dirout, poses, times, tlim, interp, fps=fps, prefix=prefix, ext=ext)
+
+    def save_flight(self, fn:str):
+        """ Write flight memory to file JSON """
+
+        import json
+
+        if len(self._flight_memory)>0:
+            with open(fn,'w') as f:
+                json.dump(self._flight_memory, f, indent=2)
+
+    def load_flight(self, fn:str):
+        """ Load flight memory from file JSON """
+        import json
+
+        if exists(fn):
+            with open(fn,'r') as f:
+                self._flight_memory = json.load(f)
+
+
+    def _callback_props(self):
+
+        self._update_viewer()
+
+    def _callback_destroy_props(self):
+
+        if self._myprops is not None:
+            # self._callback_props()
+            self._myprops.Destroy()
+            self._myprops = None
+
+    def _create_props(self):
+        """ Create properties Wolf_Param for LAZ data """
+
+        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')
+
+        props.Populate()
+
+        updatebutton = wx.Button(props, label=_('Get from viewer'))
+        props.sizerbut.Add(updatebutton,1,wx.EXPAND)
+        updatebutton.Bind(wx.EVT_BUTTON, self._fill_props)
+
+        getselection = wx.Button(props, label=_('Edit selection'))
+        props.sizerbut.Add(getselection,1,wx.EXPAND)
+        getselection.Bind(wx.EVT_BUTTON, self._OnEdit_Selection)
+
+        props.Layout()
+
+    def _set_new_xls(self):
+        """ Create a new Excel grid for selected data """
+
+        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(10, 4)
+
+        # Add a button to plot a histogram
+        but_sizer = wx.BoxSizer(wx.HORIZONTAL)
+        plotbutton = wx.Button(self._xlsFrame, label=_('Plot histogram (All data)'))
+        but_sizer.Add(plotbutton, 1, wx.EXPAND)
+        plotbutton.Bind(wx.EVT_BUTTON, self.OnPlot_histogram)
+
+        plotbutton2 = wx.Button(self._xlsFrame, label=_('Plot histogram (Grid data)'))
+        but_sizer.Add(plotbutton2, 1, wx.EXPAND)
+        plotbutton2.Bind(wx.EVT_BUTTON, self.OnPlot_histogram_grid)
+
+        sizer.Add(but_sizer, 0, wx.EXPAND)
+
+        self._xlsFrame.SetSizer(sizer)
+        self._xlsFrame.Layout()
+        self._xlsFrame.Show()
+
+        icon = wx.Icon()
+        icon_path = Path(__file__).parent.parent / "apps/wolf_logo2.bmp"
+        icon.CopyFromBitmap(wx.Bitmap(str(icon_path), wx.BITMAP_TYPE_ANY))
+        self._xlsFrame.SetIcon(icon)
+
+    def OnPlot_histogram(self, event:wx.MouseEvent):
+        """ Plot histogram of selected data """
+        self._plot_histogram()
+
+    def OnPlot_histogram_grid(self, event:wx.MouseEvent):
+        """ Plot histogram of selected data """
+        self._plot_histogram_grid()
+
+    def _plot_histogram_grid(self):
+        """ Histogram ONLY of selected data in grid.
+
+        The data are extracted based on the first column of the grid
+        untile an empty cell is found.
+        """
+
+        xls = self._xls
+
+        if xls is None:
+            logging.warning(_('No Excel grid'))
+            return
+
+        # Find not null cells
+        nbrows = 1
+
+        while xls.GetCellValue(nbrows,0) != '' and nbrows < xls.NumberRows:
+            nbrows += 1
+
+        if nbrows == 1:
+            logging.warning(_('Nt enough points selected'))
+            return
+
+        xyz = np.zeros((nbrows,3))
+        codes = np.zeros(nbrows)
+
+        try:
+            for i in range(nbrows):
+                xyz[i,0] = float(xls.GetCellValue(i,0))
+                xyz[i,1] = float(xls.GetCellValue(i,1))
+                xyz[i,2] = float(xls.GetCellValue(i,2))
+                codes[i] = int(xls.GetCellValue(i,3))
+        except Exception as e:
+            logging.error(e)
+            logging.warning(_('Bad values in grid - Check your input'))
+            return
+
+        fig = plt.figure()
+
+        ax = fig.add_subplot(111)
+
+        ax.hist(xyz[:,2], bins=256)
+
+        fig.show()
+
+    def _plot_histogram(self):
+        """ """
+
+        xyz = self.xyz_selected
+
+        if xyz.shape[0]==0:
+            logging.warning(_('No points selected'))
+            return
+
+        fig = plt.figure()
+
+        ax = fig.add_subplot(111)
+
+        ax.hist(xyz[:,2], bins=256)
+
+        fig.show()
+
+    def _selection2vector(self):
+        """ FIXME: must use RANSAC to compute a segment from the selected points """
+
+        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
+
+        vect = vector(name = self.idx + '_selection', fromnumpy=xyz)
+
+        return vect
+
+
+    def _OnEdit_Selection(self, event:wx.MouseEvent):
+        """ Get selection from viewer and create a XLS grid """
+        self._edit_selection()
+
+    def _edit_selection(self):
+
+        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._set_new_xls()
+        else:
+            try:
+                self._xls.ClearGrid()
+            except:
+                #Useful if the grid is already destroyed
+                self._set_new_xls()
+
+        nbclass = len(self.classification.classification)
+        min_rows = xyz.shape[0] + nbclass +1
+        if self._xls.NumberRows < min_rows:
+            self._xls.AppendRows(min_rows - 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_viewer(self):
+        """ Update the viewer with properties """
+
+        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 = []
+
+    def _fill_props(self, full:bool = False):
+        """ Fill properties from attributes """
+        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.Populate()
+
+    def show_properties(self):
+        """ Surcharged method (see Element_To_Draw) to show properties from MapViewer"""
+        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]
@@ -1096,7 +1968,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