wolfhece 1.8.12__py3-none-any.whl → 2.0.0__py3-none-any.whl

wolfhece/GraphNotebook.py

@@ -435,7 +435,6 @@ class ManagerInterp(PlotPanel):
 
         curzone=self.active_zone
         curzone.myvectors.pop(self.curidx)
-        curzone.nbvectors-=1
 
         self.active_zones.fill_structure()
 

wolfhece/PyCrosssections.py

@@ -14,11 +14,13 @@ import typing
 import copy
 from enum import Enum
 import logging
+import wx
+from typing import Union, Literal
 
 from .PyTranslate import _
 from .PyVertexvectors import vector,zone,Zones
 from .PyVertex import wolfvertex,cloud_vertices, getIfromRGB
-from .lazviewer.laz_viewer import xyz_laz_grids
+from .lazviewer.laz_viewer import xyz_laz_grids, myviewer
 
 example_largesect="""-138 100
 -114 90
@@ -147,8 +149,9 @@ class profile(vector):
         self.refpoints={}
 
         self.s = 0.0
-        self.up = None
-        self.down = None
+        self.up:profile = None
+        self.down:profile = None
+
         self.laz=False
 
         if parent is not None:
@@ -2293,7 +2296,7 @@ class crosssections():
         self.set_zones()
         self.myzones.showstructure(parent, forceupdate)
 
-    def get_upstream(self):
+    def get_upstream(self) -> dict:
         curprof:profile
         curprof=self.myprofiles[list(self.myprofiles.keys())[0]]['cs']
 
@@ -2302,7 +2305,7 @@ class crosssections():
 
         return self.myprofiles[curprof.myname]
 
-    def get_downstream(self):
+    def get_downstream(self) -> dict:
         curprof:profile
         curprof=self.myprofiles[list(self.myprofiles.keys())[0]]['cs']
 
@@ -2502,3 +2505,586 @@ class crosssections():
                 distmin=dist
 
         return profmin
+
+class Interpolator():
+    """
+    Objet d'interpolation sur sections en travers
+
+        - self.interpolants est une liste de listes
+        - chaque élément de self.interpolants est également une liste de listes
+        - chaque liste de self.interpolants[k] contient les wolfvertex de la section discrétisée
+
+    """
+
+    def __init__(self,vec1:vector,vec2:vector,supports:list,ds=1.) -> None:
+
+        self.interpolants=[]
+
+        sect1={}
+        sect2={}
+
+        #Linestrings shapely des sections 1 et 2
+        #ATTENTION, SHAPELY est une librairie géométrique 2D --> des outils spécifiques ont été programmés pour faire l'interpolation 3D
+        s1=sect1['ls']=vec1.asshapely_ls()
+        s2=sect2['ls']=vec2.asshapely_ls()
+
+        nb = 0
+        supls={}
+
+        eps=5.e-2
+
+        for curvec in supports:
+            #linestring du support courant
+            #distances des intersections des sections sur le support
+            myls:LineString
+            myls=curvec.asshapely_ls()
+
+            #intersections du vecteur support avec les sections
+            i1=myls.intersects(s1)
+            if not i1:
+                pt=Point(s1.xy[0][0],s1.xy[1][0])
+                pt1=myls.interpolate(myls.project(pt))
+                length = pt1.distance(pt)
+                i1 = length<eps
+
+                if i1:
+                    vec1.myvertices[0].x=pt1.xy[0][0]
+                    vec1.myvertices[0].y=pt1.xy[1][0]
+                    s1=vec1.asshapely_ls()
+
+                if not i1:
+                    pt=Point(s1.xy[0][-1],s1.xy[1][-1])
+                    pt1=myls.interpolate(myls.project(pt))
+                    length = pt1.distance(pt)
+                    i1 = length<eps
+                    if i1:
+                        vec1.myvertices[-1].x=pt1.xy[0][-1]
+                        vec1.myvertices[-1].y=pt1.xy[1][-1]
+                        s1=vec1.asshapely_ls()
+
+            i2=myls.intersects(s2)
+            if not i2:
+                pt=Point(s2.xy[0][0],s2.xy[1][0])
+                pt2=myls.interpolate(myls.project(pt))
+                length = pt2.distance(Point(s2.xy[0][0],s2.xy[1][0]))
+                i2 = length<eps
+
+                if i2:
+                    vec2.myvertices[0].x=pt2.xy[0][0]
+                    vec2.myvertices[0].y=pt2.xy[1][0]
+                    s2=vec2.asshapely_ls()
+
+                if not i2:
+                    pt=Point(s2.xy[0][-1],s2.xy[1][-1])
+                    pt2=myls.interpolate(myls.project(pt))
+                    length = pt2.distance(pt)
+                    i2 = length<eps
+                    if i2:
+                        vec2.myvertices[-1].x=pt2.xy[0][-1]
+                        vec2.myvertices[-1].y=pt2.xy[1][-1]
+                        s2=vec2.asshapely_ls()
+
+            if i1 and i2:
+                supls[nb]={}
+                supls[nb]['ls']=myls
+                supls[nb]['vec']=curvec
+                nb+=1
+
+        #bouclage sur les vecteurs supports pour trouver les intersections avec les sections
+        #  - trouver la portion utile entre intersections des supports
+        #  - trouver les distances sur les sections de ces intersections
+        for k in range(nb):
+            #linestring du support courant
+            #distances des intersections des sections sur le support
+            myls:LineString
+            myls=supls[k]['ls']
+
+            #intersections du vecteur support avec les sections
+
+            #section amont
+            i1=myls.intersection(s1)
+            if i1.geom_type=='MultiPoint':
+                i1=i1.geoms[0]
+
+            #section aval
+            i2=myls.intersection(s2)
+            if i2.geom_type=='MultiPoint':
+                i2=i2.geoms[0]
+
+            #Les distances, sur les sections, sont calculées en projetant l'intersection du vecteur support et des sections
+            sect1[k]=s1.project(i1)
+            sect2[k]=s2.project(i2)
+
+            #Les distances, sur le support, sont calculées en projetant l'intersection du vecteur support et des sections
+            supls[k][1]=myls.project(i1)
+            if supls[k][1]==-1.:
+                #problème de précision de calcul
+                if myls.distance(Point(s1.xy[0][0],s1.xy[1][0]))<eps:
+                    supls[k][1]=myls.project(Point(s1.xy[0][0],s1.xy[1][0]))
+                    sect1[k]=s1.project(Point(s1.xy[0][0],s1.xy[1][0]))
+                elif myls.distance(Point(s1.xy[0][-1],s1.xy[1][-1]))<eps:
+                    supls[k][1]=myls.project(Point(s1.xy[0][-1],s1.xy[1][-1]))
+                    sect1[k]=s1.project(Point(s1.xy[0][-1],s1.xy[1][-1]))
+
+            supls[k][2]=myls.project(i2)
+            if supls[k][2]==-1.:
+                #problème de précision de calcul
+                if myls.distance(Point(s2.xy[0][0],s2.xy[1][0]))<eps:
+                    supls[k][2]=myls.project(Point(s2.xy[0][0],s2.xy[1][0]))
+                    sect2[k]=s2.project(Point(s2.xy[0][0],s2.xy[1][0]))
+                elif myls.distance(Point(s2.xy[0][-1],s2.xy[1][-1]))<eps:
+                    supls[k][2]=myls.project(Point(s2.xy[0][-1],s2.xy[1][-1]))
+                    sect2[k]=s2.project(Point(s2.xy[0][-1],s2.xy[1][-1]))
+
+            #on ne conserve que la fraction utile entre intersections
+            supls[k]['vec']=supls[k]['vec'].substring(supls[k][1],supls[k][2],False,False)
+
+        #bouclage sur les intervalles --> nb_supports-1
+        for k in range(nb-1):
+            interpolant=[]
+            self.interpolants.append(interpolant)
+
+            cursupl:vector
+            cursupr:vector
+            curvec1:vector
+            curvec2:vector
+
+            #morceaux de sections entre intersections avec le support
+            curvec1=sect1['sub'+str(k)]=vec1.substring(sect1[k],sect1[k+1],is3D=False,adim=False)
+            curvec2=sect2['sub'+str(k)]=vec2.substring(sect2[k],sect2[k+1],is3D=False,adim=False)
+
+            #pointeurrs vers les morceaux des supports
+            cursupl = supls[k]['vec']
+            cursupr = supls[k+1]['vec']
+
+            #MAJ des longueurs 2D et 3D
+            cursupl.update_lengths()
+            cursupr.update_lengths()
+            curvec1.update_lengths()
+            curvec2.update_lengths()
+
+            #Trouve la liste des distances à traiter pour le maillage
+            nbi = np.ceil(max(curvec1.length3D,curvec2.length3D)/ds)
+            locds = 1./float(nbi)
+            dist3d = np.concatenate([np.arange(0.,1.,locds),np.cumsum(curvec1._lengthparts3D)/curvec1.length3D,np.cumsum(curvec2._lengthparts3D)/curvec2.length3D])
+            dist3d = np.unique(dist3d)
+
+            #nombre de points à traiter sur les supports
+            # on divise la longueur 3D des supports par la taille souhaitée et on arrondi à l'entier supérieur
+            nbi = int(np.ceil(max(cursupl.length3D,cursupr.length3D)/ds))
+            # nouvelle distance de calcul
+            locds = 1./float(nbi)
+
+            sloc=0.
+            pt1l = curvec1.interpolate(0.,True,True)
+            pt2l = curvec2.interpolate(0.,True,True)
+            pt1r = curvec1.interpolate(1.,True,True)
+            pt2r = curvec2.interpolate(1.,True,True)
+
+            s1dr = vector(name='sectiondroite1')
+            s2dr = vector(name='sectiondroite2')
+            s1dr.add_vertex([pt1l,pt1r])
+            s2dr.add_vertex([pt2l,pt2r])
+
+            s1dr = s1dr.asshapely_ls()
+            s2dr = s2dr.asshapely_ls()
+
+            # if np.isnan(pt1l.x):
+            #     a=1
+            # if np.isnan(pt2l.x):
+            #     a=1
+            # if np.isnan(pt1r.x):
+            #     a=1
+            # if np.isnan(pt2r.x):
+            #     a=1
+
+            for curalong in range(nbi+1):
+                print(str(curalong))
+
+                #interpolation 3D sur les 2 supports
+                l1 = cursupl.interpolate(sloc,True,True)
+                l2 = cursupr.interpolate(sloc,True,True)
+
+                curvec=vector(name='loc')
+                curvec.add_vertex([l1,l2])
+                val = []
+
+                if l1.z!=0.:
+                    if pt1l.z==0.:
+                        alpha1l=0.
+                    else:
+                        alpha1l = l1.z/pt1l.z
+                    if pt2l.z==0.:
+                        alpha2l=0.
+                    else:
+                        alpha2l = l1.z/pt2l.z
+                else:
+                    alpha1l = 0.
+                    alpha2l = 0.
+                if l2.z!=0.:
+                    if pt1r.z==0.:
+                        alpha1r = 0.
+                    else:
+                        alpha1r = l2.z/pt1r.z
+
+                    if pt2r.z==0.:
+                        alpha2r = 0.
+                    else:
+                        alpha2r = l2.z/pt2r.z
+                else:
+                    alpha1r=0.
+                    alpha2r=0.
+
+                for curdist in dist3d:
+
+                    #interpolation 3D dans les 2 sections
+                    cur1 = curvec1.interpolate(curdist,True,True)
+                    cur2 = curvec2.interpolate(curdist,True,True)
+
+                    alpha1 = alpha1l*(1.-curdist)+alpha1r*curdist
+                    alpha2 = alpha2l*(1.-curdist)+alpha2r*curdist
+
+                    sr1 = s1dr.project(Point(cur1.x,cur1.y))
+                    sr2 = s2dr.project(Point(cur2.x,cur2.y))
+                    pr1 = s1dr.interpolate(sr1)
+                    pr2 = s2dr.interpolate(sr2)
+                    sr1/=s1dr.length
+                    sr2/=s2dr.length
+
+                    dx1 = cur1.x-pr1.x
+                    dy1 = cur1.y-pr1.y
+                    dx2 = cur2.x-pr2.x
+                    dy2 = cur2.y-pr2.y
+                    dx = dx1*(1.-sloc)+dx2*sloc
+                    dy = dy1*(1.-sloc)+dy2*sloc
+                    s = sr1*(1.-sloc)+sr2*sloc
+
+                    # dist2d1 = cur1.dist2D(curvec1.myvertices[0])/curvec1.myvertices[0].dist2D(curvec1.myvertices[-1]) #curvec1.length2D
+                    # dist2d2 = cur2.dist2D(curvec2.myvertices[0])/curvec2.myvertices[0].dist2D(curvec2.myvertices[-1]) #curvec2.length2D
+                    # dist2d  = dist2d1*(1.-sloc) + dist2d2*sloc
+                    # pt = curvec.interpolate(dist2d,False,True)
+                    pt = curvec.interpolate(s,False,True)
+
+                    # xloc = cur1.x + sloc * (cur2.x-cur1.x)
+                    # yloc = cur1.y + sloc * (cur2.y-cur1.y)
+                    zloc = cur1.z*alpha1 + sloc * (cur2.z*alpha2-cur1.z*alpha1)
+
+                    val.append(wolfvertex(pt.x+dx,pt.y+dy,zloc))
+                    # val.append(wolfvertex(xloc,yloc,zloc))
+
+                interpolant.append(val)
+
+                sloc+=locds
+                sloc=min(sloc,1.)
+
+    def get_xyz_for_viewer(self,nbsub=10):
+
+        pts=self.interpolants
+
+        nb=0
+        for curpt in pts:
+            for curl in curpt:
+                nb+=(len(curpt)-1)*(len(curl)-1)*3+(len(curl)-1)+(len(curpt))
+
+        pond=np.arange(0.,1.,1./float(nbsub))
+        xyz=np.ones([(nb-1)*nbsub,4],order='F')
+        start=0
+        for curpt in pts:
+            for k in range(len(curpt)-1):
+                curl=curpt[k]
+                nextl=curpt[k+1]
+                for i in range(len(curl)-1):
+                    v1=curl[i].getcoords()
+                    v2=curl[i+1].getcoords()
+                    v3=nextl[i].getcoords()
+
+                    xyz[start:start+nbsub,:3]=[v1+(v2-v1)*curpond for curpond in pond]
+                    start+=nbsub
+                    xyz[start:start+nbsub,:3]= [v2+(v3-v2)*curpond for curpond in pond]
+                    start+=nbsub
+                    xyz[start:start+nbsub,:3]= [v3+(v1-v3)*curpond for curpond in pond]
+                    start+=nbsub
+
+            curl=curpt[-1]
+            for i in range(len(curl)-1):
+                v1=curl[i].getcoords()
+                v2=curl[i+1].getcoords()
+                xyz[start:start+nbsub,:3]=[v1+(v2-v1)*curpond for curpond in pond]
+                start+=nbsub
+            for k in range(len(curpt)-1):
+                curl=curpt[k]
+                nextl=curpt[k+1]
+                v1=curl[-1].getcoords()
+                v3=nextl[-1].getcoords()
+                xyz[start:start+nbsub,:3]=[v1+(v3-v1)*curpond for curpond in pond]
+                start+=nbsub
+
+        return xyz
+
+    def add_triangles_to_zone(self,myzone:zone):
+
+        nb=0
+        npt=1
+        for curpt in self.interpolants:
+            for k in range(len(curpt)-1):
+                curl=curpt[k]
+                nextl=curpt[k+1]
+                for i in range(len(curl)-1):
+                    curvec = vector(name='tr'+'_'+str(npt)+'_'+str(k)+'_'+str(i),parentzone=myzone)
+                    curvec.add_vertex([curl[i],curl[i+1],nextl[i]])
+                    curvec.close_force()
+                    curvec.myprop.used=False
+                    myzone.add_vector(curvec)
+
+                    curvec = vector(name='tr'+'_'+str(npt)+'_'+str(k+1)+'_'+str(i),parentzone=myzone)
+                    curvec.add_vertex([nextl[i],curl[i+1],nextl[i+1]])
+                    curvec.close_force()
+                    curvec.myprop.used=False
+                    myzone.add_vector(curvec)
+
+            npt+=1
+            nb+=(len(curpt)-1)*(len(curl)-1)*3+(len(curl)-1)+(len(curpt))
+
+    def get_triangles(self,forgltf=True):
+
+        points=[]
+        triangles=[]
+        nbpts=0
+        nbtr=0
+        for curpt in self.interpolants:
+
+            nb_points_perline = len(curpt[0])
+            nbsect=len(curpt)
+            if forgltf:
+                pointsloc=[[pt.x,pt.z,-pt.y] for curl in curpt for pt in curl]
+            else:
+                pointsloc=[[pt.x,pt.y,pt.z] for curl in curpt for pt in curl]
+
+            trianglesloc=[[[k+decal*nb_points_perline+nbpts,
+                        k+1+decal*nb_points_perline+nbpts,
+                        nb_points_perline+k+decal*nb_points_perline+nbpts],
+
+                        [nb_points_perline+k+decal*nb_points_perline+nbpts,
+                        k+1+decal*nb_points_perline+nbpts,
+                        nb_points_perline+k+decal*nb_points_perline+1+nbpts]]
+                            for decal in range(len(curpt)-1) for k in range(nb_points_perline-1)]
+
+            nbpts+=nb_points_perline*nbsect
+            nbloc=(nb_points_perline-1)*(nbsect-1)*2
+            nbtr+=nbloc
+
+            points.append(pointsloc)
+            triangles.append(np.asarray(trianglesloc).reshape([nbloc,3]))
+
+
+        points=np.asarray(np.concatenate(points),dtype=np.float32)
+        triangles=np.asarray(np.concatenate(triangles),dtype=np.uint32)
+
+
+        if len(np.argwhere(np.isnan(points)==True))>0:
+            a=1
+
+        return nbpts,points,triangles
+
+    def get_points(self,forgltf=False):
+
+        points=[]
+        nbpts=0
+        for curpt in self.interpolants:
+
+            nb_points_perline = len(curpt[0])
+            nbsect=len(curpt)
+            if forgltf:
+                pointsloc=[[pt.x,pt.z,-pt.y] for curl in curpt for pt in curl]
+            else:
+                pointsloc=[[pt.x,pt.y,pt.z] for curl in curpt for pt in curl]
+
+            nbpts+=nb_points_perline*nbsect
+            points.append(pointsloc)
+
+        if forgltf:
+            points=np.asarray(np.concatenate(points),dtype=np.float32)
+        else:
+            points=np.asarray(np.concatenate(points))
+
+        return nbpts,points
+
+    def export_gltf(self,points=None,triangles=None):
+
+        if points is None and triangles is None:
+            points,triangles= self.get_triangles()
+
+        triangles_binary_blob = triangles.flatten().tobytes()
+        points_binary_blob = points.tobytes()
+
+        gltf = pygltflib.GLTF2(
+            scene=0,
+            scenes=[pygltflib.Scene(nodes=[0])],
+            nodes=[pygltflib.Node(mesh=0)],
+            meshes=[
+                pygltflib.Mesh(
+                    primitives=[
+                        pygltflib.Primitive(
+                            attributes=pygltflib.Attributes(POSITION=1), indices=0
+                        )
+                    ]
+                )
+            ],
+            accessors=[
+                pygltflib.Accessor(
+                    bufferView=0,
+                    componentType=pygltflib.UNSIGNED_INT,
+                    count=triangles.size,
+                    type=pygltflib.SCALAR,
+                    max=[int(triangles.max())],
+                    min=[int(triangles.min())],
+                ),
+                pygltflib.Accessor(
+                    bufferView=1,
+                    componentType=pygltflib.FLOAT,
+                    count=len(points),
+                    type=pygltflib.VEC3,
+                    max=points.max(axis=0).tolist(),
+                    min=points.min(axis=0).tolist(),
+                ),
+            ],
+            bufferViews=[
+                pygltflib.BufferView(
+                    buffer=0,
+                    byteLength=len(triangles_binary_blob),
+                    target=pygltflib.ELEMENT_ARRAY_BUFFER,
+                ),
+                pygltflib.BufferView(
+                    buffer=0,
+                    byteOffset=len(triangles_binary_blob),
+                    byteLength=len(points_binary_blob),
+                    target=pygltflib.ARRAY_BUFFER,
+                ),
+            ],
+            buffers=[
+                pygltflib.Buffer(
+                    byteLength=len(triangles_binary_blob) + len(points_binary_blob)
+                )
+            ],
+        )
+        gltf.set_binary_blob(triangles_binary_blob + points_binary_blob)
+
+        dlg=wx.FileDialog(None,_('Choose filename'),wildcard='binary gltf2 (*.glb)|*.glb|gltf2 (*.gltf)|*.gltf|All (*.*)|*.*',style=wx.FD_SAVE)
+        ret=dlg.ShowModal()
+        if ret==wx.ID_CANCEL:
+            dlg.Destroy()
+            return
+
+        fn=dlg.GetPath()
+        dlg.Destroy()
+
+        gltf.save(fn)
+
+    def get_xy_z_for_griddata(self):
+
+        xy = np.asarray([[curvertex.x,curvertex.y] for curpt in self.interpolants for curl in curpt for curvertex in curl])
+        z = np.asarray([curvertex.z for curpt in self.interpolants for curl in curpt for curvertex in curl])
+
+        # if len(np.argwhere(np.isnan(z)))>0:
+        #     test=1
+        # if len(np.argwhere(np.isneginf(z)))>0:
+        #     test=1
+        # if len(np.argwhere(np.isposinf(z)))>0:
+        #     test=1
+        return xy,z
+
+class Interpolators():
+    """ Classe de gestion des interpolations sur sections en travers """
+
+    def __init__(self, banks:Zones, cs:crosssections, ds=1.) -> None:
+        """
+        Constructeur de la classe Interpolators
+
+        @param banks: Zones contenant les vecteurs supports
+        @param cs: objet 'crosssections' contenant les sections en travers --> voir PyCrosssections
+        """
+
+        self.mybanks = [curv for curzone in banks.myzones for curv in curzone.myvectors]
+        cs.set_zones()
+        self.mycs = cs.myzones
+
+        self.myinterp:list[Interpolator]=[]
+
+        zonecs:zone
+        zonecs = self.mycs.myzones[0]
+
+        if zonecs.myvectors[0].up is not None:
+
+            cs1:profile
+            cs1=cs.get_upstream()['cs']
+
+            while cs1.down is not cs1:
+                cs2=cs1.down
+
+                print('{} - {}'.format(cs1.myname,cs2.myname))
+
+                myinterp=Interpolator(cs1,cs2,self.mybanks,ds)
+                self.myinterp.append(myinterp)
+                cs1=cs2
+        else:
+            for i in range(zonecs.nbvectors-1):
+                cs1=zonecs.myvectors[i]
+                cs2=zonecs.myvectors[i+1]
+
+                print('{} - {}'.format(cs1.myname,cs2.myname))
+                myinterp=Interpolator(cs1,cs2,self.mybanks,ds)
+                self.myinterp.append(myinterp)
+
+        self.add_interpolators(cs.myzones.parent)
+
+    def add_interpolators(self, parent):
+        """
+        Ajout d'objets 'Interpolators' pour affichage/stockage
+        """
+        self.myzones = Zones(parent=parent)
+
+        id=0
+        points=[]
+        triangles=[]
+        decal=0
+
+        for curinterp in self.myinterp:
+            id+=1
+
+            myzone = zone(name='Interpolator'+str(id), parent=self.myzones, is2D=False)
+            myzone.used=False
+            self.myzones.add_zone(myzone)
+            curinterp.add_triangles_to_zone(myzone)
+
+            nbpts,pts,tr=curinterp.get_triangles()
+
+            points.append(pts)
+            triangles.append(tr+decal)
+            decal+=nbpts
+
+        curinterp.export_gltf(np.concatenate(points),np.concatenate(triangles))
+
+
+    def viewer_interpolator(self):
+
+        xyz=[]
+        for curinterp in self.myinterp:
+            xyz.append(curinterp.get_xyz_for_viewer())
+
+        xyz=np.concatenate(xyz)
+
+        myviewer(xyz,0)
+
+    def interp_on_array(self, myarray, method:Literal["nearest", "linear", "cubic"]):
+
+        xy=[]
+        z=[]
+        for curinterp in self.myinterp:
+            tmpxy,tmpz = curinterp.get_xy_z_for_griddata()
+            xy.append(tmpxy)
+            z.append(tmpz)
+
+        xy = np.concatenate(xy)
+        z = np.concatenate(z)
+
+        myarray.interpolate_on_cloud(xy,z,method)