Le poste de contrôle (PC) / Les paramètres /
La scène et la vue : réticule

Affichage des nodes et des edges sur un écran réticulé

Avant-propos

Vous pouvez lancer ces exemples directement depuis Pycharm > External Libraries\Python\site-packages\pyqtgraph\examples\__main__.py
Mettre à jour impérativement : Nouvelle version de la méthode utils.py > DateTime.delay()
Elle a moins de code, mais est plus puissante.
    def delay(self, client_function, delay=20, *args, **kwargs):
        """ Asynchrone (ne prend pas la main).
        :param client_function: Cette fonction sera exécutée après un délai.
        :param delay: Délai en ms (20ms par défaut).
        :param args: Optionnel. Arguments dans l'appel de la fonction (tuple ou liste).
        :param kwargs: Optionnel. Arguments dans l'appel de la fonction (dictionnaire).
        :return: NA
        """
        key = client_function.__name__
        if key in self.d_tempo:
            if self.d_tempo[key].isActive():
                self.d_tempo[key].disconnect()
        else:
            self.d_tempo[key] = QTimer()
            self.d_tempo[key].setSingleShot(True)

        self.d_tempo[key].timeout.connect(lambda: client_function(*args, **kwargs))

        self.d_tempo[key].start(delay)

 

Description

Copier-coller, dans l'ordre :
  1. Création de la classe UiScene dans le fichier /pc/ui_scene.py  
    from PyQt5.QtWidgets import QGraphicsScene
import pyqtgraph as pg
from PyQt5.QtCore import QLine


class UiScene(QGraphicsScene):
    def __init__(self, o_scene):
        super().__init__(parent=o_scene)
        self.o_scene = o_scene
        self.init_ui()

    def init_ui(self):
        self.setSceneRect(-32000, -32000, 64000, 64000)     # x, y, w, h
        self.setBackgroundBrush(pg.mkColor('#393939'))

    def drawBackground(self, painter, rect):        # https://doc.qt.io/qt-5/qgraphicsscene.html#drawBackground
        super().drawBackground(painter, rect)
        print('Draw background')    # Provisoire, à supprimer.

        # Dessin provisoire de 2 traits.
        painter.setPen(pg.mkPen('#fff', width=.5))      # Couleur 'blanc', épaisseur 0.5
        painter.drawLine(QLine(-10_000, 0, 10_000, 0))  # Trait horizontal de 20 000 points, passant par le centre.
        painter.drawLine(QLine(0, -10_000, 0, 10_000))  # Trait vertical de 20 000 points, passant par le centre.

     

  2. Création de la classe UiView dans le fichier /pc/ui_view.py  
    from PyQt5.QtWidgets import QGraphicsView


class UiView(QGraphicsView):
    def __init__(self, o_scene):
        super().__init__()
        self.o_scene = o_scene

     

  3. Création de la classe CtrlScene dans le fichier /pc/ctrl_scene.py  
    from PyQt5.QtWidgets import QWidget, QVBoxLayout
from ui_scene import UiScene
from ui_view import UiView


class CtrlScene(QWidget):
    """ Contrôleur de la scène et de la vue. """
    def __init__(self, dir_name):
        super().__init__()
        self.graph_name = dir_name  # On donne au graphe le nom de son dossier.
        self.o_gr_scene = None      # Instance d'un GraphicsScene dérivé : UiScene.
        self.o_gr_view = None       # Instance d'un GraphicsView dérivé : UiView.
        self.setup()

    def setup(self):
        """ Création de la scène. """
        self.o_gr_scene = UiScene(self)             # pyqtgraph.GraphicsScene.GraphicsScene dérivée.
        """ Création de l'unique vue. """
        self.o_gr_view = UiView(self)               # pyqtgraph.GraphicsView dérivée.
        """ Affectaion de la scène à visionner. """
        self.o_gr_view.setScene(self.o_gr_scene)    # Unique vue de la scène (il pourrait y en avoir plusieurs).

        """ 'Boîte' container verticale - elle pourrait être horizontale car elle ne contient qu'un élément. """
        box = QVBoxLayout()  # Son but est d'étirer la vue sur toute sa surface.
        """ On place la vue dans cette boîte. """
        box.addWidget(self.o_gr_view)
        box.setContentsMargins(0, 0, 0, 0)   # Suppression des marges (10px par défaut)
        """ Enfin, on place cette boîte dans l'onglet. """
        self.setLayout(box)

     

  4. Finalement, on revient à main.py > UiMain.open_graph() pour rechercher le "Todo : Coder la classe Scene"
    Sans oublier d'importer la classe CtrlScene, de retirer le Todo et de supprimer le commentaire.
    • Remplacer o_scene = QWidget() par o_scene = CtrlScene(graph_name)  
              # o_scene = QWidget()  # Objet provisoire. Instance de la scène qui sera affichée dans l'onglet.
        o_scene = CtrlScene(graph_name)
  5. Tester en lançant la fenêtre Main.

  6. Vous devriez voir 2 traits blancs sur un fond sombre (#393939).
    • S'ils sont hors de vue, cherchez-les en jouant sur les ascenseurs (sliders H et V ou molette-souris).
    • Leur croisement est à l'origine (0, 0).
    • La scene va de -32 000 à +32 000 en horizontal et en vertical.
    • Sans le zoom (c'est à dire avec un zoom de 1), un point de la scène correspond à 1 pixel.
    • La vue est cette petite fenêtre, limitée par sa taille.
    • Pour voir toute la scène, il vous faudrait un moniteur carré de 20 m de côté (sans zoom) !
A faire - Ajoutez (ou modifiez) du code pour :

Vérification

Pas de TDD, mais un simple contrôle visuel :

Snippets

Essayez de résoudre cette fonctionnalité par vous-même.
Consultez les réponses (snippets) seulement si vous n'avez pas trop de temps.

Bonjour les codeurs !

Messages & questions
Commentaires & questions

Laissez vos commentaires et vos questions sur Youtube !