wolfhece 2.2.34__py3-none-any.whl → 2.2.35__py3-none-any.whl

wolfhece/PyCrosssections.py

@@ -27,6 +27,8 @@ import logging
 import wx
 from typing import Union, Literal
 from pathlib import Path
+import pandas as pd
+
 
 from .PyTranslate import _
 from .drawing_obj import Element_To_Draw
@@ -130,6 +132,7 @@ class postype(Enum):
     BY_VERTEX   = 0 # sur base de coordonnées (wolfvertex)
     BY_S3D      = 1 # sur base d'une position curviligne 3D (le long de la trace de la section)
     BY_INDEX    = 2 # sur base d'un index de vertex
+
 class profile(vector):
     """
     Surcharge d'un vecteur en vue de définir un profil de rivière
@@ -156,6 +159,9 @@ class profile(vector):
         self._bankright=None
         self._bed=None
 
+        self._bankleft_down=None
+        self._bankright_down=None
+
         self.banksbed_postype = postype.BY_VERTEX
 
         self.refpoints={}
@@ -206,6 +212,22 @@ class profile(vector):
     def bankright(self,value):
         self._bankright=value
 
+    @ property
+    def bankleft_down(self):
+        return self._bankleft_down
+
+    @bankleft_down.setter
+    def bankleft_down(self,value):
+        self._bankleft_down=value
+
+    @property
+    def bankright_down(self):
+        return self._bankright_down
+
+    @bankright_down.setter
+    def bankright_down(self,value):
+        self._bankright_down=value
+
     @property
     def bed(self):
         return self._bed
@@ -232,6 +254,24 @@ class profile(vector):
         else:
             return self.interpolate(self._bankright, adim=False)
 
+    @property
+    def bankleft_down_vertex(self):
+        if self.banksbed_postype == postype.BY_VERTEX:
+            return self._bankleft_down
+        elif self.banksbed_postype == postype.BY_INDEX:
+            return self.myvertices[self._bankleft_down]
+        else:
+            return self.interpolate(self._bankleft_down, adim=False)
+
+    @property
+    def bankright_down_vertex(self):
+        if self.banksbed_postype == postype.BY_VERTEX:
+            return self._bankright_down
+        elif self.banksbed_postype == postype.BY_INDEX:
+            return self.myvertices[self._bankright_down]
+        else:
+            return self.interpolate(self._bankright_down, adim=False)
+
     @property
     def bed_vertex(self):
         if self.banksbed_postype == postype.BY_VERTEX:
@@ -277,6 +317,42 @@ class profile(vector):
                 s3d = self.length3D
             return s3d
 
+    @property
+    def bankleft_down_s3D(self):
+        if self.banksbed_postype == postype.BY_S3D:
+            return self._bankleft_down
+        else:
+            # on dispose d'un vertex 3D et on doit retnvoyer une position s3D
+            # --> projection x,y sur la trace --> récupération de 's'
+            # --> calcul de la distance s3D via shapely LineString sz en projetant '(s,z)'
+            if self.bankleft_down_vertex is not None:
+                ls2d = self.asshapely_ls()
+                lssz = self.asshapely_sz()
+                curvert = self.bankleft_down_vertex
+                s = ls2d.project(Point(curvert.x, curvert.y))
+                s3d = lssz.project(Point(s,curvert.z))
+            else:
+                s3d = 0.
+            return s3d
+
+    @property
+    def bankright_down_s3D(self):
+        if self.banksbed_postype == postype.BY_S3D:
+            return self._bankright_down
+        else:
+            # on dispose d'un vertex 3D et on doit retnvoyer une position s3D
+            # --> projection x,y sur la trace --> récupération de 's'
+            # --> calcul de la distance s3D via shapely LineString sz en projetant '(s,z)'
+            if self.bankright_down_vertex is not None:
+                ls2d = self.asshapely_ls()
+                lssz = self.asshapely_sz()
+                curvert = self.bankright_down_vertex
+                s = ls2d.project(Point(curvert.x, curvert.y))
+                s3d = lssz.project(Point(s,curvert.z))
+            else:
+                s3d = self.length3D
+            return s3d
+
     @property
     def bed_s3D(self):
         if self.banksbed_postype == postype.BY_S3D:
@@ -527,7 +603,8 @@ class profile(vector):
             curv.x +=dx
             curv.y +=dy
 
-    def movebankbed_index(self,which,orientation):
+    def movebankbed_index(self, which:Literal['left', 'right', 'bed', 'left_down', 'right_down'],
+                          orientation:Literal['left', 'right']) -> None:
         """
         Déplacement des points de référence sur base d'un index
         Le cas échéant, adaptation du mode de stockage
@@ -539,6 +616,10 @@ class profile(vector):
                 k = self.myvertices.index(self._bankright)
             elif which=='bed':
                 k = self.myvertices.index(self._bed)
+            elif which=='left_down':
+                k = self.myvertices.index(self._bankleft_down)
+            elif which=='right_down':
+                k = self.myvertices.index(self._bankright_down)
 
             if orientation=='left':
                 k=max(0,k-1)
@@ -551,6 +632,11 @@ class profile(vector):
                 self._bankright=k
             elif which=='bed':
                 self._bed=k
+            elif which=='left_down':
+                self._bankleft_down=k
+            elif which=='right_down':
+                self._bankright_down=k
+
         elif self.banksbed_postype == postype.BY_S3D:
             if which=='left':
                 k = 0
@@ -561,6 +647,14 @@ class profile(vector):
             elif which=='bed':
                 k = int(self.nbvertices/2)
                 self._bed=k
+            elif which=='left_down':
+                k = 1
+                self._bankleft_down=k
+            elif which=='right_down':
+                k = self.nbvertices-2
+                self._bankright_down=k
+
+
         if self.banksbed_postype == postype.BY_INDEX:
             if which=='left':
                 k = self._bankleft
@@ -568,6 +662,10 @@ class profile(vector):
                 k = self._bankright
             elif which=='bed':
                 k = self._bed
+            elif which=='left_down':
+                k = self._bankleft_down
+            elif which=='right_down':
+                k = self._bankright_down
 
             if orientation=='left':
                 k=max(0,k-1)
@@ -580,6 +678,10 @@ class profile(vector):
                 self._bankright=k
             elif which=='bed':
                 self._bed=k
+            elif which=='left_down':
+                self._bankleft_down=k
+            elif which=='right_down':
+                self._bankright_down=k
 
         self.banksbed_postype = postype.BY_INDEX
 
@@ -862,7 +964,7 @@ class profile(vector):
         self.zmax = -99999
         self.sz_bankbed = None
         self.s3d_bankbed = None
-        self.linestring = None
+        self.reset_linestring()
 
         self.prepared=False
 
@@ -1695,6 +1797,7 @@ class crosssections(Element_To_Draw):
     Gestion de sections en travers pour différents formats
         - SPW 2000 --> format ='2000'
         - SPW 2022 --> format ='2022'
+        - SPW_2025 --> format ='2025_xlsx'
         - WOLF vecz --> format ='vecz'
         - WOLF sxy --> format ='sxy'
 
@@ -1704,6 +1807,8 @@ class crosssections(Element_To_Draw):
         ['left']    : wolfvertex
         ['bed']     : wolfvertex
         ['right']   : wolfvertex
+        ['left_down'] : wolfvertex
+        ['right_down']: wolfvertex
         ['cs']      : profile (surcharge de vector)
 
     Pour le moment, il est possible de lire les fichiers et d'effectuer cerrains traitements (tri selon vecteur, export gltf...).
@@ -1715,7 +1820,7 @@ class crosssections(Element_To_Draw):
             - cloud
             - cloud_all
 
-    :remark !! La classe n'est pas encore prévue pour créer des sections en travers!!
+    :attention: !! La classe n'est pas encore prévue pour créer des sections en travers!!
 
     """
 
@@ -1724,12 +1829,13 @@ class crosssections(Element_To_Draw):
 
     def __init__(self,
                  myfile:str = '',
-                 format:typing.Literal['2000','2022','vecz','sxy']='2022',
+                 format:typing.Literal['2000','2022', '2025_xlsx','vecz','sxy']='2022',
                  dirlaz:typing.Union[str, xyz_laz_grids] =r'D:\OneDrive\OneDrive - Universite de Liege\Crues\2021-07 Vesdre\CSC - Convention - ARNE\Data\LAZ_Vesdre\2023',
                  mapviewer = None,
                  idx='',
                  plotted=True) -> None:
 
+        assert format in ['2000','2022','2025_xlsx','vecz','sxy'], _('Format %s not supported!')%format
 
         super().__init__(idx=idx, plotted= plotted, mapviewer=mapviewer, need_for_wx=False)
 
@@ -1759,6 +1865,21 @@ class crosssections(Element_To_Draw):
                 f=open(myfile,'r')
                 lines=f.read().splitlines()
                 f.close()
+        elif format=='2025_xlsx':
+            # For the 2025_xlsx format, we need to read the file using pandas
+            if Path(myfile).exists() and myfile!='':
+                # read the first sheet of the excel file
+                # Note: header=1 means that the first row is not the header, but the second row is.
+                logging.info(_('Reading cross section data from %s')%myfile)
+                try:
+                    lines = pd.read_excel(myfile, sheet_name=0, header=1)
+                    logging.info(_('Cross section data read successfully from %s')%myfile)
+                except Exception as e:
+                    logging.error(_('Error reading the file %s: %s')%(myfile, str(e)))
+                    lines = pd.DataFrame()
+            else:
+                logging.error(_('File %s does not exist!')%myfile)
+                lines = []
         # For other formats (e.g.  vecz)
         else:
             lines=[]
@@ -1773,7 +1894,80 @@ class crosssections(Element_To_Draw):
         self.sorted = {}
         self.plotted = False
 
-        if len(lines)>0:
+        if isinstance(lines, pd.DataFrame):
+
+            self.format='2025_xlsx'
+
+            # We attend these columns:
+            # 'Num', 'X', 'Y', 'Z', 'Code'
+            if 'Num' not in lines.columns or 'X' not in lines.columns or 'Y' not in lines.columns or 'Z' not in lines.columns or 'Code' not in lines.columns:
+                logging.error(_('The file %s does not contain the required columns: Num, X, Y, Z, Code')%self.filename)
+                return
+
+            nbsects = int(lines['Num'].max())
+
+            # Convert X and Y to float
+            lines['X'] = lines['X'].apply(lambda x: float(x.replace('.', '').replace(',', '.')) if isinstance(x, str) else float(x))
+            lines['Y'] = lines['Y'].apply(lambda x: float(x.replace('.', '').replace(',', '.')) if isinstance(x, str) else float(x))
+            # Convert Z to float and in meters
+            # Note: The Z values are in mm, so we divide by 1000 to convert to meters.
+            lines['Z'] = lines['Z'].apply(lambda x: float(x.replace('.', '').replace(',', '.'))/1000. if isinstance(x, str) else float(x)/1000.)
+
+            for index in range(1, nbsects + 1):
+                #création d'un nouveau dictionnaire
+                name = str(index)
+                curdict = self.myprofiles[name] = {}
+                curdict['index'] = index
+                curdict['cs'] = profile(name=name, parent=self)
+                cursect:profile
+                cursect = curdict['cs']
+
+                df = lines[lines['Num'] == index]
+
+                for ___, row in df.iterrows():
+                    x = row['X']
+                    y = row['Y']
+                    z = row['Z']
+                    label = row['Code']
+
+                    # Add vertex to the current section
+                    curvertex=wolfvertex(x,y,z)
+                    cursect.add_vertex(curvertex)
+
+                    if label == 'HBG':
+                        if cursect.bankleft is None:
+                            cursect.bankleft = wolfvertex(x,y,z)
+                            curdict['left'] = cursect.bankleft
+                        else:
+                            logging.debug(name)
+                    elif label == 'THA':
+                        if cursect.bed is None:
+                            cursect.bed=wolfvertex(x,y,z)
+                            curdict['bed']=cursect.bed
+                        else:
+                            logging.debug(name)
+                    elif label == 'HBD':
+                        if cursect.bankright is None:
+                            cursect.bankright=wolfvertex(x,y,z)
+                            curdict['right']=cursect.bankright
+                        else:
+                            logging.debug(name)
+                    elif label == 'BBG':
+                        # This is a special case for the 2025 format, where the bank left down is defined as BBG (Bas Berge Gauche in French).
+                        if cursect.bankleft_down is None:
+                            cursect.bankleft_down = wolfvertex(x,y,z)
+                            curdict['left_down'] = cursect.bankleft_down
+                        else:
+                            logging.debug(name)
+                    elif label == 'BBD':
+                        # This is a special case for the 2025 format, where the bank right down is defined as BBD (Bas Berge Droite in French).
+                        if cursect.bankright_down is None:
+                            cursect.bankright_down = wolfvertex(x,y,z)
+                            curdict['right_down'] = cursect.bankright_down
+                        else:
+                            logging.debug(name)
+
+        elif len(lines)>0:
             if format=='2000':
                 self.format='2000'
                 lines.pop(0)
@@ -1953,6 +2147,7 @@ class crosssections(Element_To_Draw):
                         cursect.bankright=wolfvertex(rbs,rbz)
                         curdict['right']=cursect.bankright
 
+
         # To make a distinction between cases for vecz
         elif len(lines)==0:
             if format=='vecz' or format=='zones':
@@ -1990,6 +2185,7 @@ class crosssections(Element_To_Draw):
         self.init_cloud()
 
     def init_cloud(self):
+        """ Initialiaze cloud points for cross-sections. """
 
         self.cloud = cloud_vertices()
         self.cloud_all = cloud_vertices()
@@ -2001,6 +2197,11 @@ class crosssections(Element_To_Draw):
         self.cloud_all.myprop.width=4
 
     def add(self, newprofile:profile | vector):
+        """ Add a new profile or vector to the cross-sections.
+
+        :param newprofile: A profile or vector to be added.
+        :type newprofile: profile | vector
+        """
 
         if isinstance(newprofile, profile):
             curvec = newprofile
@@ -2008,9 +2209,11 @@ class crosssections(Element_To_Draw):
 
             curdict['index']=len(self.myprofiles)
             curdict['cs'] = newprofile
-            curdict['left']= newprofile.bankleft_vertex.copy()
-            curdict['bed']= newprofile.bed_vertex.copy()
-            curdict['right']=newprofile.bankright_vertex.copy()
+            curdict['left']= newprofile.bankleft_vertex.copy() if newprofile.bankleft_vertex else None
+            curdict['bed']= newprofile.bed_vertex.copy() if newprofile.bed_vertex else None
+            curdict['right']=newprofile.bankright_vertex.copy() if newprofile.bankright_vertex else None
+            curdict['left_down'] = newprofile.bankleft_down_vertex.copy() if newprofile.bankleft_down_vertex else None
+            curdict['right_down'] = newprofile.bankright_down_vertex.copy() if newprofile.bankright_down_vertex else None
 
         elif isinstance(newprofile, vector):
             curvec = newprofile
@@ -2020,6 +2223,8 @@ class crosssections(Element_To_Draw):
             curdict['left']=None
             curdict['bed']=None
             curdict['right']=None
+            curdict['left_down'] = None
+            curdict['right_down'] = None
 
             cursect = curdict['cs'] = profile(name=curvec.myname,parent=self)
             cursect.myvertices = curvec.myvertices
@@ -2035,7 +2240,12 @@ class crosssections(Element_To_Draw):
 
     def get_profile(self, which_prof, which_dict:str=None):
         """
-        Recherche et renvoi d'un profil sur base du nom ou de son index et éventuellement de la liste triée
+        Recherche et renvoi d'un profil sur base du nom ou de son index et éventuellement de la liste triée.
+
+        :param which_prof: Nom du profil ou index du profil à rechercher.
+        :type which_prof: str | int
+        :param which_dict: Nom du dictionnaire trié à utiliser, si applicable.
+        :type which_dict: str | None
         """
         if which_dict is not None:
             # on travaille sur les vecteurs triés
@@ -2059,6 +2269,7 @@ class crosssections(Element_To_Draw):
         return None
 
     def fillin_cloud_all(self):
+        """ Fill the cloud_all with all vertices from all profiles. """
 
         curprof:profile
         for idx,vect in self.myprofiles.items():
@@ -2069,6 +2280,7 @@ class crosssections(Element_To_Draw):
         self.cloud_all.find_minmax()
 
     def update_cloud(self):
+        """ Update the cloud with vertices from all profiles. """
 
         curprof:profile
         for idx,vect in self.myprofiles.items():
@@ -2089,6 +2301,7 @@ class crosssections(Element_To_Draw):
         self.cloud.find_minmax(True)
 
     def create_zone_from_banksbed(self):
+        """ Create a zone from the banks and bed of the cross-sections."""
 
         if self.linked_zones is None:
             return
@@ -2112,11 +2325,14 @@ class crosssections(Element_To_Draw):
         newvec.myvertices=right
         newzone.add_vector(newvec)
 
-    def link_external_zones(self,mylink:Zones):
+    def link_external_zones(self, mylink:Zones):
+        """ Link the cross-sections to external zones. """
+
         self.linked_zones = mylink
         self.find_intersect_with_link_zones()
 
     def find_intersect_with_link_zones(self):
+        """ Find intersections between the cross-sections and linked zones. """
 
         if self.linked_zones is None:
             return
@@ -2168,6 +2384,7 @@ class crosssections(Element_To_Draw):
         self.update_cloud()
 
     def export_gltf(self,zmin,fn=''):
+        """ Export the cross-sections to a GLTF file. """
 
         points=[]
         triangles=[]
@@ -2249,6 +2466,7 @@ class crosssections(Element_To_Draw):
         gltf.save(fn)
 
     def export_gltf_gen(self,points,triangles,fn=''):
+        """ Export generated cross-sections to a GLTF file. """
 
         triangles_binary_blob = triangles.flatten().tobytes()
         points_binary_blob = points.tobytes()
@@ -2311,6 +2529,8 @@ class crosssections(Element_To_Draw):
         gltf.save(fn)
 
     def set_zones(self, forceupdate:bool=False):
+        """ Set/Prepare the zones for the cross-sections. """
+
         if forceupdate:
             self.myzone=None
             self.myzones=None
@@ -2331,10 +2551,13 @@ class crosssections(Element_To_Draw):
                 self._prep_listogl()  #FIXME : Does not work in the context of a 1D model
 
     def showstructure(self, parent=None, forceupdate=False):
+        """ Show the structure of the cross-sections in the zones. """
+
         self.set_zones()
         self.myzones.showstructure(parent, forceupdate)
 
     def get_upstream(self) -> dict:
+        """ Get the upstream profile of the cross-sections."""
         curprof:profile
         curprof=self.myprofiles[list(self.myprofiles.keys())[0]]['cs']
 
@@ -2344,6 +2567,7 @@ class crosssections(Element_To_Draw):
         return self.myprofiles[curprof.myname]
 
     def get_downstream(self) -> dict:
+        """ Get the downstream profile of the cross-sections. """
         curprof:profile
         curprof=self.myprofiles[list(self.myprofiles.keys())[0]]['cs']
 
@@ -2352,7 +2576,14 @@ class crosssections(Element_To_Draw):
 
         return self.myprofiles[curprof.myname]
 
-    def rename(self,fromidx,updown=True):
+    def rename(self, fromidx:int, updown:bool=True):
+        """" Rename the cross-sections starting from a given index.
+
+        :param fromidx: The index from which to start renaming.
+        :type fromidx: int
+        :param updown: If True, renames upstream sections; if False, renames all sections.
+        :type updown: bool
+        """
 
         idx=fromidx
 
@@ -2383,6 +2614,8 @@ class crosssections(Element_To_Draw):
         self.set_zones(True)
 
     def saveas(self,filename=None):
+        """ Save the cross-sections to a file in the specified format. """
+
         self.forcesuper=False
 
         if filename is not None:
@@ -2395,12 +2628,38 @@ class crosssections(Element_To_Draw):
         if self.filename.endswith('.vecz'):
             self.forcesuper=True
             self.saveas_wolfvec(self.filename)
+
         elif self.format=='2000' or self.format=='2022':
+
             with open(self.filename,'w') as f:
                 f.write("Profile\tx\ty\tBerge\tz\n")
                 for idx,curvect in self.myprofiles.items():
                     curprof=curvect['cs']
                     curprof.save(f)
+
+        elif self.format=='2025_xlsx':
+            # For the 2025_xlsx format, we need to save the data using pandas
+            data = []
+            for idx, curvect in self.myprofiles.items():
+                curprof = curvect['cs']
+                for vertex in curprof.myvertices:
+                    data.append({
+                        'Num': idx,
+                        'X': vertex.x,
+                        'Y': vertex.y,
+                        'Z': vertex.z,
+                        'Code': curprof.get_label(vertex)
+                    })
+
+            df = pd.DataFrame(data)
+            # we need to ensure that the header begins at the second row
+            df = df[['Num', 'X', 'Y', 'Z', 'Code']]
+            # Save to Excel file
+            with pd.ExcelWriter(self.filename, engine='openpyxl') as writer:
+                # Write a blank row first, then the data starting from row 2
+                pd.DataFrame([]).to_excel(writer, sheet_name='Sheet1', index=False, header=False)
+                df.to_excel(writer, sheet_name='Sheet1', index=False, startrow=1)
+
         elif self.format=='sxy':
             with open(self.filename,'w') as f:
                 f.write(str(len(self.mygenprofiles)))
@@ -2433,22 +2692,28 @@ class crosssections(Element_To_Draw):
 
     def verif_bed(self):
         """Verification de l'existence du point lit mineur sinon attribution de l'altitude minimale"""
+
         for idx,curvect in self.myprofiles.items():
             curprof=curvect['cs']
             if curprof.bed is None:
                 curprof.bed = curprof.get_min()
 
-    def get_min(self,whichname='',whichprofile=None):
+    def get_min(self, whichname:str = '', whichprofile:profile = None):
+        """ Get the minimum vertex of a profile or cross-section. """
+
         curvect:profile
         if whichname!='':
             curvect=self.myprofiles[whichname]['cs']
             curvert=curvect.myvertices
-        elif not whichprofile is None:
+
+        elif whichprofile is not None:
             curvect=whichprofile['cs']
             curvert=curvect.myvertices
         return sorted(curvert,key=lambda x:x.z)[0]
 
     def asshapely_ls(self):
+        """ Convert the cross-sections to a MultiLineString using Shapely. """
+
         mylines=[]
         curvect:profile
         for idx,curvect in self.myprofiles.items():
@@ -2456,6 +2721,8 @@ class crosssections(Element_To_Draw):
         return MultiLineString(mylines)
 
     def prepare_shapely(self):
+        """ Prepare the cross-sections for Shapely operations. """
+
         self.multils = self.asshapely_ls()
 
     def sort_along(self,vecsupport:LineString,name:str,downfirst=True):
@@ -2502,6 +2769,11 @@ class crosssections(Element_To_Draw):
         return len(mysorted)
 
     def find_minmax(self, update:bool=False):
+        """ Find the minimum and maximum coordinates of the cross-sections.
+
+        :param update: If True, updates the min/max values based on the current profiles.
+        :type update: bool
+        """
 
         if len(self.myprofiles)==0:
             self.xmin = 0
@@ -2509,7 +2781,7 @@ class crosssections(Element_To_Draw):
             self.xmax = 0
             self.ymax = 0
             return
-        
+
         if update:
             for idx,vect in self.myprofiles.items():
                 vect['cs'].find_minmax(only_firstlast = True)
@@ -2529,11 +2801,16 @@ class crosssections(Element_To_Draw):
         self.myzones.prep_listogl()
 
     def saveas_wolfvec(self,filename:str):
-
+        """ Save the cross-sections as a WOLF vector file. """
         self.set_zones()
         self.myzones.saveas(filename=filename)
 
-    def select_profile(self,x,y):
+    def select_profile(self, x:float, y:float):
+        """ Select the profile closest to the given coordinates (x, y).
+
+        :param x: X coordinate of the point.
+        :param y: Y coordinate of the point.
+        """
 
         mypt = Point(x,y)
         distmin=1.e300