wolfhece 2.0.18__py3-none-any.whl → 2.0.19__py3-none-any.whl

wolfhece/PyDraw.py

@@ -1002,10 +1002,20 @@ class WolfMapViewer(wx.Frame):
             self.active_array.interpolate_on_triangulation(self.active_tri.pts, self.active_tri.tri, )
 
     def compare_cloud2array(self):
+        """
+        Compare the active cloud points to the active array
+
+        """
+
+        if self.active_array is None :
+            logging.warning(_('No active array -- Please activate an array first'))
+            return
 
-        if self.active_array is not None and self.active_cloud is not None:
+        if self.active_cloud is None:
+            logging.warning(_('No active cloud -- Please activate a cloud first'))
+            return
 
-            self.active_array.compare_cloud(self.active_cloud)
+        self.active_array.compare_cloud(self.active_cloud)
 
     def compare_tri2array(self):
 
@@ -1748,7 +1758,8 @@ class WolfMapViewer(wx.Frame):
                                '2012-2013': 'ORTHO_2012_2013',
                                '2015': 'ORTHO_2015', '2016': 'ORTHO_2016', '2017': 'ORTHO_2017',
                                '2018': 'ORTHO_2018', '2019': 'ORTHO_2019', '2020': 'ORTHO_2020',
-                               '2021': 'ORTHO_2021'}}
+                               '2021': 'ORTHO_2021', '2022 printemps': 'ORTHO_2022_PRINTEMPS', '2022 été': 'ORTHO_2022_ETE',
+                               '2023 été': 'ORTHO_2023_ETE'}}
         for idx, (k, item) in enumerate(orthos.items()):
             for kdx, (m, subitem) in enumerate(item.items()):
                 self.add_object(which='wmsback',
@@ -2429,6 +2440,13 @@ class WolfMapViewer(wx.Frame):
                     else:
                         logging.info(_('Bad parameter in project file - array : ')+ curname[key_Param.VALUE])
 
+            if 'cloud' in myproject.myparams.keys():
+                for curid, curname in zip(myproject.myparams['cloud'].keys(), myproject.myparams['cloud'].values()):
+                    if exists(curname[key_Param.VALUE]):
+                        mycloud = cloud_vertices(curname[key_Param.VALUE])
+                        self.add_object('cloud', newobj=mycloud, id=curid)
+                    else:
+                        logging.info(_('Bad parameter in project file - cloud : ')+ curname[key_Param.VALUE])
 
             if 'wolf2d' in myproject.myparams.keys():
                 for curid, curname in zip(myproject.myparams['wolf2d'].keys(), myproject.myparams['wolf2d'].values()):
@@ -3005,15 +3023,66 @@ class WolfMapViewer(wx.Frame):
 
         elif itemlabel == _("Plot active vector..."):
 
+
             if self.active_vector is None:
+                logging.warning(_('No active vector !'))
                 return
 
+            add_cloud = False
+            if self.active_cloud is not None:
+                dlg = wx.MessageDialog(self, _('Do you want to plot the cloud ?'), style=wx.YES_NO)
+
+                if dlg.ShowModal() == wx.ID_YES:
+                    add_cloud = True
+
+                    prox = wx.TextEntryDialog(None,_('Proximity [m] ?'), value = '5.0')
+                    ret = prox.ShowModal()
+                    if ret == wx.ID_CANCEL:
+                        prox.Destroy()
+                        return
+                    try:
+                        proxval = float(prox.GetValue())
+                    except:
+                        prox.Destroy()
+                        logging.warning(_('Bad value -- Rety'))
+                        return
+
+                    tol = wx.TextEntryDialog(None,_('Tolerance [m] ?'), value = '0.5')
+                    ret = tol.ShowModal()
+                    if ret == wx.ID_CANCEL:
+                        tol.Destroy()
+                        return
+                    try:
+                        tolval = float(tol.GetValue())
+                    except:
+                        tol.Destroy()
+                        logging.warning(_('Bad value -- Rety'))
+                        return
+
+                else:
+                    add_cloud = False
+
+                dlg.Destroy()
+
             fig, ax = self.active_vector.plot_mpl(True, False)
 
             linkedarrays = self.get_linked_arrays()
 
             self.active_vector.plot_linked(fig, ax, linkedarrays)
 
+            if add_cloud:
+                s, z = self.active_cloud.projectontrace(self.active_vector, return_cloud=False, proximity= proxval)
+
+                ax.scatter( s, z, c='black', s=1.0)
+
+                for curs, curz in zip(s,z):
+                    ax.plot([curs, curs], [curz-tolval, curz+tolval], 'k--', linewidth=0.5)
+                    ax.plot([curs-.1, curs+.1], [curz+tolval, curz+tolval], c='black', linewidth=0.5)
+                    ax.plot([curs-.1, curs+.1], [curz-tolval, curz-tolval], c='black', linewidth=0.5)
+
+                fig.canvas.draw()
+                fig.canvas.flush_events()
+
         elif itemlabel == _("Export arrays as Geotif..."):
 
             self.export_results_as('geotiff')
@@ -4268,9 +4337,10 @@ class WolfMapViewer(wx.Frame):
         filterall = "all (*.*)|*.*"
         filterres2d = "all (*.*)|*.*"
         filterVector = "vec (*.vec)|*.vec|vecz (*.vecz)|*.vecz|dxf (*.dxf)|*.dxf|shp (*.shp)|*.shp|all (*.*)|*.*"
-        filterCloud = "xyz (*.xyz)|*.xyz|dxf (*.dxf)|*.dxf|text (*.txt)|*.txt|all (*.*)|*.*"
+        filterCloud = "xyz (*.xyz)|*.xyz|dxf (*.dxf)|*.dxf|text (*.txt)|*.txt|shp (*.shp)|*.shp|all (*.*)|*.*"
         filtertri = "tri (*.tri)|*.tri|text (*.txt)|*.txt|dxf (*.dxf)|*.dxf|gltf (*.gltf)|*.gltf|gltf binary (*.glb)|*.glb|*.*'all (*.*)|*.*"
         filterCs = "vecz WOLF (*.vecz)|*.vecz|txt 2022 (*.txt)|*.txt|WOLF (*.sxy)|*.sxy|text 2000 (*.txt)|*.txt|all (*.*)|*.*"
+        filterimage = "Geotif (*.tif)|*.tif|all (*.*)|*.*"
 
         if filename == '' and newobj is None:
             # ouverture d'une boîte de dialogue
@@ -4303,9 +4373,9 @@ class WolfMapViewer(wx.Frame):
 
             # FIXME : particularize filters for wmsback and wmsfore
             elif which.lower() == 'wmsback':
-                file = wx.FileDialog(self, "Choose file", wildcard=filterCloud)
+                file = wx.FileDialog(self, "Choose file", wildcard=filterimage)
             elif which.lower() == 'wmsfore':
-                file = wx.FileDialog(self, "Choose file", wildcard=filterCloud)
+                file = wx.FileDialog(self, "Choose file", wildcard=filterimage)
 
             if file.ShowModal() == wx.ID_CANCEL:
                 file.Destroy()
@@ -4718,12 +4788,13 @@ class WolfMapViewer(wx.Frame):
             newobj.mapviewer = self
 
         elif which.lower() == 'cloud':
+
             curdict = self.myclouds
             curtree = self.myitemscloud
             if newobj is None:
 
                 loadhead = False
-                if not filename.endswith('.dxf'):
+                if not filename.endswith('.dxf') and not filename.endswith('.shp'):
                     with open(filename,'r') as f:
                         text=f.read().splitlines()
                         tmphead=''
@@ -4738,7 +4809,7 @@ class WolfMapViewer(wx.Frame):
 
                 with wx.lib.busy.BusyInfo(_('Importing cloud points')):
                     wait = wx.BusyCursor()
-                    newobj = cloud_vertices(filename,header=loadhead)
+                    newobj = cloud_vertices(filename, header=loadhead)
                     del wait
 
             self.myclouds.append(newobj)
@@ -6681,6 +6752,7 @@ class WolfMapViewer(wx.Frame):
                 self.active_tile = None
                 self.active_particle_system = None
                 self.active_vertex = None
+                self.active_cloud = None
 
             elif key == ord('C'):
 

wolfhece/PyParams.py

@@ -271,7 +271,8 @@ class Wolf_Param(wx.Frame):
                  withbuttons: bool = True,
                  DestroyAtClosing:bool = True,
                  toShow:bool = True,
-                 init_GUI:bool = True):
+                 init_GUI:bool = True,
+                 force_even_if_same_default:bool = False):
         """
         Initialisation
 
@@ -285,7 +286,7 @@ class Wolf_Param(wx.Frame):
         :param withbuttons : if True, buttons will be displayed
         :param DestroyAtClosing : if True, the frame will be destroyed when closed
         :param toShow : if True, the frame will be displayed
-
+        :param force_even_if_same_default : if True, the parameter will be displayed even if the default and active parameters are the same
 
         Callbacks (see 'set_callbacks'):
             - callback : callback function when 'apply' is pressed
@@ -305,7 +306,7 @@ class Wolf_Param(wx.Frame):
         self._callbackdestroy:function = None
 
         self.wx_exists = wx.App.Get() is not None # test if wx App is running
-        self.show_in_active_if_default = False
+        self.show_in_active_if_default = force_even_if_same_default
 
         if to_read:
             self.ReadFile(filename)
@@ -457,6 +458,8 @@ class Wolf_Param(wx.Frame):
         self.SetAutoLayout(1)
         self.sizer.Fit(self)
 
+        self.SetSize(0,0,w,h)
+
         #affichage de la page
         self.Show(toShow)
 
@@ -518,9 +521,13 @@ class Wolf_Param(wx.Frame):
                 page_active.Append(pg.PropertyCategory(groupname))
 
             #teste si param existe
-            if not self.is_in_active(groupname, paramname):
+            activeprop = self.prop.GetPropertyByName(groupname + paramname)
+            if activeprop is None:
                 #si non existant --> on ajoute, si existant --> rien à faire
-                self._add_elem_to_page(page_active, groupname, param_def)
+                self._insert_elem_to_page(page_active, groupname, param_def)
+            # if not self.is_in_active(groupname, paramname):
+            #     #si non existant --> on ajoute, si existant --> rien à faire
+            #     self._add_elem_to_page(page_active, groupname, param_def)
 
         else:
             #recopiage de la valeur par défaut
@@ -571,6 +578,16 @@ class Wolf_Param(wx.Frame):
         # populate the property grid
         self.Populate()
 
+    def _get_prop_names(self, page:pg.PropertyGridPage) -> list[str]:
+        """ Return the names of the properties in a page """
+
+        return [prop.GetName() for prop in page.GetPyIterator(pg.PG_ITERATE_ALL)]
+
+    def _is_in_propperty_page(self, page:pg.PropertyGridPage, group:str, param:str="") -> bool:
+        """ Test if a parameter is in a page """
+
+        return (group + param) in self._get_prop_names(page)
+
     def ApplytoMemory(self, event:wx.MouseEvent):
         """ Transfert des données en mémoire --> remplissage des dictionnaires """
 
@@ -585,7 +602,19 @@ class Wolf_Param(wx.Frame):
             if not self._callback is None:
                 self._callback()
         else:
-            wx.MessageDialog(self,'Nothing to do!')
+            if self.wx_exists:
+                dlg = wx.MessageDialog(self,'Nothing to do!')
+                dlg.ShowModal()
+
+    @property
+    def page_active(self) -> pg.PropertyGridPage:
+        """ Return the active page """
+        return self.prop.GetPage(0)
+
+    @property
+    def page_default(self) -> pg.PropertyGridPage:
+        """ Return the default page """
+        return self.prop.GetPage(1)
 
     def _Apply1ParamtoMemory(self,
                              group:str,
@@ -625,7 +654,8 @@ class Wolf_Param(wx.Frame):
             val_default = self.prop.GetPropertyByName(PREFIX_DEFAULT + group + param_name).m_value
 
             # on tente de rcupérer la valeur active mais il ets possible qu'elle n'existe pas si sa valeur est identique à la valeur par défaut
-            if self.is_in_active(group, param_name):
+            if self._is_in_propperty_page(self.page_active, group, param_name):
+            # if self.is_in_active(group, param_name):
                 val_active  = self.prop.GetPropertyByName(group + param_name).m_value
             else:
                 val_active = val_default
@@ -641,7 +671,8 @@ class Wolf_Param(wx.Frame):
         else:
             # La valeur par défaut n'existe pas --> on prend la valeur active car c'est certainement une valeur incrémentable ou d'un groupe incrémentable
             # Si la valeur n'est pas présente, on ne fait rien
-            if self.is_in_active(group, param_name):
+            if self._is_in_propperty_page(self.page_active, group, param_name):
+            # if self.is_in_active(group, param_name):
                 val_active  = self.prop.GetPropertyByName(group + param_name).m_value
                 val_active  = self.value_as_type(val_active, dict_param_def[key_Param.TYPE])
 
@@ -675,7 +706,9 @@ class Wolf_Param(wx.Frame):
 
         #gestion des paramètres actifs
         for group, params in self.myparams.items():
+
             page_active.Append(pg.PropertyCategory(group))
+
             for param_name, param in params.items():
                 param:dict
                 if self.is_in_default(group, param_name):
@@ -701,6 +734,63 @@ class Wolf_Param(wx.Frame):
         self.prop.ShowHeader()
         self.prop.Refresh()
 
+    def _insert_elem_to_page(self, page:pg.PropertyGridPage, group:str, param:dict, param_def:dict = None, prefix:str=''):
+        """ Insert an element to a page """
+
+        param_name = param[key_Param.NAME]
+        locname = prefix + group + param_name
+
+        # Get parent item based on group name
+        parent = page.GetPropertyByName(group)
+        assert parent is not None, "Group {} not found in page".format(group)
+        assert isinstance(parent, pg.PropertyCategory), "Parent is not a PropertyCategory"
+
+        if param_def is not None:
+            # priority to default parameters
+            if key_Param.ADDED_JSON in param_def.keys():
+                param[key_Param.ADDED_JSON] = param_def[key_Param.ADDED_JSON]
+            param[key_Param.COMMENT] = param_def[key_Param.COMMENT]
+            param[key_Param.TYPE] = param_def[key_Param.TYPE]
+
+        if key_Param.ADDED_JSON in param.keys() and param[key_Param.ADDED_JSON] is not None:
+            # Ajout des choix via chaîne JSON
+            list_keys   = [ k for k in param[key_Param.ADDED_JSON]['Values'].keys()]
+            list_values = [ k for k in param[key_Param.ADDED_JSON]['Values'].values()]
+
+            page.AppendIn(parent, pg.EnumProperty(param_name, name=locname, labels=list_keys, values=list_values, value=int(param[key_Param.VALUE])))
+
+            self.prop.SetPropertyHelpString(locname , param[key_Param.ADDED_JSON]['Full_Comment'])
+        else:
+
+            locvalue = self[(group, param_name)]
+
+            if isinstance(locvalue, float):
+                page.AppendIn(parent, pg.FloatProperty(label = param_name, name = locname, value = locvalue))
+
+            elif isinstance(locvalue, int):
+                # bool is also an int
+                if isinstance(locvalue, bool):
+                    page.AppendIn(parent, pg.BoolProperty(label=param_name, name = locname, value = locvalue))
+                else:
+                    page.AppendIn(parent, pg.IntProperty(label = param_name, name = locname, value = locvalue))
+
+            elif param[key_Param.TYPE]==Type_Param.File:
+                page.AppendIn(parent, pg.FileProperty(label=param_name, name = locname, value = param[key_Param.VALUE]))
+
+            elif param[key_Param.TYPE]==Type_Param.Directory:
+                page.AppendIn(parent, pg.DirProperty(label = param_name, name = locname, value = locvalue))
+
+            elif param[key_Param.TYPE]==Type_Param.Color:
+                page.AppendIn(parent, pg.ColourProperty(label = param_name, name = locname, value = locvalue))
+
+            elif param[key_Param.TYPE]==Type_Param.Fontname:
+                page.AppendIn(parent, pg.FontProperty(label = param_name, name = locname, value = locvalue))
+
+            else:
+                page.AppendIn(parent, pg.StringProperty(label = param_name, name = locname, value = locvalue))
+
+            self.prop.SetPropertyHelpString(locname, param[key_Param.COMMENT])
+
     def _add_elem_to_page(self, page:pg.PropertyGridPage, group:str, param:dict, param_def:dict = None, prefix:str=''):
         """ Add an element to a page """
 

wolfhece/PyVertex.py

@@ -9,12 +9,13 @@ except:
     raise Exception(msg)
 
 import math
-from shapely.geometry import Point, LineString
+from shapely.geometry import Point, LineString, MultiPoint
 from os.path import exists
 import wx
 import re
 import logging
 from scipy.spatial import KDTree
+from pathlib import Path
 
 from .PyParams import Wolf_Param, key_Param, Type_Param
 from .PyTranslate import _
@@ -121,6 +122,10 @@ class wolfvertex:
         self.y = min(self.y, bounds[1][1])
 
 class cloudproperties:
+    """
+    Properties of a cloud of vertices
+
+    """
     used: bool
 
     color: int
@@ -148,7 +153,7 @@ class cloudproperties:
 
     myprops: Wolf_Param = None
 
-    def __init__(self, lines=[], parent=None) -> None:
+    def __init__(self, lines=[], parent:"cloud_vertices"=None) -> None:
 
         self.parent = parent
 
@@ -251,8 +256,10 @@ class cloudproperties:
         if 'Draw' in curdict.keys():
             keysactive = curdict['Draw'].keys()
             if 'Color' in keysactive:
-                self.color = getIfromRGB(
-                    curdict['Draw']['Color'][key_Param.VALUE].replace('(', '').replace(')', '').split(', '))
+                if isinstance(curdict['Draw']['Color'][key_Param.VALUE], str):
+                    self.color = getIfromRGB(curdict['Draw']['Color'][key_Param.VALUE].replace('(', '').replace(')', '').split(', '))
+                elif isinstance(curdict['Draw']['Color'][key_Param.VALUE], tuple):
+                    self.color = getIfromRGB(curdict['Draw']['Color'][key_Param.VALUE])
             if 'Width' in keysactive:
                 self.width = int(curdict['Draw']['Width'][key_Param.VALUE])
             if 'Style' in keysactive:
@@ -277,8 +284,10 @@ class cloudproperties:
             if 'Font size' in keysactive:
                 self.legendfontsize = int(curdict['Legend']['Font size'][key_Param.VALUE])
             if 'Color' in keysactive:
-                self.legendcolor = getIfromRGB(
-                    curdict['Legend']['Color'][key_Param.VALUE].replace('(', '').replace(')', '').split(', '))
+                if isinstance(curdict['Legend']['Color'][key_Param.VALUE], str):
+                    self.legendcolor = getIfromRGB(curdict['Draw']['Color'][key_Param.VALUE].replace('(', '').replace(')', '').split(', '))
+                elif isinstance(curdict['Legend']['Color'][key_Param.VALUE], tuple):
+                    self.v = getIfromRGB(curdict['Draw']['Color'][key_Param.VALUE])
             if 'Italic' in keysactive:
                 self.legenditalic = bool(curdict['Legend']['Italic'][key_Param.VALUE])
             if 'relative Position' in keysactive:
@@ -294,9 +303,17 @@ class cloudproperties:
 
         self.parent.forceupdategl = True
 
+        if self.parent.mapviewer is not None:
+            self.parent.mapviewer.Refresh()
+
     def defaultprop(self):
+        """
+        Default properties
+
+        """
         if self.myprops is None:
-            self.myprops = Wolf_Param(title='Cloud Properties', to_read=False)
+            self.myprops = Wolf_Param(title='Cloud Properties', to_read=False, force_even_if_same_default=True)
+            self.myprops.hide_selected_buttons()
             self.myprops._callbackdestroy = self.destroyprop
             self.myprops._callback = self.fill_property
             self.myprops.saveme.Disable()
@@ -383,7 +400,7 @@ class cloud_vertices(Element_To_Draw):
 
     """
     filename: str
-    myvertices: dict
+    myvertices: dict[int, dict['vertex':wolfvertex, str:float]]
 
     xbounds: tuple
     ybounds: tuple
@@ -392,7 +409,28 @@ class cloud_vertices(Element_To_Draw):
     myprop: cloudproperties
     mytree : KDTree
 
-    def __init__(self, fname: str = '', fromxls: str = '', header: bool = False, toload=True, idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
+    def __init__(self,
+                 fname: str = '',
+                 fromxls: str = '',
+                 header: bool = False,
+                 toload=True,
+                 idx: str = '',
+                 plotted: bool = True,
+                 mapviewer=None,
+                 need_for_wx: bool = False) -> None:
+        """
+        Init cloud of vertices
+
+        :param fname: file name
+        :param fromxls: string read from xls file and to be parsed
+        :param header: header in file (first line with column names)
+        :param toload: load file at init
+        :param idx: identifier -- see Element_To_Draw
+        :param plotted: plot at init -- see Element_To_Draw
+        :param mapviewer: mapviewer -- see Element_To_Draw
+        :param need_for_wx: see Element_To_Draw
+        """
+
         super().__init__(idx, plotted, mapviewer, need_for_wx)
 
         self.myvertices = {}
@@ -416,8 +454,11 @@ class cloud_vertices(Element_To_Draw):
 
         if fname != '':
             if toload:
-                if fname[-4:].lower()=='.dxf':
+                if Path(fname).suffix.lower() == '.dxf':
+                # if fname[-4:].lower()=='.dxf':
                     self.import_from_dxf(fname)
+                elif Path(fname).suffix.lower() == '.shp':
+                    self.import_shapefile(fname)
                 else:
                     self.readfile(fname, header)
 
@@ -592,7 +633,14 @@ class cloud_vertices(Element_To_Draw):
             self.loaded = True
 
     def import_from_dxf(self,fn=''):
+        """
+        Importing DXF file using ezdxf library
+
+        :param fn: file name
+
+        """
         if fn == '' or not exists(fn):
+            logging.error(_('File not found : ')+fn)
             return
 
         import ezdxf
@@ -622,6 +670,57 @@ class cloud_vertices(Element_To_Draw):
 
         return k
 
+    def import_shapefile(self, fn='', targetcolumn:str = 'X1_Y1_Z1'):
+        """
+        Importing Shapefile using geopandas library
+
+        :param fn: file name
+        :param targetcolumn: column name to be used for XYZ coordinates -- 'X1_Y1_Z1' is used by SPW-ARNE-DCENN
+
+        """
+
+        if fn == '' or not exists(fn):
+            logging.error(_('File not found : ')+fn)
+            return
+
+        import geopandas as gpd
+
+        # read data
+        gdf = gpd.read_file(fn)
+
+        # Bouclage sur les éléments du Shapefile
+        if not targetcolumn in gdf.columns:
+
+            if self.wx_exists:
+
+                dlg = wx.SingleChoiceDialog(None, _('Choose the column to be used for XYZ coordinates'), _('Column choice'), gdf.columns)
+                if dlg.ShowModal() == wx.ID_OK:
+                    targetcolumn = dlg.GetStringSelection()
+                    dlg.Destroy()
+                else:
+                    dlg.Destroy()
+                    return
+
+        k=0
+        for index, row in gdf.iterrows():
+            x, y, z = row[targetcolumn].split(',')
+            x = float(x)
+            y = float(y)
+            z = float(z)
+
+            curvert = wolfvertex(x, y, z)
+            curdict = self.myvertices[k] = {}
+            curdict['vertex'] = curvert
+            k += 1
+
+        self.find_minmax(True)
+        self.loaded = True
+
+        logging.info(_('Number of imported points : ')+str(k))
+
+        return k
+
+
     def add_vertex(self, vertextoadd: wolfvertex = None, id=None, cloud: dict = None):
         if vertextoadd is not None:
             curid = id
@@ -639,6 +738,7 @@ class cloud_vertices(Element_To_Draw):
         pass
 
     def plot(self, update=False, *args, **kwargs):
+        """ OpenGL plot of the cloud of vertices """
 
         if update or self.gllist == 0 or self.forceupdategl and not self.ongoing:
             curvert: wolfvertex
@@ -790,21 +890,48 @@ class cloud_vertices(Element_To_Draw):
         xyz = self.get_xyz(key)
         myarray.interpolate_on_cloud(xyz[:,:2],xyz[:,2],method)
 
-    def projectontrace(self, trace):
+    def iter_on_vertices(self):
+        """ Iteration on vertices """
+        for cur in self.myvertices.values():
+            yield cur['vertex']
+
+    def get_multipoint(self):
+        return MultiPoint([cur.as_shapelypoint() for cur in self.iter_on_vertices()])
+
+    def projectontrace(self, trace, return_cloud:bool = True, proximity:float = 99999.):
         """
         Projection du nuage sur une trace (type 'vector')
 
+        :param trace: classe vector
+        :param proximity: distance de recherche pour la projection
+
         Return :
-          Nouveau nuage contenant les infos de position sur la trace et d'altitude (s,z)
+            if return_cloud:
+                Nouveau nuage contenant les infos de position sur la trace et d'altitude (s,z)
+            else:
+                s,z : list[float], list[float]
         """
+
         # trace:vector
         tracels:LineString
         tracels = trace.asshapely_ls() # conversion en linestring Shapely
 
-        all_s = [tracels.project(Point(cur['vertex'].x,cur['vertex'].y)) for cur in self.myvertices.values()] # Projection des points sur la trace et récupération de la coordonnées curviligne
-        all_z = [cur['vertex'].z for cur in self.myvertices.values()]
-        # création d'un nouveau nuage
-        newcloud = cloud_vertices(idx=_('Projection on ')+trace.myname)
+        if proximity == 99999.:
+            # on garde tous les points
+
+            all_s = [tracels.project(Point(cur['vertex'].x,cur['vertex'].y)) for cur in self.myvertices.values()] # Projection des points sur la trace et récupération de la coordonnées curviligne
+            all_z = [cur['vertex'].z for cur in self.myvertices.values()]
+
+        else:
+
+            buffer = tracels.buffer(proximity) # buffer de la trace
+
+            multipoints = self.get_multipoint() # conversion en multipoint Shapely
+
+            mp = multipoints.intersection(buffer) # intersection avec le buffer
+
+            all_s = [tracels.project(Point(cur.x,cur.y)) for cur in mp.geoms] # Projection des points sur la trace et récupération de la coordonnées curviligne
+            all_z = [cur.z for cur in mp.geoms] # récupération de l'altitude
 
         new_dict = {}
         k=0
@@ -812,6 +939,10 @@ class cloud_vertices(Element_To_Draw):
             new_dict[k] = {'vertex':wolfvertex(s,z)}
             k+=1
 
-        newcloud.add_vertex(cloud=new_dict)
+        if return_cloud:
+            newcloud = cloud_vertices(idx=_('Projection on ')+trace.myname)
+            newcloud.add_vertex(cloud=new_dict)
 
-        return newcloud
+            return newcloud
+        else:
+            return all_s, all_z

wolfhece/PyVertexvectors.py

@@ -311,7 +311,7 @@ class Triangulation(Element_To_Draw):
 
         self.id_list = -99999
 
-    def plot(self):
+    def plot(self, sx=None, sy=None, xmin=None, ymin=None, xmax=None, ymax=None, size=None ):
 
         if self.id_list == -99999:
             self.id_list = glGenLists(1)
@@ -341,10 +341,10 @@ class Triangulation(Element_To_Draw):
     def find_minmax(self,force):
         if force:
             if self.nb_pts>0:
-                self.minx=np.min(self.pts[:,0])
-                self.miny=np.min(self.pts[:,1])
-                self.maxx=np.max(self.pts[:,0])
-                self.maxy=np.max(self.pts[:,1])
+                self.xmin=np.min(self.pts[:,0])
+                self.ymin=np.min(self.pts[:,1])
+                self.xmax=np.max(self.pts[:,0])
+                self.ymax=np.max(self.pts[:,1])
 
     def import_dxf(self,fn):
         import ezdxf
@@ -2268,8 +2268,8 @@ class zone:
         Création d'une triangulation sur base des vecteurs
         Tient compte de l'ordre
 
-        nb : nombre de points de découpe des vecteurs
-        nb2 : nombre de points en perpendiculaire
+        :param nb : nombre de points de découpe des vecteurs
+        :param nb2 : nombre de points en perpendiculaire
 
         return :
          - instance de 'Triangulation'
@@ -2284,8 +2284,14 @@ class zone:
             myls.append(curv.asshapely_ls())
 
         if nb is None and wx_exists:
-            dlg=wx.NumberEntryDialog(None,_('How many points along polylines ?')+'\n'+
-                                        _('Length size is {} meters').format(myls[0].length),'nb','dl size',100,1,10000.)
+            dlg=wx.NumberEntryDialog(None,
+                                     _('How many points along polylines ?')+'\n'+
+                                     _('Length size is {} meters').format(myls[0].length),
+                                     'nb',
+                                     'dl size',
+                                     100,
+                                     1,
+                                     10000)
             ret=dlg.ShowModal()
             if ret==wx.ID_CANCEL:
                 dlg.Destroy()
@@ -2304,7 +2310,13 @@ class zone:
             newls.append(LineString([curls.interpolate(curs,True) for curs in s]))
 
         if nb2==0 and wx_exists:
-            dlg=wx.NumberEntryDialog(None,_('How many points between two polylines ?'), 'nb2','perpendicular',0,1,10000.)
+            dlg=wx.NumberEntryDialog(None,
+                                     _('How many points between two polylines ?'),
+                                     'nb2',
+                                     'perpendicular',
+                                     0,
+                                     1,
+                                     10000)
             ret=dlg.ShowModal()
             if ret==wx.ID_CANCEL:
                 dlg.Destroy()
@@ -2370,8 +2382,8 @@ class zone:
         Création d'une triangulation sur base des vecteurs par projection au plus proche du veteur central
         Tient compte de l'ordre
 
-        nb : nombre de points de découpe des vecteurs
-        nb2 : nombre de points en perpendiculaire
+        :param nb : nombre de points de découpe des vecteurs
+        :param nb2 : nombre de points en perpendiculaire
 
         return :
          - instance de 'Triangulation'
@@ -2387,7 +2399,7 @@ class zone:
 
         if nb is None and wx_exists:
             dlg=wx.NumberEntryDialog(None,_('How many points along polylines ?')+'\n'+
-                                        _('Length size is {} meters').format(myls[0].length),'nb','dl size',100,1,10000.)
+                                        _('Length size is {} meters').format(myls[0].length),'nb','dl size',100,1,10000)
             ret=dlg.ShowModal()
             if ret==wx.ID_CANCEL:
                 dlg.Destroy()
@@ -2411,7 +2423,7 @@ class zone:
             newls.append(LineString([curls.interpolate(curs) for curs in news]))
 
         if nb2==0 and wx_exists:
-            dlg=wx.NumberEntryDialog(None,_('How many points between two polylines ?'), 'nb2','perpendicular',0,0,10000.)
+            dlg=wx.NumberEntryDialog(None,_('How many points between two polylines ?'), 'nb2','perpendicular',0,0,10000)
             ret=dlg.ShowModal()
             if ret==wx.ID_CANCEL:
                 dlg.Destroy()

wolfhece/lazviewer/laz_viewer.py

@@ -33,6 +33,7 @@ class Colors_Lazviewer(Enum):
     ORTHO_2012_2013 = 2013
     ORTHO_2015 = 2015
     ORTHO_2021 = 2021
+    ORTHO_2023 = 2023
     ORTHO_2006_2007 = 2006
     CODE_2013 = 0
     CODE_2023 = 2
@@ -93,7 +94,7 @@ class Classification_LAZ():
         self.test_wx()
 
         if self._choose_colors is None and self.wx_exists:
-            self._choose_colors = Wolf_Param(None, _('Colors of classification LAZ 2023'), w=600, h=800, to_read=False, withbuttons=True, toShow=False)
+            self._choose_colors = Wolf_Param(None, _('Colors of classification LAZ 2023'), w=600, h=800, to_read=False, withbuttons=True, toShow=False, force_even_if_same_default=True)
             self._choose_colors.callback        = self.callback_colors
             self._choose_colors.callbackdestroy = self.callback_destroy
             self._choose_colors.hide_selected_buttons()
@@ -987,6 +988,8 @@ def get_colors(las:laspy.LasData, which_colors:Colors_Lazviewer, imsize=2000, fn
             mycat='IMAGERIE/ORTHO_2021'
         elif which_colors==Colors_Lazviewer.ORTHO_2006_2007.value:
             mycat='IMAGERIE/ORTHO_2006_2007'
+        elif which_colors==Colors_Lazviewer.ORTHO_2023.value:
+            mycat='IMAGERIE/ORTHO_2023_ETE'
 
         if type(las) is laspy.LasData:
             x = las.x

wolfhece/wolf_array.py

@@ -3773,28 +3773,47 @@ class WolfArray(Element_To_Draw, header_wolf):
             else:
                 self.add_ops_sel()
 
-    def compare_cloud(self,mycloud:cloud_vertices):
+    def compare_cloud(self, mycloud:cloud_vertices, delta:list[float] = [.15, .5, 1.]):
         """
         Graphique de comparaison des valeurs d'un nuage de points et des valeurs de la matrice sous les mêmes positions
+
+        :param mycloud: cloud_vertices
+        :param delta: list of tolerance for the comparison
+
         """
+
+        # Get the values of the cloud
         xyz_cloud = mycloud.get_xyz()
+        # Get values of the array at the same positions
         zarray = np.array([self.get_value(curxy[0],curxy[1]) for curxy in xyz_cloud])
 
+        # count the number of points outside the array
         nbout = np.count_nonzero(zarray==-99999)
 
+        # Get the values of the cloud that are not outside the array
+        # Separate XY and Z values (cloud and array)
+        #  - z values
         z_cloud = xyz_cloud[zarray!=-99999][:,2]
+        #  - xy values
         xy_cloud = xyz_cloud[zarray!=-99999][:,:2]
+
+        #  - array values
         zarray = zarray[zarray!=-99999]
 
+        # concatenate all z values
         zall = np.concatenate([z_cloud,zarray])
+        # find the min and max values
         zmin = np.min(zall)
         zmax = np.max(zall)
 
+        # compute differences
         diffz = zarray-z_cloud
+        # choose a colormap
         cmap = plt.cm.get_cmap('RdYlBu')
         mindiff = np.min(diffz)
         maxdiff = np.max(diffz)
 
+        # Plot the differences [0] and the position [1]
         fig,ax = plt.subplots(2,1)
         ax[0].set_title(_('Comparison Z - ') + str(nbout) + _(' outside points on ') + str(len(xyz_cloud)))
         sc0 = ax[0].scatter(z_cloud,zarray,s=10,c=diffz,cmap = cmap, vmin=mindiff, vmax=maxdiff)
@@ -3802,7 +3821,16 @@ class WolfArray(Element_To_Draw, header_wolf):
         ax[0].set_ylabel(_('Array values'))
         ax[0].set_xlim([zmin,zmax])
         ax[0].set_ylim([zmin,zmax])
-        ax[0].plot([zmin,zmax],[zmin,zmax])
+
+        ax[0].plot([zmin,zmax],[zmin,zmax], color='black')
+
+        if delta is not None:
+            if isinstance(delta, list):
+                for idx, curdelta in enumerate(delta):
+                    curdelta = abs(float(curdelta))
+                    ax[0].plot([zmin,zmax],[zmin+delta,zmax+delta], 'k--', alpha=1.-1./(idx+1))
+                    ax[0].plot([zmin,zmax],[zmin-delta,zmax-delta], 'k--', alpha=1.-1./(idx+1))
+
         ax[0].axis('equal')
 
         sc1 = ax[1].scatter(xy_cloud[:,0],xy_cloud[:,1],s=10,c=diffz,cmap = cmap, vmin=mindiff, vmax=maxdiff)

{wolfhece-2.0.18.dist-info → wolfhece-2.0.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.0.18
+Version: 2.0.19
 Author-email: Stéphane Champailler <stephane.champailler@uliege.be>, Pierre Archambeau <pierre.archambeau@uliege.be>
 Project-URL: Homepage, https://uee.uliege.be/hece
 Project-URL: Issues, https://uee.uliege.be/hece

{wolfhece-2.0.18.dist-info → wolfhece-2.0.19.dist-info}/RECORD

@@ -5,16 +5,16 @@ wolfhece/Lidar2002.py,sha256=sXZ6p8_EKI5l8fJswIMAABT6dqHKVexU52Tjl1uuisU,5770
 wolfhece/ManageParams.py,sha256=Wgt5Zh7QBtyiwTAltPHunSLqt4XuVuRH76GTUrXabS4,219
 wolfhece/PyConfig.py,sha256=oGSL1WsLM9uinlNP4zGBLK3uHPmBfduUi7R-VtWuRFA,8034
 wolfhece/PyCrosssections.py,sha256=wdq-KYaLDBAa-gu3plWFBJN0Stx-oZX2dxs-iKjGBHo,111109
-wolfhece/PyDraw.py,sha256=DYiV9eUq6bXPpqQEl8w-WH45pAqLY5U2Hl0XZW9T7Zk,300264
+wolfhece/PyDraw.py,sha256=wXOtnYNVBRoaD8kkbcq1DRUEVqwY74akdPcL-eIUHn0,303430
 wolfhece/PyGui.py,sha256=mzJCRjMHtebFrxmPnwUK6YpQgMf5iiiCTm0hCOuRsOY,52722
 wolfhece/PyGuiHydrology.py,sha256=t7EqOMyA1mkVg_aATMaduR-aqs04V-uRCifyHVmPqRs,7133
 wolfhece/PyHydrographs.py,sha256=h2OfgmRkKc5XZn0iPFOVy60pGTSa5EFoUOEya0SeG7o,3411
 wolfhece/PyPalette.py,sha256=nb9oPLZF-xx-yvOWvw2XVVmis6XTmYT2i7hvH3qPwAg,21932
-wolfhece/PyParams.py,sha256=RqeIWvvKZ6LK5q6QK4k6SIRci4qVgLejnVR45sDS9iw,77211
+wolfhece/PyParams.py,sha256=TN7xDdhBGwq9dypVXuIfOUZ9Y6OxwcemfMhrJr1Y89U,81691
 wolfhece/PyPictures.py,sha256=-mJB0JL2YYiEK3D7_ssDkvYiMWK4ve9kXhozQXNeSx8,2216
 wolfhece/PyTranslate.py,sha256=4appkmNeHHZLFmUtaA_k5_5QL-5ymxnbVN4R2OblmtE,622
-wolfhece/PyVertex.py,sha256=nqQhfg4RFn4iGenJf6BMsnPB-fNFjnXqVeUi39BhEWc,30512
-wolfhece/PyVertexvectors.py,sha256=T5or2zgEy1Z6-DsrwJmRvsHo_fmcCiqNHAtrBBaV0wk,189557
+wolfhece/PyVertex.py,sha256=slmNcecB54jmqGHC4bozemLRUASSW6uJzypxWZ9kh7g,35071
+wolfhece/PyVertexvectors.py,sha256=n5Xfb-AlJfwV-RVOrV15Uo3STR-PYdxDY1Tb_MJkeV0,190119
 wolfhece/PyWMS.py,sha256=t6jVZpTxTNSLJxABk8A79cEMWTKoRM_S_SXRipsHLzw,4493
 wolfhece/RatingCurve.py,sha256=Psw4OknvqVXOjIomJxCW4hGd_q2HZ4DmcwV-wJXehds,21420
 wolfhece/RatingCurveData.py,sha256=5UvnIm89BwqjnEbLCcY3CA8WoFd_xHJbooNy62fX5iY,57660
@@ -44,7 +44,7 @@ wolfhece/pywalous.py,sha256=jwp251AzGBc0VmMzOqA0IJiRRa6yQIfccRM8lVGszIY,4474
 wolfhece/rain_SPWMI.py,sha256=YqsF-yFro3y_a6MfVRFfr-Rxi7NR1gl_i8VX7scmzes,13548
 wolfhece/textpillow.py,sha256=YJxF4JzPv3G1oqenJgWVYq3OPZx9iFtrmeIfvBwbJVU,8735
 wolfhece/tools_mpl.py,sha256=q8Yc4aukPPiUcEzREvZRM_em67XqXaahdoaNt0DETfE,266
-wolfhece/wolf_array.py,sha256=BAdO9j_ilDbzJ_Awrqnxz0kKL3zML0Z8eCSkY_M8IQM,280195
+wolfhece/wolf_array.py,sha256=gFHA0xTTQpgwneXUNwbSvvbMRp6nJaXyDKU5EQuKBR0,281277
 wolfhece/wolf_hist.py,sha256=JpRXvzJLUP-RkSkvth3DQWglgTMFI2ZEUDb4RYOfeeI,3284
 wolfhece/wolf_texture.py,sha256=quflEvi32lWSvOPa0aDCDl-8Jv-jGtLHbR2rdx67LsI,14883
 wolfhece/wolf_tiles.py,sha256=F2JsJHdAP8fIffNJdG_J26bonCIRtIwMmxKFqdSCRDA,10088
@@ -118,7 +118,7 @@ wolfhece/lagrangian/particles.py,sha256=TOr02FFIz98i0eFe8HAq-tpnJH0zgyCu1mDPeBxs
 wolfhece/lagrangian/velocity_field.py,sha256=vwGq7fEazib4Or7afVIFMfY_rRemQgKuSZ_4lHHx3wM,10276
 wolfhece/lazviewer/__init__.py,sha256=0SNDEKGad6e2AwxjalcPqb2bdW6crmXQFxWUY13PiVU,223
 wolfhece/lazviewer/_add_path.py,sha256=GDwPnzHuGRXGriDNcu1SQ6HetFDGIApeAQZEzYArGvI,605
-wolfhece/lazviewer/laz_viewer.py,sha256=7_IrV4smPxmIbhpq9zlX1Lorv-dyf5lwjRVhiSThqzc,42041
+wolfhece/lazviewer/laz_viewer.py,sha256=EHg-7MGRASevT3tmOwIGWdZZqo8cvEbTt8J2Ei9v1X8,42205
 wolfhece/lazviewer/libs/Qt5Core.dll,sha256=sTJ_ctYFY9KHMNytF-lzH_078zIvnKTjN-71FDkOWPw,4924928
 wolfhece/lazviewer/libs/Qt5Gui.dll,sha256=07BeaOeYByraGkKYeDiSDYLawHM8tyd55pVJlKbZ4Y0,5436416
 wolfhece/lazviewer/libs/Qt5Network.dll,sha256=U-9FiLE9LUKru8r8EQxTnwwlMpwS8JzUtenhkKTCox0,1038336
@@ -243,8 +243,8 @@ wolfhece/sounds/sonsw1.wav,sha256=HhuGeZ3iIyJdDALmM-jvGZDkKw3IZ3JXCuQZkN3Zjtc,21
 wolfhece/sounds/sonsw2.wav,sha256=pFLVt6By0_EPQNt_3KfEZ9a1uSuYTgQSX1I_Zurv9Rc,110636
 wolfhece/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 wolfhece/ui/wolf_multiselection_collapsiblepane.py,sha256=yGbU_JsF56jsmms0gh7mxa7tbNQ_SxqhpAZxhm-mTy4,14860
-wolfhece-2.0.18.dist-info/METADATA,sha256=_Qnbh7lus3Ln44kYSd_UjvnovEnBd38bWRq4nIHSMPw,2239
-wolfhece-2.0.18.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-wolfhece-2.0.18.dist-info/entry_points.txt,sha256=IHhq-i2W9QpyXFHKe2Ld8j1R4hW5DmYqrZsuSsXkdEE,245
-wolfhece-2.0.18.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
-wolfhece-2.0.18.dist-info/RECORD,,
+wolfhece-2.0.19.dist-info/METADATA,sha256=CMs_atGwoXeru4C1K50WGzLgM73dEJw7iAgE53id5-M,2239
+wolfhece-2.0.19.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+wolfhece-2.0.19.dist-info/entry_points.txt,sha256=IHhq-i2W9QpyXFHKe2Ld8j1R4hW5DmYqrZsuSsXkdEE,245
+wolfhece-2.0.19.dist-info/top_level.txt,sha256=EfqZXMVCn7eILUzx9xsEu2oBbSo9liWPFWjIHik0iCI,9
+wolfhece-2.0.19.dist-info/RECORD,,