[PYTHON] Dessin en temps réel avec matplotlib

motivation

Il y a des moments où vous souhaitez vérifier les valeurs des capteurs ou tracer l'état d'apprentissage de l'apprentissage automatique sur un graphique en temps réel. python a une bibliothèque de création de graphes pratique appelée `` matplotlib '', donc je veux l'utiliser.

Problèmes connus

Normalement lors de la création d'un graphe avec `` matplotlib ''

import matplotlib.pyplot as plt

"""
Traitement pour calculer les données que vous souhaitez tracer
...
"""
plt.plot(data)
plt.show()

Je le ferai. Cependant, si vous appelez show () '', le programme y sera bloqué et vous ne pourrez pas dessiner en temps réel. Si vous le recherchez, utilisez des articles comme draw () '' au lieu de show () '', ou combinez-le avec des bibliothèques d'interface graphique telles que Tkinter (tkinter) '' et Qt. Dans un environnement Windows, si vous touchez le graphique une seule fois, l'interface graphique se fige et vous ne pouvez pas l'utiliser même si ce n'est pas très bon. (Je pense qu'il pourrait être utilisé dans un environnement Unix tel que Mac.)

Utilisons pause () !!!

Comme dans l'exemple, il y avait un échange lié à celui-ci dans le débordement de pile. [Référence: traçage en temps réel en boucle while avec matplotlib](http://stackoverflow.com/questions/11874767/real-time-plotting-in- while-loop-with-matplotlib)

La conclusion est d'utiliser plt.pause (intervalle) '' au lieu de plt.show () ''. Vous trouverez ci-dessous un exemple de traçage d'une simple fonction sin pour toujours.

J'ai écrit des notes dans les commentaires, alors veuillez les lire.

matplotlib_realtime_plot_example.py

# -*- coding: utf-8 -*-
"""
Exemple de traçage en temps réel avec matplotlib

Continuer à tracer la fonction sin indéfiniment
"""
from __future__ import unicode_literals, print_function

import numpy as np
import matplotlib.pyplot as plt


def pause_plot():
    fig, ax = plt.subplots(1, 1)
    x = np.arange(-np.pi, np.pi, 0.1)
    y = np.sin(x)
    #Doit être tracé une fois pour l'initialisation
    #A ce moment, il est nécessaire de recevoir l'objet tracé.
    #Notez que la liste sera retournée
    lines, = ax.plot(x, y)

    #Tracer infiniment d'ici
    while True:
        #Mettre à jour les données du tracé
        x += 0.1
        y = np.sin(x)

        #Si vous utilisez la fonction de tracé lors de la mise à jour des données de dessin
        #Notez que l'objet ligne augmentera à chaque fois.
        #
        #Le plus simple est pour les lignes reçues ci-dessus
        # set_data()Comment mettre à jour les données de dessin avec une méthode.
        lines.set_data(x, y)

        # set_data()Il semble que l'axe ne soit pas réglé automatiquement lorsque vous utilisez
        #Dans cet exemple, la courbe de péché disparaît de la plage de dessin en un clin d'œil.
        #Par conséquent, il est nécessaire de modifier la plage de l'axe des x comme il convient.
        ax.set_xlim((x.min(), x.max()))

        #Le meilleur point
        # - plt.show()Bloqué et ne peut pas être représenté en temps réel
        # - plt.ion() + plt.draw()Ne peut pas être utilisé car la fenêtre graphique se fige et le programme s'arrête
        # ----> plt.pause(interval)Utilisez ceci!!!L'argument est le temps de sommeil
        plt.pause(.01)

if __name__ == "__main__":
    pause_plot()

Cela fera beaucoup de progrès !!!

prime

Le débordement de pile mentionné ci-dessus décrit également une méthode utilisant un package appelé drawnow, je vais donc l'introduire. Puisque drawow est entré avec pip

$ pip install drawnow

D'ACCORD.

Comment utiliser

matplotlib_drawnow_realtime_plot_example.py

# -*- coding: utf-8 -*-
"""
Exemple de traçage en temps réel avec matplotlib

Continuer à tracer la fonction sin indéfiniment
"""
from __future__ import unicode_literals, print_function

import numpy as np
import matplotlib.pyplot as plt
from drawnow import drawnow, figure

def drawnow_plot():
    #Utilisation de la fonction figure incluse dans le package drawnow
    #Créer un objet figure
    fig = figure()
    x = np.arange(-np.pi, np.pi, .1)
    y = np.sin(x)

    def draw():
        """
Décrire le traitement requis pour que le tracé soit transmis à la fonction drawow
Les variables requises pour le tracé doivent être des variables dans la portée auxquelles cette fonction peut accéder.
        """
        plt.plot(x, y)

    while True:
        x += .1
        y = np.sin(x)
        drawnow(draw)

... J'ai regardé le code source après l'avoir écrit, mais il semble que drawnow appelle `` draw () '' à la fin, et cela n'a pas fonctionné quand je l'ai fait sur Windows (un phénomène où l'interface graphique se fige). ..

Conclusion

Si vous voulez tracer en temps réel, utilisez `` plt.pause () '' !!!