2017-07-03 1 views
0

Je suis en train d'essayer d'animer un graphe networkx croissant avec le temps. J'ai il travaille avec des bords incurvés et tous. Assez satisfait, MAIS comme le graphique se développe, il ralentit considérablement? Quelqu'un peut-il expliquer ou modifier le code donné pour courir plus vite. Je ne pense pas que c'est mon ordinateur qui est le problème. NOTE: Même sans les bords incurvés fantaisie c'était très lent. Un nx.draw simple, causerait le même problèmeAnimation très lente de graphe de réseau dans matplotlib de Python avec networkx


import time 
from matplotlib import pyplot as plt 
from matplotlib import animation 
import networkx as nx 
from matplotlib.patches import FancyArrowPatch, Circle 
import numpy as np 

mainGraph = nx.DiGraph() 
nodeToCoordinate_dict = {} 
label_coordinatePositions = {} 
edgeLabel_coordinatePositions = {} 
edgeLabel_values_dict = {} 
fig = plt.figure() 


#============================================================= 

def draw_network(G,pos,ax,sg=None): 
    e = None 
    for n in G: 
     c=Circle(pos[n],radius=0.02,alpha=0.5) 
     ax.add_patch(c) 
     G.node[n]['patch']=c 
     x,y=pos[n] 
    seen={} 
    for (u,v,d) in G.edges(data=True): 
     n1=G.node[u]['patch'] 
     n2=G.node[v]['patch'] 
     rad=0.1 
     if (u,v) in seen: 
      rad=seen.get((u,v)) 
      rad=(rad+np.sign(rad)*0.1)*-1 
     alpha=0.5 
     color='k' 

     e = FancyArrowPatch(n1.center,n2.center,patchA=n1,patchB=n2, 
          arrowstyle='-|>', 
          connectionstyle='arc3,rad=%s'%rad, 
          mutation_scale=10.0, 
          lw=2, 
          alpha=alpha, 
          color=color) 
     seen[(u,v)]=rad 
     ax.add_patch(e) 

    return e 


#======================================================== 

def animate(i): 
    startTime = time.time() 
    """perform animation step""" 
    global mainGraph, nodeToCoordinate_dict, label_coordinatePositions    

    mainGraph.add_node(str(i%20)+","+str(i/20), pos = (i%20,i/20)) 
    if not (i%20 == 0): 
     mainGraph.add_edge(str(i%20-1)+","+str(i/20), str(i%20)+","+str(i/20))   
     prevNode_coordinate = nodeToCoordinate_dict[str(i%20-1)+","+str(i/20)] 

     mainGraph[str(i%20-1)+","+str(i/20)][str(i%20)+","+str(i/20)]['p'] = 1.0 
    #END IF  
    nodeToCoordinate_dict[str(i%20)+","+str(i/20)] = (i%20,i/20)        
    ax=plt.gca() 
    draw_network(mainGraph,nodeToCoordinate_dict,ax) 
    ax.autoscale() 
    plt.axis('equal') 
    plt.axis('off')   
    print("time Elapsed = ", time.time()-startTime) 
    return None #mainGraph 

#==================================================== 

ani = animation.FuncAnimation(fig, animate, frames= 60,interval=1000) 
plt.show() 
+0

Désolé - lorsque je copie et collez ceci, j'obtiens un tracé montrant un seul nœud, puis beaucoup d'erreurs de clé. – Joel

+0

@Joel c'est étrange, j'ai copié le code ci-dessus dans un nouveau script isolé et il a fonctionné comme prévu. Avez-vous les importations nécessaires? Peut-être un networkx mis à jour et matplotlib. Aussi, s'il vous plaît coller le message d'erreur le plus pertinent et je pourrais être en mesure de comprendre quel est votre problème –

Répondre

0

Je pense que je compris. La fonction qui utilise "matplotlib.patches import FancyArrowPatch, Circle" le ralentit. C'est la fonction "draw_network".

J'ai essayé de remplacer le code de dessin par le plus simple (nx.draw (mainGraph, nodeToCoordinate_dict)) et réduit l'intervalle de temps à 100 (0,1 seconde). Travaillé comme un charme

Maintenant, je dois juste trouver un moyen d'accélérer le graphique avec des bords incurvés.