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

wolfhece/PyVertexvectors.py

@@ -46,6 +46,7 @@ from .PyVertex import wolfvertex,getIfromRGB,getRGBfromI, cloud_vertices
 from .PyParams import Wolf_Param, Type_Param, new_json
 from .wolf_texture import Text_Image_Texture,Text_Infos
 from .drawing_obj import Element_To_Draw
+from .matplotlib_fig import Matplotlib_Figure as MplFig
 
 class Triangulation(Element_To_Draw):
     def __init__(self, fn='', pts=[], tri=[], idx: str = '', plotted: bool = True, mapviewer=None, need_for_wx: bool = False) -> None:
@@ -2626,6 +2627,83 @@ class vector:
 
         return fig,ax
 
+    def plot_linked_wx(self, fig:MplFig, linked_arrays:dict):
+        """
+        Graphique Matplolib de valeurs dans les matrices liées.
+
+        Version pour wxPython
+        """
+
+        colors=['red','blue','green']
+
+        exit=True
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+                exit=False
+
+        if exit:
+            return
+
+        k=0
+
+        myls = self.asshapely_ls()
+        length = myls.length
+        tol=length/10.
+        fig.cur_ax.set_xlim(0-tol,length+tol)
+
+        zmin=99999.
+        zmax=-99999.
+        nullvalue = -99999
+
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+
+                ds = curarray.get_dxdy_min()
+
+                nb = int(np.ceil(length/ds*2))
+
+                alls = np.linspace(0,int(length),nb)
+
+                pts = [myls.interpolate(curs) for curs in alls]
+
+                allz = np.asarray([curarray.get_value(curpt.x,curpt.y, nullvalue= nullvalue) for curpt in pts])
+
+                zmaxloc=np.max(allz[allz!=nullvalue])
+                zminloc=np.min(allz[allz!=nullvalue])
+
+                zmax=max(zmax,zmaxloc)
+                zmin=min(zmin,zminloc)
+
+                if np.max(allz)>nullvalue:
+                    # select parts
+                    if nullvalue in allz:
+                        # find all parts separated by nullvalue
+                        nulls = np.argwhere(allz==nullvalue)
+                        nulls = np.insert(nulls,0,-1)
+                        nulls = np.append(nulls,len(allz))
+
+                        addlabel = True
+                        for i in range(len(nulls)-1):
+                            if nulls[i+1]-nulls[i]>1:
+                                fig.plot(alls[nulls[i]+1:nulls[i+1]],allz[nulls[i]+1:nulls[i+1]],
+                                        color=colors[np.mod(k,3)],
+                                        lw=2.0,
+                                        label=curlabel if addlabel else None)
+                                addlabel = False
+
+                    else:
+                        fig.plot(alls,allz,
+                                color=colors[np.mod(k,3)],
+                                lw=2.0,
+                                label=curlabel)
+                k+=1
+
+        fig.cur_ax.set_ylim(zmin,zmax)
+        fig.cur_ax.legend()
+        fig.cur_ax.grid()
+
+        return fig
+
     def plot_mpl(self,show=False,forceaspect=True,fig:Figure=None,ax:Axes=None,labels:dict={}):
         """
         Graphique Matplolib du vecteur
@@ -4814,6 +4892,227 @@ class zone:
         ax.set_yticks(np.arange(zmodmin,zmax,.25))
         fig.canvas.draw()
 
+    def plot_linked_polygons_wx(self, fig:MplFig,
+                             linked_arrays:dict, linked_vec:dict[str,"Zones"]=None,
+                             linestyle:str='-', onlymedian:bool=False,
+                             withtopography:bool = True, ds:float = None):
+        """
+        Création d'un graphique sur base des polygones
+
+        Chaque polygone se positionnera sur base de la valeur Z de ses vertices
+           - façon conventionnelle de définir une longueur
+           - ceci est normalement fait lors de l'appel à 'create_polygon_from_parallel'
+           - si les polygones sont créés manuellement, il faut donc prendre soin de fournir l'information adhoc ou alors utiliser l'rgument 'ds'
+
+        ATTENTION : Les coordonnées Z ne sont sauvegardées sur disque que si le fichier est 3D, autrement dit au format '.vecz'
+
+        :param fig: Figure
+        :param ax: Axes
+        :param linked_arrays: dictionnaire contenant les matrices à lier -- les clés sont les labels
+        :param linked_vec: dictionnaire contenant les instances Zones à lier -- Besoin d'une zone et d'un vecteur 'trace/trace' pour convertir les positions en coordonnées curvilignes
+        :param linestyle: style de ligne
+        :param onlymedian: affiche uniquement la médiane
+        :param withtopography: affiche la topographie
+        :param ds: pas spatial le long de l'axe
+
+        """
+
+        colors=['red','blue','green','darkviolet','fuchsia','lime']
+
+        #Vérifie qu'au moins une matrice liée est fournie, sinon rien à faire
+        exit=True
+        for curlabel, curarray in linked_arrays.items():
+            if curarray.plotted:
+                exit=False
+        if exit:
+            return
+
+        k=0
+
+        zmin=99999.
+        zmax=-99999.
+
+        if ds is None:
+            # Récupération des positions
+            srefs=np.asarray([curpol.myvertices[0].z for curpol in self.myvectors])
+        else:
+            # Création des positions sur base de 'ds'
+            srefs=np.arange(0., float(self.nbvectors) * ds, ds)
+
+        for idx, (curlabel, curarray) in enumerate(linked_arrays.items()):
+            if curarray.plotted:
+
+                logging.info(_('Plotting linked polygons for {}'.format(curlabel)))
+                logging.info(_('Number of polygons : {}'.format(self.nbvectors)))
+                logging.info(_('Extracting values inside polygons...'))
+
+                vals= [curarray.get_values_insidepoly(curpol) for curpol in self.myvectors]
+
+                logging.info(_('Computing stats...'))
+
+                values = np.asarray([cur[0] for cur in vals],dtype=object)
+                valel  = np.asarray([cur[1] for cur in vals],dtype=object)
+
+                zmaxloc=np.asarray([np.max(curval) if len(curval) >0 else -99999. for curval in values])
+                zminloc=np.asarray([np.min(curval) if len(curval) >0 else -99999. for curval in values])
+
+                zmax=max(zmax,np.max(zmaxloc[np.where(zmaxloc>-99999.)]))
+                zmin=min(zmin,np.min(zminloc[np.where(zminloc>-99999.)]))
+
+                if zmax>-99999:
+
+                    zloc = np.asarray([np.median(curpoly) if len(curpoly) >0 else -99999. for curpoly in values])
+
+                    fig.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                            color=colors[np.mod(k,3)],
+                            lw=2.0,
+                            linestyle=linestyle,
+                            label=curlabel+'_median')
+
+                    zloc = np.asarray([np.min(curpoly) if len(curpoly) >0 else -99999. for curpoly in values])
+
+                    if not onlymedian:
+
+                        fig.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                                color=colors[np.mod(k,3)],alpha=.3,
+                                lw=2.0,
+                                linestyle=linestyle,
+                                label=curlabel+'_min')
+
+                        zloc = np.asarray([np.max(curpoly) if len(curpoly) >0 else -99999. for curpoly in values])
+
+                        fig.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                                color=colors[np.mod(k,3)],alpha=.3,
+                                lw=2.0,
+                                linestyle=linestyle,
+                                label=curlabel+'_max')
+
+                if withtopography and idx==0:
+                    if valel[0] is not None:
+                        zmaxloc=np.asarray([np.max(curval) if len(curval) >0 else -99999. for curval in valel])
+                        zminloc=np.asarray([np.min(curval) if len(curval) >0 else -99999. for curval in valel])
+
+                        zmax=max(zmax,np.max(zmaxloc[np.where(zmaxloc>-99999.)]))
+                        zmin=min(zmin,np.min(zminloc[np.where(zminloc>-99999.)]))
+
+                        if zmax>-99999:
+
+                            zloc = np.asarray([np.median(curpoly) if len(curpoly) >0 else -99999. for curpoly in valel])
+
+                            fig.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                                    color='black',
+                                    lw=2.0,
+                                    linestyle=linestyle,
+                                    label=curlabel+'_top_median')
+
+                        # if not onlymedian:
+                            # zloc = np.asarray([np.min(curpoly) for curpoly in valel])
+
+                            # ax.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                            #         color='black',alpha=.3,
+                            #         lw=2.0,
+                            #         linestyle=linestyle,
+                            #         label=curlabel+'_top_min')
+
+                            # zloc = np.asarray([np.max(curpoly) for curpoly in valel])
+
+                            # ax.plot(srefs[np.where(zloc!=-99999.)],zloc[np.where(zloc!=-99999.)],
+                            #         color='black',alpha=.3,
+                            #         lw=2.0,
+                            #         linestyle=linestyle,
+                            #         label=curlabel+'_top_max')
+
+                k+=1
+
+        for curlabel, curzones in linked_vec.items():
+            curzones:Zones
+            names = [curzone.myname for curzone in curzones.myzones]
+            trace = None
+            tracels = None
+
+            logging.info(_('Plotting linked zones for {}'.format(curlabel)))
+
+            curzone: zone
+            if 'trace' in names:
+                curzone = curzones.get_zone('trace')
+                trace = curzone.get_vector('trace')
+
+                if trace is None:
+                    if curzone is not None:
+                        if curzone.nbvectors>0:
+                            trace = curzone.myvectors[0]
+
+                if trace is not None:
+                    tracels = trace.asshapely_ls()
+                else:
+                    logging.warning(_('No trace found in the vectors {}'.format(curlabel)))
+                    break
+
+            if ('marks' in names) or ('repères' in names):
+                if ('marks' in names):
+                    curzone = curzones.myzones[names.index('marks')]
+                else:
+                    curzone = curzones.myzones[names.index('repères')]
+
+                logging.info(_('Plotting marks for {}'.format(curlabel)))
+                logging.info(_('Number of marks : {}'.format(curzone.nbvectors)))
+
+                for curvect in curzone.myvectors:
+                    curls = curvect.asshapely_ls()
+
+                    if curls.intersects(tracels):
+                        inter = curls.intersection(tracels)
+                        curs = float(tracels.project(inter))
+
+                        fig.plot([curs, curs], [zmin, zmax], linestyle='--', label=curvect.myname)
+                        fig.text(curs, zmax, curvect.myname, fontsize=8, ha='center', va='bottom')
+
+            if ('banks' in names) or ('berges' in names):
+
+                if ('banks' in names):
+                    curzone = curzones.myzones[names.index('banks')]
+                else:
+                    curzone = curzones.myzones[names.index('berges')]
+
+                logging.info(_('Plotting banks for {}'.format(curlabel)))
+                logging.info(_('Number of banks : {}'.format(curzone.nbvectors)))
+
+                for curvect in curzone.myvectors:
+                    curvect: vector
+
+                    curproj = curvect.projectontrace(trace)
+                    sz = curproj.asnparray()
+                    fig.plot(sz[:,0], sz[:,1], label=curvect.myname)
+
+            if ('bridges' in names) or ('ponts' in names):
+                if ('bridges' in names):
+                    curzone = curzones.myzones[names.index('bridges')]
+                else:
+                    curzone = curzones.myzones[names.index('ponts')]
+
+                logging.info(_('Plotting bridges for {}'.format(curlabel)))
+
+                for curvect in curzone.myvectors:
+                    curvect: vector
+                    curls = curvect.asshapely_ls()
+
+                    if curls.intersects(tracels):
+
+                        logging.info(_('Bridge {} intersects the trace'.format(curvect.myname)))
+
+                        inter = curls.intersection(tracels)
+                        curs = float(tracels.project(inter))
+                        locz = np.asarray([vert.z for vert in curvect.myvertices])
+                        zmin = np.amin(locz)
+                        zmax = np.amax(locz)
+
+                        fig.plot(curs, zmin, label=curvect.myname + ' min', marker='x')
+                        fig.plot(curs, zmax, label=curvect.myname + ' max', marker='x')
+
+        fig.cur_ax.set_ylim(zmin,zmax)
+        zmodmin= np.floor_divide(zmin*100,25)*25/100
+        fig.cur_ax.set_yticks(np.arange(zmodmin,zmax,.25))
+
     def reset_listogl(self):
         """
         Reset OpenGL lists.
@@ -7673,6 +7972,11 @@ class Zones(wx.Frame, Element_To_Draw):
 
             if self.active_vector is None:
                 logging.warning(_('No vector in the active zone'))
+                if self.parent is not None:
+                    try:
+                        self.parent.Active_zone(self.active_zone)
+                    except:
+                        raise Warning(_('Not supported in the current parent -- see PyVertexVectors in Activate_zone function'))
             else:
                 self.labelactvect.SetLabel(self.active_vector.myname)
 

wolfhece/apps/check_install.py

@@ -58,6 +58,45 @@ def main():
         ret += 'Wolfhece not installed properly\n Please install the VC++ redistributable\n from https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads\n\n'
         ret += 'Error : ' + str(e) + '\n\n'
 
+    from pathlib import Path
+    dirlaz = Path(__file__).parent.parent / 'lazviewer'
+    dirs_to_test =  [dirlaz / 'libs', dirlaz / 'libs/qt_plugins', dirlaz / 'libs/qt_plugins/platforms']
+
+    for d in dirs_to_test:
+        if not d.exists() or not d.is_dir():
+            ret += str(d) + ' does not exist\n\n'
+
+    curdir = dirlaz / 'libs/qt_plugins/platforms'
+    files_to_test = [curdir / 'qwindows.dll']
+
+    for f in files_to_test:
+        if not f.exists() or not f.is_file():
+            ret += str(f) + ' does not exist\n\n'
+
+    curdir = dirlaz / 'libs'
+    files_to_test = [curdir / 'icudt53.dll', curdir / 'icuin53.dll', curdir / 'icuuc53.dll',
+                     curdir / 'msvcp120.dll', curdir / 'msvcr120.dll', curdir / 'Qt5Core.dll',
+                     curdir / 'Qt5Gui.dll', curdir / 'Qt5Network.dll', curdir / 'Qt5Widgets.dll',
+                     curdir / 'tbb.dll', curdir / 'tbbmalloc.dll', curdir / 'vcomp120.dll']
+
+    for f in files_to_test:
+        if not f.exists() or not f.is_file():
+            ret += str(f) + ' does not exist\n\n'
+
+    try:
+        from ..lazviewer.viewer import viewer
+        import numpy as np
+
+        pts = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2]])
+        myview = viewer.viewer(pts, debug = True)
+
+        ret += 'LAZ viewer created in debug mode -- check for errors if reported\n\n'
+
+    except ImportError as e:
+        ret += 'Could not import/create LAZ viewer\n\n'
+        ret += 'Wolfhece not installed properly\n Please check if QT \n\n'
+        ret += 'Error : ' + str(e) + '\n\n'
+
     print(ret)
 
 if __name__=='__main__':

wolfhece/apps/version.py

@@ -5,7 +5,7 @@ class WolfVersion():
 
         self.major = 2
         self.minor = 1
-        self.patch = 118
+        self.patch = 120
 
     def __str__(self):
 

wolfhece/lazviewer/_add_path.py

@@ -1,23 +1,23 @@
-import os
-import os.path
-import sys
-import platform
+# import os
+# import os.path
+# import sys
+# import platform
 
 
-def _add_path():
-    _root_dir = os.path.dirname(os.path.realpath(__file__))
+# def _add_path():
+#     _root_dir = os.path.dirname(os.path.realpath(__file__))
 
-    # manual specify list of dll directories, with paths relative to _root_dir
-    _dll_dirs = ['libs']
+#     # manual specify list of dll directories, with paths relative to _root_dir
+#     _dll_dirs = ['libs']
 
-    if platform.system() == 'Windows':
-        os.environ.setdefault('PATH', '')
-        paths = os.environ['PATH'].split(';')
-        for x in _dll_dirs:
-            x = os.path.join(_root_dir, x)
-            if os.path.isdir(x) and x not in paths:
-                paths = [x] + paths
-        os.environ['PATH'] = ';'.join(paths)
+#     if platform.system() == 'Windows':
+#         os.environ.setdefault('PATH', '')
+#         paths = os.environ['PATH'].split(';')
+#         for x in _dll_dirs:
+#             x = os.path.join(_root_dir, x)
+#             if os.path.isdir(x) and x not in paths:
+#                 paths = [x] + paths
+#         os.environ['PATH'] = ';'.join(paths)
 
 
-_add_path()
+# _add_path()