wolfhece 2.1.119__py3-none-any.whl → 2.1.121__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.

wolfhece/acceptability/acceptability.py

@@ -566,26 +566,30 @@ def Acceptability(main_dir:str = 'Vesdre',
 
                 comb += part_accept[curT] * float(pond["Ponderation"][curT])
 
-            y_pixels, x_pixels = comb.shape  # number of pixels in x
+            y_pixels, x_pixels = comb.shape 
 
-            # Set up output GeoTIFF
             driver = gdal.GetDriverByName('GTiff')
-            
-            dataset = driver.Create(str(saveA),
-                                    x_pixels, y_pixels,
-                                    1,
-                                    gdal.GDT_Float32,
-                                    options=["COMPRESS=LZW"])
+
+            dataset = driver.Create(
+                str(saveA),
+                x_pixels, y_pixels,
+                1,
+                gdal.GDT_Float32,
+                options=["COMPRESS=LZW"]
+            )
 
             assert comb.dtype == np.float32, "The dtype of the combined acceptability matrix is not np.float32"
 
-            dataset.GetRasterBand(1).WriteArray(comb)
             dataset.SetGeoTransform(geotrans)
             dataset.SetProjection(proj)
-            dataset.FlushCache()
-            dataset=None
-        
-        done.append(steps_acceptability.COMPUTE_MEAN_ACCEPT)
+            band = dataset.GetRasterBand(1)
+            band.WriteArray(comb)  
+            band.FlushCache()  
+            dataset.SetGeoTransform(geotrans)
+            dataset.SetProjection(proj)
+            dataset = None
+
+            done.append(steps_acceptability.COMPUTE_MEAN_ACCEPT)
         
         if 6 in steps or steps_acceptability.RESAMPLING in steps:
             if os.path.exists(manager.OUT_ACCEPT):