---

Avant-propos

Quelques exemples.
 

• Étudiez ou révisez Matplotlib (Rechercher sur Youtube et Google).
  • Essentiellement subplots : je dis bien subplots et non subplot !.
• Étudiez ou révisez les fonctions basiques de Numpy.
• Étudiez ou révisez psutils.Popen (Utilisé au point 8 du plan du tuto ci-dessous).

---

Description

1. Classe de base.
2. Classe pour Matplotlib.
3. Affichage d'une courbe.
4. Refactoring.
5. Animation : mise à jour de a courbe.
6. Persistance de la géométrie.
7. Événements clavier.
8. Pilotage depuis le poste ce contrôle.

---

• Nous allons utiliser différentes interfaces de visualisation, chacune présentant ses spécificités et ses performances.
• Le choix est fait dans le poste de contrôle / paramétrage des afficheurs / Fenêtre / Interface.
  • Vous pouvez augmenter / réduire cette liste, néanmoins, conservez Matplotlib et Pyqtgraph.
    • 'Matplotlib', 'Pyqtgraph', 'Plotly', 'Bokeh', 'Cufflinks', 'Dash', 'Guiqwt', 'OpenCV', 'Seaborn'
• Chacune aura sa classe, mais les éléments communs sont groupés dans la classe de base : ShowBase, dans le fichier show_base.py.

/show/show_base.py :

class ShowBase:
    """ Classe de base pour Matplotlib, Pyqtgraph, Bokeh, etc. """
    def __init__(self):
        pass

Pour l'instant vide, cette classe sera complétée au fur et à mesure.
 

---

Retour au plan

• Pour la mise au point (MAP), partons de l'exemple du dernier tuto :
  • Graphe 'Exercices'
  • ID des plots : 9 et 10 (pour la MAP, nous utiliserons le 9)
  • Si vous n'avez pas les mêmes valeurs, modifiez le code suivant en conséquence !
• Code minimaliste → /show/show_matplotlib.py :

  from show.show_base import ShowBase
  import sys
  from matplotlib import pyplot as plt
  
  
  class ShowMatPlotLib(ShowBase):
      def __init__(self):
          super().__init__()
          self.fig, self.ax = plt.subplots()
          plt.show()
  
  
  if __name__ == '__main__':
      sys.argv.append('Exercices')    # Nom du graphe.
      sys.argv.append('9')            # Plots id. (La ligne de commande ne doit contenir que du str).
      sys.argv.append('-1')           # Gestion de la fermeture automatique. Poste de contrôle PID : -1 en local.
      mpl = ShowMatPlotLib()
  

  matplotlib doit être installé !
   

• Exécutez ce code : Clic droit / Run 'show_matplotlib'

Vérification.

• Nous avons posé la base de travail. Partant de là, nous allons enrichir ce projet :
  • Affichage d'une courbe.
  • Pilotage depuis le poste de controle.
  • Persistance de la géométrie.
  • Etc.

---

Retour au plan

• Nous allons créer la méthode show_anim qui affichera une courbe aléatoire pour nos tests.
• Elle s'appelle ainsi car elle pourra être appelée en répétition dans une boucle ou un timer, et produire une animation.
  ShowMatPlotLib.show_anim :

      def show_anim(self):
          y = np.random.randn(100)
          self.ax.set_ylim(np.min(y), np.max(y))
          self.line.set_ydata(y)
          plt.pause(.001)
  

• Oui mais ... il faut installer puis importer la librairie Numpy :

  import numpy as np
  

   

• Modifier l'init pour l'appeler.
  ShowMatPlotLib.__init__ :

      def __init__(self):
          super().__init__()
          self.fig, self.ax = plt.subplots()
          self.line = self.ax.plot(np.zeros((100,)))[0]
          self.show_anim()
          plt.show()
  

   

---

Retour au plan

• Avant de poursuivre, nous allons structurer notre code pour bien l'organiser :
  • La méthode __init__ déclare les attributs, puis appelle le setup.
    • Les affectations très simples pourront se faire directement dans l'init.
  • La méthode setup affecte les attributs, et lance les diverses initialisations.
• Par conséquent, nous allons remplacer la méthode __init__ par 2 méthodes.
  ShowMatPlotLib.__init__ :

      def __init__(self):
          super().__init__()
          self.fig = None
          self.ax = None
          self.line = None
          self.setup()   # Placé à la fin.
  

  
  ShowMatPlotLib.setup :

      def setup(self):
          """ Chemin complet du node final 'Plots' contenant les modèles de calculs. """
          # à compléter plus tard.
  
          """ Nom complet du fichier de configuration, éditable manuellement en yaml. """
          # à compléter plus tard.
  
          """ Liste de tous les fichiers du node final : modèles de calcul (calc_*.pkl), config (*.yaml), ...  """
          # à compléter plus tard.
  
          """ Initialisations. """
          self.fig, self.ax = plt.subplots()
          self.line = self.ax.plot(np.zeros((100,)))[0]
          self.show_anim()
  
          """ Restauration de l'état de la fenêtre. """
          # à compléter plus tard.
  
          """ Surveillance des fichiers yaml et pkl. """
          # à compléter plus tard.
  
          """ Événements. """
          # à compléter plus tard.
  
          """ Boucles. """
          plt.show()
  

  On remarque que le setup est déjà organisé en groupes (nous allons les compléter pas à pas).
   

---

Retour au plan

• La meilleure solution en terme de performances est d'utiliser une horloge asynchrone (QTimer).
• Dans __init__ ajouter un timer et une période à priori de 500 ms.
  Ajouter ces 2 lignes dans ShowMatPlotLib.__init__ :

          self.anim = QTimer()
          self.delay = 500
  

   

• Oui mais ... il faut importer QTimer depuis PyQt5.QtCore :

  from PyQt5.QtCore import QTimer
  

   

• Lancer l'animation depuis le setup.
  Section """ Événements """, dans ShowMatPlotLib.setup :

          """ Événements. """
          self.anim.timeout.connect(self.show_anim)
  

  
  Section """ Boucles """, dans ShowMatPlotLib.setup 

          """ Boucles. """
          self.anim.start(self.delay)
          plt.show()
  

   

• Vérifier : La courbe est actualisée toutes les 500 ms.

---

Retour au plan

• Nous allons procéder comme pour la fenêtre Main du poste de contrôle.
  • ... en utilisant les méthodes save_state et restore_state de la classe Utils.
• Du point de vue du poste de contrôle il peut y avoir plusieurs nodes de type 'Plots' dans un graphe.
• Par conséquent, nous aurons besoin de plusieurs fichiers de configuration pour mémoriser les différentes géométries.
• Nous connaissons le nom du graphe ainsi que l'ID du node 'Plots', grace aux arguments passés en ligne de commande.
  • Pour la MAP, ils sont simulés à la fin du fichier  show_matplotlib.py , dans sys.argv.append(...).

1. Ajouter ces 3 lignes (après super().__init__()) au début de la méthode __init__ :

           self.graph_name = sys.argv[1]
           self.node_id = int(sys.argv[2])
           self.parent_pid = int(sys.argv[3])
   

   sys.argv est une liste qui contient tous les arguments de la ligne de commande.
    

2. Coder le chemin complet du node final, en ajoutant ces lignes dans le setup.
   Section """ Chemin complet du node final ... etc. """ ShowMatPlotLib.setup :

           """ Chemin complet du node final 'Plots' contenant les modèles de calculs. """
           bk_path = os.path.dirname(__file__).replace('show', 'backups')  # Dossier de backup.
           final_path = os.path.normpath(os.path.join(bk_path, self.graph_name, f'node{self.node_id}'))  # Node 'Plots'
           self.ut = Utils(final_path)
   

   Importer os et Utils (from functions.utils import Utils).
    

3. Outre l'import de os et Utils, il faut aussi déclarer self.ut dans __init__ :
   ShowMatPlotLib.__init__ :

           self.ut = None
   

    

4. Nous devons modifier l'instanciation de la classe Utils (Cette modification n'a aucune incidence sur le reste du code).
   utils.py > Utils.__init__ :

       def __init__(self, path=''):
           self.o_dt = DateTime()  # o_dt = 'Object DateTime'
           self.caller_dir = os.getcwd()  # dossier du code appelant. Ne pas remplacer getcwd()
           path_conf = self.caller_dir if path == '' else path
           self.settings = QSettings(f"{path_conf}{os.sep}params.conf", QSettings.IniFormat)
           self.watcher = None
   

    

5. Créer un "surveillant", lancé par timer : la méthode listener.
   ShowMatPlotLib.listener :

       def listener(self):
           geometry = self.get_real_geometry()
           if self.geometry != geometry:
               self.ut.save_state(self.mgr.window)
               self.geometry = geometry
   

6. Oui mais ... la méthode get_real_geometry ainsi que la propriété mgr n'existent pas. Créons-les.
   ShowMatPlotLib.get_real_geometry :

       def get_real_geometry(self):
           geom = self.mgr.window.geometry()
           return geom.x(), geom.y(), geom.width(), geom.height()
   

   
   @property ShowMatPlotLib.mgr :

       @property
       def mgr(self):
           return plt.get_current_fig_manager()
   

    

7. L'attribut self.geometry doit être déclaré dans __init__ :

           self.geometry = None
   

    

8. Créer le timer listen dans __init__.
   Ajouter cette ligne dans ShowMatPlotLib.__init__ :

           self.listen = QTimer()
   

   
   Ajouter la surveillance à la fréquence de 1 Hertz dans le setup.
   Section """ Événements. """  ShowMatPlotLib.setup :

           """ Événements. """
           self.listen.timeout.connect(self.listener)
           self.anim.timeout.connect(self.show_anim)
   

   Section """ Boucles. """  ShowMatPlotLib.setup :

           """ Boucles. """
           self.listen.start(1000)
           self.anim.start(self.delay)
           plt.show()
   

    

9. Nous pouvons enfin, depuis le setup, lire l'état de la fenêtre au lancement et l'appliquer.
   Section """ Restauration de l'état de la fenêtre. """  ShowMatPlotLib.setup :

           """ Restauration de l'état de la fenêtre. """
           self.ut.restore_state(self.mgr.window)
   

10. Vérifiez.

---

Retour au plan

• Pour l'instant, on se limite à 3 touches du clavier : à vous d'en ajouter d'autres, selon vos besoins.
  • Barre d'espace du clavier : Pause / Reprise.
  • Touche '+' : Accélération.
  • Touche '-' : Ralentissement.
• Ajouter la méthode key_event.
   ShowMatPlotLib.key_event :

      def key_event(self, ev):
          """ Appui sur une touche du clavier. """
          keycode = ev.key
          if keycode == ' ':
              """ Pause on/off. """
              self.paused = not self.paused
              self.anim.stop() if self.paused else self.anim.start(int(self.delay))
          elif keycode == '+':
              """ Accélérer. """
              self.anim.stop()
              self.delay /= 1.5
              self.delay = max(5, self.delay)
              self.anim.start(int(self.delay))
          elif keycode == '-':
              """ Ralentir. """
              self.anim.stop()
              self.delay *= 1.5
              self.delay = min(5000, self.delay)
              self.anim.start(int(self.delay))
  

• L'attribut self.paused est nécessaire, mais il est absent.
  Ajouter cette ligne dans ShowMatPlotLib.__init__ :

          self.paused = False
  

• Étudiez ce code pour l'adapter à vos besoins :
  • La vitesse varie avec un pas géométrique de 1.5
  • La période est bornée entre 5 et 5000 ms.
• Ajouter l'événement qui appellera cette méthode.
  Section """ Événements. """ de ShowMatPlotLib.setup :

          """ Événements. """
          self.listen.timeout.connect(self.listener)
          self.anim.timeout.connect(self.show_anim)
          self.fig.canvas.mpl_connect('key_press_event', self.key_event)
  

• Vérifiez.

---

Retour au plan

• Les nodes de type 'Plots' possèdent un bouton dont le clic appelle la méthode show_figure.
• C'est cette méthode que nous allons modifier, pour l'instant un message est affiché.

---

Voila ce que nous voulons faire :

• Lorsque l'on clique sur le bouton, 2 cas :
  • Le libellé est 'Voir'. Dans ce cas, on lance l'afficheur Matplotlib, le libellé du bouton devient 'Fermer'.
  • Le libellé est 'Fermer'. Dans ce cas, on ferme l'afficheur Matplotlib, je libellé du bouton redevient 'Voir'.
• Lorsque l'on ferme le poste de contrôle, tous les afficheurs ouverts par lui doivent se fermer également, automatiquement.
• Si un afficheur se ferme, manuellement ou pour toute autre raison, le libellé du bouton qui lui correspond devient 'Voir' automatiquement.

---

1. Affichez le poste de contrôle. Pour chaque afficheur, assurez-vous que Paramètres / Fenêtre / Interface est sur Matplotlib.
2. Nous aurons besoin de connaître, en plusieurs endroits du code, les interfaces d'affichage (les scripts Python) présentes dans le projet.
   Par conséquent :
   • Déclarer l'attribut self.scripts dans __init__.
     Ajouter cette ligne dans plots.py > Node.__init__ :

             self.scripts = dict()
     

     
      
   • ... et l'affecter dans le setup.
     plots.py > Node.setup :

         def setup(self, child_file=__file__):
             self.o_grcontent = UiContentPlots(self)
             self.scripts = {
                 'Matplotlib': 'show_matplotlib.py',
                 'Pyqtgraph': 'show_pyqtgraph.py',
                 'Plotly': 'show_plotly.py',
                 'Bokeh': 'show_bokeh.py',
                 'Cufflinks': 'show_cufflinks.py',
                 'Dash': 'show_dash.py',
                 'Guiqwt': 'show_guiqwt.py',
                 'OpenCV': 'show_opencv.py',
                 'Seaborn': 'show_seaborn.py',
             }
             super().setup(child_file)
             self.init_calc()
     

      

3. Les clés de ce dictionnaire sont les noms des différentes interfaces.
   Utilisons-les pour éviter la répétition de code. Modifions la méthode fixed_params.
   plots.py > Node.fixed_params :

       def fixed_params(self):
           """ Valeurs par défaut. """
           return {
               "Nombre d'entrées": [1, {'step': 1, 'limits': (1, 8)}],
               'Fenêtre': {
                   'Titre': 'Titre de la fenêtre',
                   'Interface': ['Matplotlib', {'values': list(self.scripts.keys())}]
               }
           }
   

   
   
    
4. Le PID de l'affichage Matplotlib :
   • Pour améliorer les performances, la plupart des afficheurs seront lancés dans des process différents.
   • Windows étant multi-tâche, nous aurons plusieurs instances de Pyton.exe qui s'exécutent simultanément.
   • Toutefois, pour pouvoir interagir, le poste de contrôle doit connaitre les identifiants de chaque process d'affichage, les PID.
   • Il s'agit de l'attribut self.graph_pid, que l'on doit déclarer dans __init__, et affecter au moment du lancement du process.
     Ajouter cette ligne dans plots.py > Node.__init__ :

             self.graph_pid = None   # PID du process affichant le graphique.
     

5. Surveillance de l'existence de la fenêtre d'affichage, après son lancement.
   • Si le PID ne répond plus, c'est parce que le process est mort (killed), autrement dit, que la fenêtre d'affichage a été fermée.
   • Dans ce cas, le libellé du bouton doit automatiquement revenir à 'Voir'.
   • Cette surveillance se fera dans un timer de période 3 secondes via l'attribut self.clock.
     Ajouter cette ligne dans plots.py > Node.__init__ :

             self.clock = QTimer()
     

     La classe QTimer (de QtCore) doit être importée.
     
     Insérer cette ligne avant self.script = ..., dans plots.py > Node.setup :

             self.clock.timeout.connect(self.detect_graph_closed)
     

   • La méthode appelée par ce timer est self.detect_graph_closed, elle n'existe pas. Créons-la.
     plots.py > Node.detect_graph_closed :

         def detect_graph_closed(self):
             if self.graph_pid is None or not psutil.pid_exists(self.graph_pid):
                 self.o_grcontent.button.setText('Voir')
                 self.clock.stop()
     

     Cette méthode rétablit le libellé du bouton à 'Voir' et arrête la surveillance.
     Installer puis importer psutil.
      

6. La méthode plots.py > Node.show_figure devient :

       def show_figure(self):
           """ Désélection de tous les items de la scène, puis sélection de moi-même. """
           for item in self.o_scene.o_grscene.items():
               item.setSelected(False)
           self.o_grnode.setSelected(True)
   
           ui_fig = self.get_param(['Fenêtre', 'Interface'])
   
           # à coder ...



7. Fermeture du poste de contrôle.
   • Chaque fenêtre d'affichage doit surveiller la présence du poste de contrôle.
   • Lorsque ce dernier ne répond plus, elle doit se fermer.

     # à coder ...

      

---

Vérification

---

Snippets

• Matplotlib

---

Bonjour les codeurs !

---