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

wolfhece/lazviewer/laz_viewer.py

@@ -23,9 +23,10 @@ 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
 
 """
 Importation et visualisation de données LAS et LAZ
@@ -374,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):
@@ -493,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()
 
@@ -526,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)
 
@@ -636,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()
@@ -687,49 +744,116 @@ class xyz_laz_grids():
                                                             force_format=force_format))
 
 
-class Base_LAZ_Data(Element_To_Draw):
+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.lazfile:Path = None
-        self._data:np.ndarray = None
-        self.classification = Classification_LAZ()
+        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
+        self._associated_color:int = Colors_Lazviewer.CODE_2023.value # Associated color type for LAZ data
 
-        self.viewer:viewer = None
-        self._colors:np.ndarray = None
+        self.viewer:viewer = None       # PPTK viewer
 
-        self._point_size = .05
+        self._point_size = .05 # Point size in viewer -- in user units
 
-        self._memory = []
+        self._flight_memory = [] # Flight position
 
-        self._myprops = None
+        self._myprops = None # Properties based on Wolf_Param class
 
-        self._bg_color = [0,0,0,255]
-        self._bg_color_top = [0,0,0,255]
-        self._bg_color_bottom = [0,0,0,255]
+        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.
-        self._floor_color = [0,0,0,255]
+        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
-        self._show_axis = True
-        self._show_info = True
+        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 = []
+        self._select_only_codes = [] # Codes to be selected -- Defined by user
 
-        self._xls:CpGrid = None
-        self._xlsFrame:wx.Frame = None
+        self._xls:CpGrid = None # Excel grid for selected data
+        self._xlsFrame:wx.Frame = None # Frame containing the xls grid
 
-        # self._auto_update_properties = False
-        # self._auto_update_interval = 100 # ms
-        # self._timer = None
+    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):
@@ -746,7 +870,7 @@ class Base_LAZ_Data(Element_To_Draw):
 
     def floor_level(self, value):
         if self.viewer is not None:
-            return self.viewer.set(floor_level = value)
+            return self.viewer.set(floor_level = float(value))
 
     def floor_color(self, value):
         if self.viewer is not None:
@@ -754,15 +878,24 @@ class Base_LAZ_Data(Element_To_Draw):
 
     def show_grid(self, value:bool):
         if self.viewer is not None:
-            return self.viewer.set(show_grid = value)
+            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 = value)
+            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 = value)
+            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):
@@ -772,6 +905,10 @@ class Base_LAZ_Data(Element_To_Draw):
 
     @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
 
@@ -799,21 +936,25 @@ class Base_LAZ_Data(Element_To_Draw):
     @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')
-
+            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
     def nb_points(self):
-        """ Number of points """
+        """ Number of points - alias of num_points """
         return self.num_points
 
     @property
     def nb(self):
-        """ Number of points """
+        """ Number of points - alias of num_points """
         return self.num_points
 
     @property
@@ -823,36 +964,46 @@ class Base_LAZ_Data(Element_To_Draw):
 
     @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]
@@ -862,24 +1013,48 @@ class Base_LAZ_Data(Element_To_Draw):
         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):
@@ -892,11 +1067,13 @@ class Base_LAZ_Data(Element_To_Draw):
         # 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))
+        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
@@ -904,6 +1081,7 @@ class Base_LAZ_Data(Element_To_Draw):
         self._point_size = value
         if self.viewer is not None:
             self.viewer.set(point_size=value)
+            self._fill_props()
 
     @property
     def xyz(self):
@@ -914,17 +1092,18 @@ class Base_LAZ_Data(Element_To_Draw):
         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 color_code is not None:
-            self.associated_color = color_code
-
         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)
@@ -933,6 +1112,7 @@ class Base_LAZ_Data(Element_To_Draw):
         return self.viewer
 
     def interactive_update_colors(self):
+        """ Create a frame to interactively update colors """
 
         self.classification.interactive_update_colors()
 
@@ -945,12 +1125,17 @@ class Base_LAZ_Data(Element_To_Draw):
         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':
@@ -959,6 +1144,7 @@ class Base_LAZ_Data(Element_To_Draw):
             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])]]
 
@@ -996,6 +1182,7 @@ class Base_LAZ_Data(Element_To_Draw):
 
     @property
     def data(self):
+        """ Full data array (x,y,z,code) """
         return self._data
 
     @data.setter
@@ -1010,87 +1197,106 @@ class Base_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)
 
     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 decimate(self, step:int):
+    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._memory.append((new_pose, key_time))
+            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._memory)>0:
-                poses = [cur[0] for cur in self._memory]
+            if len(self._flight_memory)>0:
+                poses = [cur[0] for cur in self._flight_memory]
                 times = [0.]
-                for i in range(1,len(self._memory)):
-                    times.append(times[-1]+self._memory[i][1])
+                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):
-        if len(self._memory)>0:
-            self._memory = [(self._memory[i][0], times[i]) for i in range(len(self._memory))]
+        """ 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._memory)>0:
-            self._memory = [(self._memory[i][0], increment*i) for i in range(len(self._memory))]
+        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._memory])
+        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
 
-    def record_flight(self, dirout:str, tlim=[-np.inf, np.inf], interp='cubic_natural', fps=24, prefix:str = 'laz_', ext:str = '.png'):
+        FIXME : FREEZE the app --> to debug
+        """
         if self.viewer is not None:
-            if len(self._memory)>0:
-                poses = [cur[0] for cur in self._memory]
+            if len(self._flight_memory)>0:
+                poses = [cur[0] for cur in self._flight_memory]
                 times = [0.]
-                for i in range(1,len(self._memory)):
-                    times.append(times[-1]+self._memory[i][1])
+                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 memory to file JSON """
+        """ Write flight memory to file JSON """
+
         import json
 
-        if len(self._memory)>0:
+        if len(self._flight_memory)>0:
             with open(fn,'w') as f:
-                json.dump(self._memory, f, indent=2)
+                json.dump(self._flight_memory, f, indent=2)
 
     def load_flight(self, fn:str):
-        """ Load memory from file JSON """
+        """ Load flight memory from file JSON """
         import json
 
         if exists(fn):
             with open(fn,'r') as f:
-                self._memory = json.load(f)
+                self._flight_memory = json.load(f)
 
 
     def _callback_props(self):
 
-        self._update_props()
+        self._update_viewer()
 
     def _callback_destroy_props(self):
 
         if self._myprops is not None:
-            self._callback_props()
+            # 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
@@ -1134,22 +1340,123 @@ class Base_LAZ_Data(Element_To_Draw):
             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'))
+        updatebutton = wx.Button(props, label=_('Get from viewer'))
         props.sizerbut.Add(updatebutton,1,wx.EXPAND)
-        props.Bind(wx.EVT_BUTTON, self._fill_props, updatebutton)
+        updatebutton.Bind(wx.EVT_BUTTON, self._fill_props)
 
-        getselection = wx.Button(props, label=_('Get selection'))
+        getselection = wx.Button(props, label=_('Edit selection'))
         props.sizerbut.Add(getselection,1,wx.EXPAND)
-        props.Bind(wx.EVT_BUTTON, self._get_selection, getselection)
+        getselection.Bind(wx.EVT_BUTTON, self._OnEdit_Selection)
 
         props.Layout()
 
-    def _get_selection(self, event):
+    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'))
@@ -1161,24 +1468,40 @@ class Base_LAZ_Data(Element_To_Draw):
             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)
+        vect = vector(name = self.idx + '_selection', fromnumpy=xyz)
 
-            sizer = wx.BoxSizer(wx.VERTICAL)
-            sizer.Add(self._xls, 1, wx.EXPAND)
+        return vect
 
-            nbclass = len(self.classification.classification)
-            self._xls.CreateGrid(xyz.shape[0] + nbclass +1, 4)
 
-            self._xlsFrame.SetSizer(sizer)
-            self._xlsFrame.Layout()
-            self._xlsFrame.Show()
+    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:
-            self._xls.ClearGrid()
-            if self._xls.NumberRows < xyz.shape[0]:
-                self._xls.AppendRows(xyz.shape[0]-self._xls.NumberRows)
+            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')
@@ -1206,7 +1529,8 @@ class Base_LAZ_Data(Element_To_Draw):
         self._xlsFrame.Raise()
         self._xlsFrame.Center()
 
-    def _update_props(self):
+    def _update_viewer(self):
+        """ Update the viewer with properties """
 
         if self._myprops is None:
             return
@@ -1217,7 +1541,7 @@ class Base_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.)
@@ -1245,17 +1569,8 @@ class Base_LAZ_Data(Element_To_Draw):
             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):
-
+        """ Fill properties from attributes """
         if self._myprops is None:
             return
 
@@ -1288,31 +1603,10 @@ class Base_LAZ_Data(Element_To_Draw):
 
             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):
-
+        """ Surcharged method (see Element_To_Draw) to show properties from MapViewer"""
         if self.viewer is None:
             return