SHARE
TWEET

simplification de graph

a guest Feb 19th, 2019 65 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. """ simplify the graph
  2.    @G : le graph etudier
  3.    @simplify_on : sur quoi simplifier
  4.        ex: NDVI, CODE CULTURE...
  5.    @criteria : quel relation simplifier
  6.    """    
  7.     def simplify_graphV2(self, G, simplify_on, criteria):
  8.  
  9.         # condition de terminaison
  10.         exit = False
  11.  
  12.         nombre_dispo = G.number_of_nodes()
  13.  
  14.         # graph des dummies
  15.         G_dummy = nx.Graph()
  16.         G_dummy = G_dummy.to_directed()
  17.        
  18.         l_priorite = ["EC", "tres_proche", "PO", "Moyen proche", "peu proche"]
  19.  
  20.         while(not exit):
  21.  
  22.             # si il n'y a plus de lien, on sort
  23.             if not G.edges():
  24.  
  25.                 exit = True
  26.                 break
  27.  
  28.             # pour chaques liens
  29.             for u,v in G.edges() :
  30.    
  31.                 # si le liens doit etre simplifier
  32.                 if ((G[u][v]["label"] == criteria) and
  33.                 (G.has_edge(v, u)) and
  34.                 (G[u][v]["label"] == criteria) and
  35.                 (G.node[u]["data"][simplify_on] == G.node[v]["data"][simplify_on])):
  36.  
  37.                     # il faut reverifier les autres liens
  38.                     exit = False
  39.                    
  40.                     # avant de fusionner les noeuds,
  41.                     # il faut determiner quels relation transmettre
  42.  
  43.                     # pour chaque relation entrante en v
  44.                     for a, b in G.in_edges(v):
  45.                         if (a != u and b != u):
  46.                            
  47.                             # si a n'a pas de relation vers u
  48.                             # alors ajouter cette relation
  49.  
  50.                             if not G.has_edge(a, u):
  51.  
  52.                                 G.add_edge(a, u,
  53.                                         label = G[a][b]["label"],
  54.                                         color = G[a][b]["color"])
  55.  
  56.                             # si u est deja en relation avec b
  57.                             # alors regarder quel relation est prioritaire
  58.                             # et maj si besoin
  59.  
  60.                             else:
  61.  
  62.                                 label_bu = G[b][u]["label"]
  63.                                 label_ab = G[a][b]["label"]
  64.  
  65.                                 # obtenont leurs rangs respectif
  66.                                 # en regardant dans la liste de priorite
  67.  
  68.                                 rang_bu = l_priorite.index(label_bu)
  69.                                 rang_ab = l_priorite.index(label_ab)
  70.  
  71.                                 if rang_ab < rang_bu:
  72.  
  73.                                     # il faut maj
  74.                                     G[b][u]["label"] = label_ab
  75.                    
  76.    
  77.  
  78.                     # meme raisonnement pour les relations sortantes
  79.                     for a, b in G.out_edges(v):
  80.                         if (a != u and b != u):
  81.                            
  82.                             # si u n'a pas de relation vers v
  83.                             # alors ajouter cette relation
  84.  
  85.                             if not G.has_edge(u, b):
  86.  
  87.                                 G.add_edge(u, b,
  88.                                         label = G[a][b]["label"],
  89.                                         color = G[a][b]["color"])
  90.  
  91.                             # si u est deja en relation avec b
  92.                             # alors regarder quel relation est prioritaire
  93.                             # et maj si besoin
  94.  
  95.                             else:
  96.  
  97.                                 label_ub = G[u][b]["label"]
  98.                                 label_ab = G[a][b]["label"]
  99.  
  100.                                 # obtenont leurs rangs respectif
  101.                                 # en regardant dans la liste de priorite
  102.  
  103.                                 rang_ub = l_priorite.index(label_ub)
  104.                                 rang_ab = l_priorite.index(label_ab)
  105.  
  106.                                 if rang_ab < rang_ub:
  107.  
  108.                                     # il faut maj
  109.                                     G[u][b]["label"] = label_ab
  110.  
  111.  
  112.                     # on ajoute des noeuds et edges
  113.                     # dummies
  114.  
  115.                     if not G_dummy.has_node(u):
  116.                         G_dummy.add_node(u,
  117.                                 pos = G.node[u]["pos"])
  118.                    
  119.                     if not G_dummy.has_node(v):
  120.                         G_dummy.add_node(v,
  121.                             pos  = G.node[v]["pos"])
  122.  
  123.                     G_dummy.add_edge(v, u, label="dummy", color = "grey")
  124.  
  125.                     # la parcelle est maintenant l'union des
  126.                     # deux parcelles
  127.                     new_geo = shapely.ops.unary_union(
  128.                             [G.node[u]["data"]["geometry"],
  129.                             G.node[v]["data"]["geometry"]])
  130.                            
  131.                
  132.                     G.node[u]["data"]["geometry"] = new_geo
  133.                    
  134.                    # supression et maj des noeuds / liens
  135.                     G.remove_edge(u, v)
  136.                     G.remove_node(v)
  137.  
  138.                     break
  139.  
  140.                 else:
  141.                    
  142.                     exit = True
  143.  
  144.         for n in G.nodes:
  145.  
  146.             # on cherche un nr dispo
  147.             while (G_dummy.has_node(nombre_dispo) or
  148.                     G.has_node(nombre_dispo)):
  149.                 nombre_dispo = nombre_dispo + 1
  150.  
  151.             # mettons a jour les coordonnes des noeuds
  152.             centroid = G.node[n]["data"]["geometry"].centroid
  153.            
  154.  
  155.             # les dummies sont a jour sauf pour le noeud
  156.             # fussiones. reglons cela
  157.             if (G_dummy.has_node(n)
  158.             and G.node[n]["pos"] != centroid):
  159.  
  160.                 G_dummy.add_node(nombre_dispo,
  161.                         pos = G.node[n]["pos"])
  162.  
  163.                 G_dummy.add_edge(nombre_dispo, n, label="dummy", color = "grey")
  164.                 G_dummy.node[n]["pos"] = (centroid.x, centroid.y)
  165.            
  166.             G.node[n]["pos"] = (centroid.x, centroid.y)
  167.  
  168.         return G, G_dummy
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top