La façon simple de créer une interface graphique avec Python – Real Python

By | juin 17, 2020

Expert Python

La création d'une interface utilisateur graphique simple (GUI) qui fonctionne sur plusieurs plates-formes peut être compliquée. Mais il ne doit pas nécessairement en être ainsi. Vous pouvez utiliser Python et le package PySimpleGUI pour créer de belles interfaces utilisateur que vous et vos utilisateurs apprécierez! PySimpleGUI est une nouvelle bibliothèque d'interface graphique Python qui a suscité beaucoup d'intérêt récemment.

Dans ce didacticiel, vous apprendrez à:

  • Installer le package PySimpleGUI
  • Créer de base interface utilisateur éléments avec PySimpleGUI
  • Créer des applications, comme un PySimpleGUI Visionneuse d'images
  • Intégrez PySimpleGUI avec Matplotlib
  • Utilisation vision par ordinateur dans PySimpleGUI
  • Emballez votre application PySimpleGUI pour les fenêtres

Il est maintenant temps de commencer!

Débuter avec PySimpleGUI

PySimpleGUI a été lancé en 2018, il s'agit donc d'un package relativement nouveau par rapport à wxPython ou PyQt.

PySimpleGUI possède quatre ports:

  1. Tkinter
  2. PyQt
  3. wxPython
  4. Rémi

PySimpleGUI encapsule des parties de chacun de ces autres packages et les rend plus faciles à utiliser. Cependant, chacun des ports doit être installé séparément.

PySimpleGUI encapsule l'intégralité de Tkinter, fourni avec Python. PySimpleGUI a enveloppé la plupart de PySide2, mais seulement une petite partie de wxPython. Lorsque vous installez PySimpleGUI, vous obtenez le Tkinter variante par défaut. Pour plus d'informations sur Tkinter, consultez Programmation GUI Python avec Tkinter.

Selon la variante de PySimpleGUI que vous utilisez, les applications que vous créez avec PySimpleGUI peuvent ne pas sembler natives sur leur plate-forme. Mais ne laissez pas cela vous empêcher d'essayer PySimpleGUI. PySimpleGUI est toujours assez puissant et peut faire la plupart des choses avec un peu de travail.

Installation de PySimpleGUI

L'installation de PySimpleGUI est facile si vous utilisez pip. Pour les besoins de ce didacticiel, vous apprendrez à installer le port PySimpleGUI standard, qui est la variante Tkinter.

Voici comment procéder:

$ python -m pip install pysimplegui

Cela installera PySimpleGUI sur tout ce que votre système Python est configuré. Vous pouvez également installer PySimpleGUI dans un environnement virtuel Python. Si vous n'êtes pas familier avec les environnements virtuels Python, alors vous devriez lire Python Virtual Environments: A Primer.

Si vous préférez essayer la variante PyQt, vous pouvez utiliser pip install PySimpleGUIQt au lieu. Maintenant que PySimpleGUI est installé, il est temps de découvrir comment l'utiliser!

Création d'éléments d'interface utilisateur de base dans PySimpleGUI

Si vous avez déjà utilisé une boîte à outils GUI auparavant, alors vous avez peut-être entendu le terme widgets. Un widget est un terme générique utilisé pour décrire les éléments qui composent l'interface utilisateur (UI), tels que les boutons, les étiquettes, les fenêtres, etc. Dans PySimpleGUI, les widgets sont appelés éléments, que vous pouvez parfois voir capitalisé ailleurs comme Éléments.

L'un des éléments de base de PySimpleGUI est le Fenêtre(). Créer un Fenêtre(), vous pouvez effectuer les opérations suivantes:

# hello_world.py

importation PySimpleGUI comme sg

sg.Fenêtre(Titre="Bonjour le monde", disposition=[[]], marges=(100, 50)).lis()

Fenêtre() prend beaucoup d'arguments différents, trop nombreux pour être répertoriés ici. Cependant, pour cet exemple, vous pouvez donner la Fenêtre() une Titre et un disposition et définissez le marges, qui est la taille de la fenêtre de l'interface utilisateur en pixels.

lis() renvoie tous les événements qui sont déclenchés dans le Fenêtre() sous forme de chaîne ainsi que valeurs dictionnaire. Vous en apprendrez plus à ce sujet dans les sections ultérieures de ce didacticiel.

Lorsque vous exécutez ce code, vous devriez voir quelque chose comme ceci:

Bonjour tout le monde dans PySimpleGUI

Cet exemple ne fait pas grand-chose d'autre que d'afficher éventuellement un message à l'utilisateur.

Normalement, vous auriez d'autres éléments en plus d'un Fenêtre() dans votre application, ajoutons du texte et un bouton au mélange.

Créez un nouveau fichier nommé hello_psg.py et ajoutez ce code:

# hello_psg.py

importation PySimpleGUI comme sg

disposition = [[[[[[[[sg.Texte("Bonjour de PySimpleGUI")], [[[[sg.Bouton("D'ACCORD")]]

# Créez la fenêtre
fenêtre = sg.Fenêtre("Démo", disposition)

# Créer une boucle d'événement
tandis que Vrai:
    un événement, valeurs = fenêtre.lis()
    # Fin du programme si l'utilisateur ferme la fenêtre ou
    # appuie sur le bouton OK
    si un événement == "D'ACCORD" ou un événement == sg.WIN_CLOSED:
        Pause

fenêtre.Fermer()

La plupart des boîtes à outils GUI vous permettent de disposer les éléments à l'aide positionnement absolu ou en permettant à l'interface graphique de les disposer dynamiquement. Par exemple, wxPython utilise Calibreurs pour disposer les éléments de manière dynamique. Si vous souhaitez en savoir plus sur wxPython, consultez Comment créer une application GUI Python avec wxPython.

PySimpleGUI utilise des listes Python imbriquées pour disposer ses éléments. Dans ce cas, vous ajoutez un Texte() élément et un Bouton() élément. Ensuite, vous créez le fenêtre et passez votre coutume disposition.

Le dernier bloc de code est le boucle d'événement. Une interface utilisateur graphique doit s'exécuter dans une boucle et attendre que l'utilisateur fasse quelque chose. Par exemple, l'utilisateur peut avoir besoin d'appuyer sur un bouton de votre interface utilisateur ou de taper quelque chose avec son clavier. Lorsqu'ils le font, ces événements sont traités par la boucle d'événements.

Lorsque vous utilisez PySimpleGUI, vous créez une boucle d'événement en créant un infini tandis que boucle qui lit les événements du fenêtre objet. Si l'utilisateur appuie sur la touche D'accord ou le bouton Quitter, vous voulez que le programme se termine. Pour ce faire, vous Pause hors de la boucle et Fermer() le fenêtre.

Le code ci-dessus crée une application qui ressemble à ceci:

Bonjour tout le monde dans PySimpleGUI

Vous êtes maintenant prêt à créer une application réelle!

Création d'applications simples

Vous pouvez créer une grande variété d'interfaces graphiques multiplateformes différentes à l'aide de PySimpleGUI. Les démos incluses dans le package sont complètes. Vous pouvez créer n'importe quoi, des widgets de bureau aux interfaces utilisateur complètes.

Dans les sections suivantes, vous verrez différentes façons d'utiliser PySimpleGUI. Cependant, vous pouvez faire bien plus que ce qui peut être couvert dans un seul didacticiel. Si vous voulez plus de détails, assurez-vous de vérifier les autres démos incluses avec PySimpleGUI.

Création d'une visionneuse d'images PySimpleGUI

L'une des démos sur la page GitHub de PySimpleGUI est une visionneuse d'images. Pouvoir écrire votre propre visionneuse d'images personnalisée avec Python est amusant. Vous pouvez utiliser ce code pour afficher vos propres photos ou l'incorporer pour afficher les photos que vous téléchargez ou lisez à partir d'une base de données.

Pour simplifier les choses, vous utiliserez la fonction intégrée de PySimpleGUI Image() élément pour visualiser les images. Malheureusement, le Image() L'élément ne peut afficher que les formats PNG et GIF dans la version régulière de PySimpleGUI.

Si vous souhaitez pouvoir ouvrir d'autres types de fichiers image, vous pouvez télécharger Pillow, qui prend en charge les formats TIFF, JPG et BMP. Consultez le dossier de démonstration PySimpleGUI sur GitHub pour un exemple qui montre comment procéder.

D'un autre côté, si vous installez le port PySimpleGUIQt, vous constaterez que Qt prend en charge plus de formats d'image prêts à l'emploi que Tkinter.

Voici une maquette de ce à quoi devrait ressembler la visionneuse d'images à la fin:

Maquette de visionneuse d'images

Il y aura beaucoup de code pour cet exemple, mais ne vous inquiétez pas. Vous l'examinerez par la suite en petits morceaux.

Vous pouvez créer un fichier nommé img_viewer.py dans l'éditeur Python de votre choix. Ajoutez ensuite le code suivant:

    1 # img_viewer.py
    2 
    3 importation PySimpleGUI comme sg
    4 importation os.path
    5 
    6 # D'abord la disposition des fenêtres en 2 colonnes
    7 
    8 file_list_column = [[[[
    9     [[[[
dix         sg.Texte("Dossier d'images"),
11         sg.Dans(Taille=(25, 1), enable_events=Vrai, clé="-DOSSIER-"),
12         sg.DossierParcourir(),
13     ],
14     [[[[
15         sg.Listbox(
16             valeurs=[], enable_events=Vrai, Taille=(40, 20), clé="-FICHIER LISTE-"
17         )
18     ],
19 ]
20 
21 # Pour l'instant, seul le nom du fichier choisi sera affiché
22 image_viewer_column = [[[[
23     [[[[sg.Texte("Choisissez une image dans la liste de gauche:")],
24     [[[[sg.Texte(Taille=(40, 1), clé="-TOUT-")],
25     [[[[sg.Image(clé="-IMAGE-")],
26 ]
27 
28 # ----- Disposition complète -----
29 disposition = [[[[
30     [[[[
31         sg.Colonne(file_list_column),
32         sg.VSeperator(),
33         sg.Colonne(image_viewer_column),
34     ]
35 ]
36 
37 fenêtre = sg.Fenêtre("Visionneuse d'images", disposition)
38 
39 # Exécutez la boucle d'événement
40 tandis que Vrai:
41     un événement, valeurs = fenêtre.lis()
42     si un événement == "Sortie" ou un événement == sg.WIN_CLOSED:
43         Pause
44     # Le nom du dossier a été rempli, faites une liste des fichiers dans le dossier
45     si un événement == "-DOSSIER-":
46         dossier = valeurs[[[["-DOSSIER-"]
47         essayer:
48             # Récupère la liste des fichiers dans le dossier
49             file_list = os.listdir(dossier)
50         sauf:
51             file_list = []
52 
53         noms = [[[[
54             F
55             pour F dans file_list
56             si os.chemin.isfile(os.chemin.joindre(dossier, F))
57             et F.inférieur().se termine par((".png", ".gif"))
58         ]
59         fenêtre[[[["-FICHIER LISTE-"].mise à jour(noms)
60     elif un événement == "-FICHIER LISTE-":  # Un fichier a été choisi dans la liste
61         essayer:
62             nom de fichier = os.chemin.joindre(
63                 valeurs[[[["-DOSSIER-"], valeurs[[[["-FICHIER LISTE-"][[[[0]
64             )
65             fenêtre[[[["-TOUT-"].mise à jour(nom de fichier)
66             fenêtre[[[["-IMAGE-"].mise à jour(nom de fichier=nom de fichier)
67 
68         sauf:
69             passer
70 
71 fenêtre.Fermer()

Phew! C’est pas mal de lignes de code! Passons en revue morceau par morceau.

Voici les premières lignes:

    1 # img_viewer.py
    2 
    3 importation PySimpleGUI comme sg
    4 importation os.path
    5 
    6 # D'abord la disposition des fenêtres en 2 colonnes
    7 
    8 file_list_column = [[[[
    9     [[[[
dix         sg.Texte("Dossier d'images"),
11         sg.Dans(Taille=(25, 1), enable_events=Vrai, clé="-DOSSIER-"),
12         sg.DossierParcourir(),
13     ],
14     [[[[
15         sg.Listbox(
16             valeurs=[], enable_events=Vrai, Taille=(40, 20), clé="-FICHIER LISTE-"
17         )
18     ],
19 ]

Ici, sur lignes 3 et 4, vous importez PySimpleGUI et Python os module. Puis, le lignes 8 à 19, vous créez une liste imbriquée d'éléments qui représentent une colonne verticale de l'interface utilisateur. Cela créera un bouton Parcourir que vous utiliserez pour trouver un dossier contenant des images.

le clé paramètre est important. C'est ce que vous utilisez pour identifier un élément spécifique de votre interface graphique. Pour le Dans() contrôle du texte d'entrée, vous lui donnez une identité de "-DOSSIER-". Vous l'utiliserez plus tard pour accéder au contenu de l'élément. Vous pouvez activer ou désactiver des événements pour chaque élément via le enable_events paramètre.

le Listbox () L'élément affichera une liste de chemins d'accès aux images que vous pouvez ensuite choisir d'afficher. Vous pouvez pré-remplir le Listbox () avec des valeurs en passant une liste de chaînes.

Lorsque vous chargez votre interface utilisateur pour la première fois, vous Listbox () être vide, vous passez donc une liste vide. Vous activez les événements pour cet élément, définissez son Tailleet donnez-lui un identifiant unique comme vous l'avez fait avec l'élément d'entrée.

Vous pouvez maintenant regarder la colonne d'éléments de droite:

21 # Pour l'instant, seul le nom du fichier choisi sera affiché
22 image_viewer_column = [[[[
23     [[[[sg.Texte("Choisissez une image dans la liste de gauche:")],
24     [[[[sg.Texte(Taille=(40, 1), clé="-TOUT-")],
25     [[[[sg.Image(clé="-IMAGE-")],
26 ]

La liste des listes sur lignes 22 à 26 crée trois éléments. Le premier élément indique à l'utilisateur qu'il doit choisir une image à afficher. Le deuxième élément affiche le nom du fichier sélectionné. Le troisième affiche le Image().

Notez que le Image() l'élément a également un clé définir de sorte que vous pouvez facilement vous référer à l'élément plus tard. Pour plus d'informations sur le Image() élément, consultez la documentation.

Le morceau de code suivant définit votre mise en page:

28 # ----- Disposition complète -----
29 disposition = [[[[
30     [[[[
31         sg.Colonne(file_list_column),
32         sg.VSeperator(),
33         sg.Colonne(image_viewer_column),
34     ]
35 ]

La dernière liste, sur lignes 29 à 35, contient le code qui contrôle la disposition des éléments à l'écran. Ce code contient deux Colonne() éléments avec un VSeperator () entre eux. Vous pouvez en savoir plus sur le fonctionnement de Column () et VSeperator () en lisant leurs pages de documentation respectives.

Pour ajouter le disposition à ton fenêtre, tu peux le faire:

37 fenêtre = sg.Fenêtre("Visionneuse d'images", disposition)

Maintenant que vous avez compris l'interface utilisateur, vous pouvez regarder le code de boucle d'événement. Voici la première pièce:

39 tandis que Vrai:
40     un événement, valeurs = fenêtre.lis()
41     si un événement == "Sortie" ou un événement == sg.WIN_CLOSED:
42         Pause

La boucle d'événements contient le logique de votre programme. Ici, vous extrayez les événements et valeurs du fenêtre. le un événement sera le clé chaîne de l'élément avec lequel l'utilisateur interagit. le valeurs La variable contient un dictionnaire Python qui mappe l'élément clé à une valeur. Par exemple, si l'utilisateur choisit un dossier, alors "-DOSSIER-" correspondra au chemin du dossier.

Les instructions conditionnelles sont utilisées pour contrôler ce qui se passe. Si la un événement équivaut à "Sortie" ou l'utilisateur ferme le fenêtre, alors vous sortez de la boucle.

Vous pouvez maintenant jeter un œil à la première partie de la prochaine instruction conditionnelle dans la boucle:

44 # Le nom du dossier a été rempli, faites une liste des fichiers dans le dossier
45 si un événement == "-DOSSIER-":
46     dossier = valeurs[[[["-DOSSIER-"]
47     essayer:
48         # Récupère la liste des fichiers dans le dossier
49         file_list = os.listdir(dossier)
50     sauf:
51         file_list = []
52 
53     noms = [[[[
54         F
55         pour F dans file_list
56         si os.chemin.isfile(os.chemin.joindre(dossier, F))
57         et F.inférieur().se termine par((".png", ".gif"))
58     ]
59     fenêtre[[[["-FICHIER LISTE-"].mise à jour(noms)

Cette fois, vous vérifiez la un événement contre la "-DOSSIER-" clé, qui fait référence à la Dans() élément que vous avez créé précédemment. Si l'événement existe, vous savez que l'utilisateur a choisi un dossier et vous utilisez os.listdir () pour obtenir une liste de fichiers. Ensuite, vous filtrez cette liste uniquement pour les fichiers avec l'extension ".png" ou ".gif".

Vous pouvez maintenant jeter un œil à la partie suivante de l'instruction conditionnelle:

60 elif un événement == "-FICHIER LISTE-":  # Un fichier a été choisi dans la liste
61     essayer:
62         nom de fichier = os.chemin.joindre(
63             valeurs[[[["-DOSSIER-"], valeurs[[[["-FICHIER LISTE-"][[[[0]
64         )
65         fenêtre[[[["-TOUT-"].mise à jour(nom de fichier)
66         fenêtre[[[["-IMAGE-"].mise à jour(nom de fichier=nom de fichier)
67     sauf:
68         passer

Si la un événement équivaut à "-FICHIER LISTE-", vous savez que l'utilisateur a choisi un fichier dans le Listbox ()et vous souhaitez mettre à jour le Image() élément ainsi que Texte() élément qui montre le sélectionné nom de fichier sur la droite.

Le dernier morceau de code est la façon dont vous terminez le programme:

Lorsque l'utilisateur appuie sur le bouton Quitter, l'application doit se fermer. Pour ce faire, vous pouvez utiliser window.close ().

Vous pouvez techniquement laisser cette ligne hors de votre code et Python terminera toujours le programme, mais c'est toujours une bonne idée de nettoyer après vous-même. De plus, si vous utilisez le port Web de PySimpleGUI et que vous ne fermez pas la fenêtre correctement, vous finirez par laisser un port ouvert.

Maintenant, exécutez le code et vous devriez voir une interface comme celle-ci:

Visionneuse d'images PySimpleGUI

Vous pouvez utiliser le bouton Parcourir pour rechercher un dossier sur votre ordinateur contenant des images afin de pouvoir essayer ce code. Ou vous pouvez copier et coller un chemin d'accès à un fichier dans le Texte() élément.

Une fois que vous avez terminé de visualiser vos images, vous êtes prêt à apprendre à utiliser Matplotlib avec PySimpleGUI.

Intégration de Matplotlib avec PySimpleGUI

La création de graphiques est un excellent moyen de partager des informations avec vos collègues. Matplotlib est l'un des packages graphiques les plus populaires pour Python. Matplotlib peut créer toutes sortes de graphiques différents. Si vous souhaitez en savoir plus, consultez Python Plotting With Matplotlib (Guide).

Matplotlib peut être intégré à PySimpleGUI, vous pouvez donc ajouter des graphiques à votre interface graphique assez facilement si vous savez déjà comment utiliser Matplotlib.

Si vous n’avez pas installé Matplotlib, vous pouvez le faire en utilisant pépin:

$ python -m pip install matplotlib

Pour cet exemple, vous utilisez l'une des démos de PySimpleGUI. Matplotlib utilise NumPy, vous voudrez donc également l'installer:

$ python -m pip install numpy

Maintenant que vous avez toutes les pièces nécessaires pour écrire le code, vous pouvez créer un nouveau fichier et le nommer psg_matplotlib.py.

Le code de démonstration est un peu long, vous ajoutez donc le code en plusieurs parties commençant par ceci:

importation engourdi comme np
de matplotlib.backends.backend_tkagg importation FigureCanvasTkAgg
importation PySimpleGUI comme sg
importation matplotlib

figure = matplotlib.figure.Figure(figsize=(5, 4), dpi=100)
t = np.arange(0, 3, .01)
figure.add_subplot(111).terrain(t, 2 * np.péché(2 * np.pi * t))

Ce sont les importations dont vous aurez besoin pour faire fonctionner votre code. Ce code configure également le Matplotlib Figure() et ajoute un tracé en utilisant add_subplot (). Pour plus de détails, vous pouvez vous référer à la documentation. Le port PySimpleGUIQt ne fonctionne pas de la même manière actuellement, mais cela est en cours d'élaboration pour une future version.

Dans PySimpleGUI et Tkinter, vous utilisez le Toile() élément pour le dessin. Vous pouvez en savoir plus sur cet élément dans la documentation.

Vous pouvez maintenant créer une fonction d'aide pour dessiner la figure sur PySimpleGUI Toile(). UNE fonction d'aide est un code répétitif que vous ne souhaitez pas écrire plusieurs fois. Regarde:

matplotlib.utilisation("TkAgg")

def draw_figure(Toile, figure):
    figure_canvas_agg = FigureCanvasTkAgg(figure, Toile)
    figure_canvas_agg.dessiner()
    figure_canvas_agg.get_tk_widget().pack(côté="Haut", remplir="tous les deux", développer=1)
    revenir figure_canvas_agg

Vous utiliserez figure_canvas_agg.draw () pour dessiner les parcelles à PySimpleGUI Toile() élément.

Pour utiliser PySimpleGUI Toile(), vous devez le transmettre à FigureCanvasTkAgg () avec le Matplotlib figure objet. FigureCanvasTkAgg () vient de Matplotlib et est utilisé par Tkinter pour intégrer les tracés dans PySimpleGUI. Cela fonctionnerait différemment si vous utilisiez PySimpleGUIQt.

La dernière étape consiste à écrire l'interface utilisateur avec PySimpleGUI:

# Définir la disposition des fenêtres
disposition = [[[[
    [[[[sg.Texte("Test de tracé")],
    [[[[sg.Toile(clé="-TOILE-")],
    [[[[sg.Bouton("D'accord")],
]

# Créez le formulaire et affichez-le sans l'intrigue
fenêtre = sg.Fenêtre(
    "Matplotlib Single Graph",
    disposition,
    emplacement=(0, 0),
    finaliser=Vrai,
    element_justification="centre",
    Police de caractère="Helvetica 18",
)

# Ajoutez le tracé à la fenêtre
draw_figure(fenêtre[[[["-TOILE-"].TKCanvas, figure)

un événement, valeurs = fenêtre.lis()

fenêtre.Fermer()

Pour créer l'interface utilisateur, tout ce dont vous avez besoin est un Texte() élément, un Toile() élément, et un Bouton() élément. Ensuite, vous ajoutez tous ces éléments à un Fenêtre() et appelez votre draw_figure () fonction d'aide pour dessiner l'intrigue.

Vous n'avez pas besoin de la boucle d'événements ici, car vous n'interagirez pas avec les éléments de cette interface utilisateur.

Voici à quoi ressemblera le graphique:

PySimpleGUI avec graphique Matplotlib

Il y a d'autres démos Matplotlib incluses avec PySimpleGUI que vous devriez vérifier.

Vous pouvez maintenant apprendre à utiliser OpenCV avec PySimpleGUI.

Intégration d'OpenCV avec PySimpleGUI

La vision par ordinateur est un sujet brûlant en ce moment. Python vous permet d'entrer dans la vision par ordinateur en utilisant le paquet opencv-python, qui est un wrapper autour du populaire OpenCV application. Si vous souhaitez en savoir plus sur la vision par ordinateur, consultez la reconnaissance des visages avec Python, dans Under 25 Lines of Code.

PySimpleGUI propose une intégration simple avec la bibliothèque OpenCV. Cependant, vous devez d’abord installer OpenCV à l’aide de pépin:

$ python -m pip install opencv-python

Maintenant que OpenCV est installé, vous pouvez écrire une application amusante!

Vous verrez une autre démonstration de PySimpleGUI qui utilise OpenCV et la webcam de votre ordinateur. Cette application vous permettra d'appliquer des filtres communs à votre vidéo en temps réel.

Le code de cet exemple est long, mais ne vous inquiétez pas. Il sera expliqué par la suite en petits morceaux. Allez-y et créez un fichier nommé psg_opencv.py et ajoutez le code suivant:

        1 importation PySimpleGUI comme sg
        2 importation cv2
        3 importation engourdi comme np
        4 
        5 def principale():
        6     sg.thème("Vert clair")
        7 
        8     # Définir la disposition des fenêtres
        9     disposition = [[[[
    dix         [[[[sg.Texte("Démo OpenCV", Taille=(60, 1), justification="centre")],
    11         [[[[sg.Image(nom de fichier="", clé="-IMAGE-")],
    12         [[[[sg.Radio("Aucun", "Radio", Vrai, Taille=(dix, 1))],
    13         [[[[
    14             sg.Radio("seuil", "Radio", Taille=(dix, 1), clé="-BATTRE-"),
    15             sg.Glissière(
    16                 (0, 255),
    17                 128,
    18                 1,
    19                 orientation="h",
    20                 Taille=(40, 15),
    21                 clé="-THRESH SLIDER-",
    22             ),
    23         ],
    24         [[[[
    25             sg.Radio("prudent", "Radio", Taille=(dix, 1), clé="-PRUDENT-"),
    26             sg.Glissière(
    27                 (0, 255),
    28                 128,
    29                 1,
    30                 orientation="h",
    31                 Taille=(20, 15),
    32                 clé="-CANNY SLIDER A-",
    33             ),
    34             sg.Glissière(
    35                 (0, 255),
    36                 128,
    37                 1,
    38                 orientation="h",
    39                 Taille=(20, 15),
    40                 clé="-CANNY SLIDER B-",
    41             ),
    42         ],
    43         [[[[
    44             sg.Radio("brouiller", "Radio", Taille=(dix, 1), clé="-BROUILLER-"),
    45             sg.Glissière(
    46                 (1, 11),
    47                 1,
    48                 1,
    49                 orientation="h",
    50                 Taille=(40, 15),
    51                 clé="-BLUR SLIDER-",
    52             ),
    53         ],
    54         [[[[
    55             sg.Radio("teinte", "Radio", Taille=(dix, 1), clé="-TEINTE-"),
    56             sg.Glissière(
    57                 (0, 225),
    58                 0,
    59                 1,
    60                 orientation="h",
    61                 Taille=(40, 15),
    62                 clé="-HUE SLIDER-",
    63             ),
    64         ],
    65         [[[[
    66             sg.Radio("améliorer", "Radio", Taille=(dix, 1), clé="-AMÉLIORER-"),
    67             sg.Glissière(
    68                 (1, 255),
    69                 128,
    70                 1,
    71                 orientation="h",
    72                 Taille=(40, 15),
    73                 clé="-ENHANCE SLIDER-",
    74             ),
    75         ],
    76         [[[[sg.Bouton("Sortie", Taille=(dix, 1))],
    77     ]
    78 
    79     # Créez la fenêtre et affichez-la sans l'intrigue
    80     fenêtre = sg.Fenêtre("Intégration OpenCV", disposition, emplacement=(800, 400))
    81 
    82     casquette = cv2.Capture vidéo(0)
    83 
    84     tandis que Vrai:
    85         un événement, valeurs = fenêtre.lis(temps libre=20)
    86         si un événement == "Sortie" ou un événement == sg.WIN_CLOSED:
    87             Pause
    88 
    89         ret, Cadre = casquette.lis()
    90 
    91         si valeurs[[[["-BATTRE-"]:
    92             Cadre = cv2.cvtColor(Cadre, cv2.COLOR_BGR2LAB)[:[:[:[: :, 0]
    93             Cadre = cv2.seuil(
    94                 Cadre, valeurs[[[["-THRESH SLIDER-"], 255, cv2.THRESH_BINARY
    95             )[[[[1]
    96         elif valeurs[[[["-PRUDENT-"]:
    97             Cadre = cv2.Prudent(
    98                 Cadre, valeurs[[[["-CANNY SLIDER A-"], valeurs[[[["-CANNY SLIDER B-"]
    99             )
100         elif valeurs[[[["-BROUILLER-"]:
101             Cadre = cv2.Flou gaussien(Cadre, (21, 21), valeurs[[[["-BLUR SLIDER-"])
102         elif valeurs[[[["-TEINTE-"]:
103             Cadre = cv2.cvtColor(Cadre, cv2.COLOR_BGR2HSV)
104             Cadre[:[:[:[: :, 0] + = int(valeurs[[[["-HUE SLIDER-"])
105             Cadre = cv2.cvtColor(Cadre, cv2.COLOR_HSV2BGR)
106         elif valeurs[[[["-AMÉLIORER-"]:
107             enh_val = valeurs[[[["-ENHANCE SLIDER-"] / 40
108             clahe = cv2.createCLAHE(clipLimit=enh_val, tileGridSize=(8, 8))
109             laboratoire = cv2.cvtColor(Cadre, cv2.COLOR_BGR2LAB)
110             laboratoire[:[:[:[: :, 0] = clahe.appliquer(laboratoire[:[:[:[: :, 0])
111             Cadre = cv2.cvtColor(laboratoire, cv2.COLOR_LAB2BGR)
112 
113         imgbytes = cv2.imencode(".png", Cadre)[[[[1].octets()
114         fenêtre[[[["-IMAGE-"].mise à jour(Les données=imgbytes)
115 
116     fenêtre.Fermer()
117 
118 principale()

C'est un long morceau de code! Passons en revue l'exemple une pièce à la fois:

    1 importation PySimpleGUI comme sg
    2 importation cv2
    3 importation engourdi comme np
    4 
    5 def principale():
    6     sg.thème("Vert clair")
    7 
    8     # Définir la disposition des fenêtres
    9     disposition = [[[[
dix         [[[[sg.Texte("Démo OpenCV", Taille=(60, 1), justification="centre")],
11         [[[[sg.Image(nom de fichier="", clé="-IMAGE-")],
12         [[[[sg.Radio("Aucun", "Radio", Vrai, Taille=(dix, 1))],
13         [[[[
14             sg.Radio("seuil", "Radio", Taille=(dix, 1), clé="-BATTRE-"),
15             sg.Glissière(
16                 (0, 255),
17                 128,
18                 1,
19                 orientation="h",
20                 Taille=(40, 15),
21                 clé="-THRESH SLIDER-",
22             ),
23         ],

Lignes 1 à 3 sont les importations pour les bibliothèques Python dont vous aurez besoin. Ensuite, vous définissez le thème sur ligne 6.

La prochaine étape, en commençant par ligne 9, est de créer un disposition pour tous les éléments de l'interface graphique. Le premier ensemble d'éléments comprend un Texte() élément, un Image() élément, et un Radio() élément. Vous définissez la clé d'identification pour le Image élément à "-IMAGE-". Vous imbriquez également un Radio() élément et un Glissière() et définissez leurs clés d'identification sur "-BATTRE-" et "-THRESH SLIDER-", respectivement.

Vous allez maintenant ajouter quelques éléments supplémentaires au disposition:

24 [[[[
25     sg.Radio("prudent", "Radio", Taille=(dix, 1), clé="-PRUDENT-"),
26     sg.Glissière(
27         (0, 255),
28         128,
29         1,
30         orientation="h",
31         Taille=(20, 15),
32         clé="-CANNY SLIDER A-",
33     ),
34     sg.Glissière(
35         (0, 255),
36         128,
37         1,
38         orientation="h",
39         Taille=(20, 15),
40         clé="-CANNY SLIDER B-",
41     ),
42 ],

Sur lignes 24 à 42, vous en ajoutez un autre Radio() élément et deux Glissière() des éléments pour contrôler la détection des bords avec l’interface utilisateur. Vous définissez également les identifiants de manière appropriée.

Vous allez maintenant ajouter un moyen de flouter les images:

43 [[[[
44     sg.Radio("brouiller", "Radio", Taille=(dix, 1), clé="-BROUILLER-"),
45     sg.Glissière(
46         (1, 11),
47         1,
48         1,
49         orientation="h",
50         Taille=(40, 15),
51         clé="-BLUR SLIDER-",
52     ),
53 ],

Ici, il vous suffit d'ajouter quelques éléments à contrôler flou de l'image, également connu sous le nom de lissage d'image. Vous pouvez en savoir plus sur cette technique dans la documentation OpenCV.

Vous n'avez que deux autres ensembles de contrôles à ajouter. Vous allez ensuite ajouter les contrôles de teinte:

54 [[[[
55     sg.Radio("teinte", "Radio", Taille=(dix, 1), clé="-TEINTE-"),
56     sg.Glissière(
57         (0, 225),
58         0,
59         1,
60         orientation="h",
61         Taille=(40, 15),
62         clé="-HUE SLIDER-",
63     ),
64 ],

Ces éléments vous permettent de convertir entre différents espaces colorimétriques. Les espaces colorimétriques n'entrent pas dans le cadre de ce didacticiel, mais vous pouvez en savoir plus à leur sujet dans le didacticiel Changer les espaces colorimétriques sur le site Web d'OpenCV.

Les derniers éléments à ajouter sont pour contrôler le contraste:

65     [[[[
66         sg.Radio("améliorer", "Radio", Taille=(dix, 1), clé="-AMÉLIORER-"),
67         sg.Glissière(
68             (1, 255),
69             128,
70             1,
71             orientation="h",
72             Taille=(40, 15),
73             clé="-ENHANCE SLIDER-",
74         ),
75     ],
76     [[[[sg.Bouton("Sortie", Taille=(dix, 1))],
77 ]
78 
79 # Créez la fenêtre et affichez-la sans l'intrigue
80 fenêtre = sg.Fenêtre("Intégration OpenCV", disposition, emplacement=(800, 400))
81 
82 casquette = cv2.Capture vidéo(0)

Ces derniers éléments vous permettront d'améliorer le contraste du flux vidéo à l'aide de l'algorithme d'égalisation d'histogramme adaptatif à contraste limité.

Ceci termine la disposition. Ensuite, vous passez votre disposition à la Fenêtre() afin que vous puissiez voir votre interface utilisateur à l'écran.

Enfin, vous utilisez cv2.VideoCapture (0) pour accéder à la webcam sur votre machine. Une fenêtre contextuelle peut vous demander l'autorisation d'utiliser votre appareil photo. Si vous le faites, vous devrez accorder une autorisation, sinon ce code ne fonctionnera pas.

Jetez maintenant un œil au reste du code:

    84     tandis que Vrai:
    85         un événement, valeurs = fenêtre.lis(temps libre=20)
    86         si un événement == "Sortie" ou un événement == sg.WIN_CLOSED:
    87             Pause
    88 
    89         ret, Cadre = casquette.lis()
    90 
    91         si valeurs[[[["-BATTRE-"]:
    92             Cadre = cv2.cvtColor(Cadre, cv2.COLOR_BGR2LAB)[:[:[:[: :, 0]
    93             Cadre = cv2.threshold(
    94                 Cadre, values[[[["-THRESH SLIDER-"], 255, cv2.THRESH_BINARY
    95             )[[[[1]
    96         elif values[[[["-CANNY-"]:
    97             Cadre = cv2.Canny(
    98                 Cadre, values[[[["-CANNY SLIDER A-"], values[[[["-CANNY SLIDER B-"]
    99             )
100         elif values[[[["-BLUR-"]:
101             Cadre = cv2.GaussianBlur(Cadre, (21, 21), values[[[["-BLUR SLIDER-"])
102         elif values[[[["-HUE-"]:
103             Cadre = cv2.cvtColor(Cadre, cv2.COLOR_BGR2HSV)
104             Cadre[:[:[:[: :, 0] += int(values[[[["-HUE SLIDER-"])
105             Cadre = cv2.cvtColor(Cadre, cv2.COLOR_HSV2BGR)
106         elif values[[[["-ENHANCE-"]:
107             enh_val = values[[[["-ENHANCE SLIDER-"] / 40
108             clahe = cv2.createCLAHE(clipLimit=enh_val, tileGridSize=(8, 8))
109             lab = cv2.cvtColor(Cadre, cv2.COLOR_BGR2LAB)
110             lab[:[:[:[: :, 0] = clahe.apply(lab[:[:[:[: :, 0])
111             Cadre = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
112 
113         imgbytes = cv2.imencode(".png", Cadre)[[[[1].tobytes()
114         window[[[["-IMAGE-"].update(Les données=imgbytes)
115 
116     window.Fermer()
117 
118 main()

This is the event loop for your PySimpleGUI interface. When you change a slider in your UI, PySimpleGUI will grab the un événement et values and use them to determine which OpenCV function to apply to your webcam stream.

This code is a bit different from the others you’ve seen because it’s encapsulated within a main() une fonction. This type of function is used as the main entry point of the program. To learn more on this topic, check out Defining Main Functions in Python.

Here’s an example of what the GUI will look like:

PySimpleGUI with OpenCV Webcam

Now it’s time learn how to create an executable of your application for Windows.

Packaging Your PySimpleGUI Application for Windows

There are many different Python packages that you can use to convert your Python code into an executable for Windows. One of the most popular is PyInstaller.

You can install PyInstaller using pip:

$ python -m pip install pyinstaller

To learn more about how to use PyInstaller, check out Using PyInstaller to Easily Distribute Python Applications.

You’ll use PyInstaller to convert the image viewer application that you created earlier into an executable.

$ pyinstaller img_viewer.py

When you run this command, you’ll see a lot of output similar to the following:

177 INFO: PyInstaller: 3.6
178 INFO: Python: 3.8.2
179 INFO: Platform: Windows-10-10.0.10586-SP0
186 INFO: wrote C:UsersmikeOneDriveDocumentsimage_viewer_psg.spec
192 INFO: UPX is not available.
221 INFO: Extending PYTHONPATH with paths
---- output snipped ----
13476 INFO: Building COLLECT because COLLECT-00.toc is non existent
13479 INFO: Building COLLECT COLLECT-00.toc
25851 INFO: Building COLLECT COLLECT-00.toc completed successfully.

This output is abbreviated since PyInstaller is quite verbose. When it’s done, you’ll have a subfolder named dist in the same folder that contains img_viewer.py. You can go into the dist folder to find img_viewer.exe and try running it.

There will be a lot of other files in the dist folder that the executable uses.

If you prefer to have only a single executable file, then you can rerun the command using the --onefile flag:

$ pyinstaller --onefile img_viewer.py

This will still generate the dist folder, but this time there should be a single executable in it.

When you run the executable, you’ll see a console window appear in addition to your user interface. To remove the console, you can use the --noconsole ou la --windowed flag when running PyInstaller.

Conclusion

You learned a lot about the PySimpleGUI package in this tutorial! Above all, you became familiar with the basics of using PySimpleGUI to create applications.

In this tutorial, you learned how to:

  • Installer the PySimpleGUI package
  • Create basic user interface elements with PySimpleGUI
  • Create some applications, such as an image viewer, with PySimpleGUI
  • Integrate PySimpleGUI with Matplotlib
  • Utilisation computer vision in PySimpleGUI
  • Package your PySimpleGUI application for les fenêtres

You can use what you learned in this tutorial to create your own interesting and useful applications.

The PySimpleGUI package offers many more example demos that you can use to build your skills and discover how to use all the tools in the library more effectively. Be sure to check them out, and you’ll soon find yourself creating your own cross-platform GUI applications

If you’d like to learn more about PySimpleGUI, then you can check out any of the following resources: