Dessiner sous Python

Salut, je suis a me faire un petit programme pour mon Raspberry et mon PC.

Je désire remplacer mon application sous Windows « Rainmeter » par un affichage que mon Raspberry Pi Zero va devoir gérer.

Je cherche donc à dessiner certains éléments graphique. J’ai commencé à regarder avec « Turtle », qui me semblais prometteur au début, mais c’est une vraie m***e.

La qualité des images a importé est affreuse, du GIF, ce qui limite la palette de couleur. Je n’arrive également pas a placer certains éléments qui me semble pourtant primordiale, comme la taille de l’écran et la position de la tortue.

Actuellement, je code et exécute sous Windows. Je demande un écran de 320x240, selon « screensize() », j’ai cette dimension, mais dans les faits, j’ai de quoi proche de 2000x2000 (je suis en résolution 4K). De plus, je crois devoir vivre avec un « titlebar », ce qui ne m’arrange pas du tout.

J’ai déjà eu a travailler avec Logo Writer, qui est basé exactement sur le principe de la tortue. Mais clairement, cette version est truffé de bugs, les coordonnés semble erronés, la plupart des paramètre sont ignorés et le mouvement de la tortue n’est pas précis, les direction je lui donne ne donne pas le résultat attendu. Par exemple un déplacement de 80x40 donne plus de hauteur que de largeur, pas logique du tout.

J’ai besoin de pouvoir dessiner, ajouter des images et écrire et faire un refresh a toutes les secondes (voir plus vite). La tortue me semble donc trop lente pour ce résultat. J’ai aucun talent en infographie, alors pour moi il est plus facile de programmer mon dessin que de le faire.

Dans mon projet je veux créer des Gauges (3 couleurs; rouge, jaune, vert) avec une flèche, des barres de niveaux et des informations en texte.

Je cherche a reproduire ceci (sans l’historique à droite et les VU Meter en bas)

1024x600 via un HDMI, affichage dédié de mon PC généré par RainMeter, Skin perso

Alors en résumé, je cherche une librairie simple ou mes coordonnés seront en pixel, débutant de 0,0 pouvant limiter l’écran à celui de mon Raspberry. Pouvant offrir des outils de dessins et d’écriture, avec un taux de rafraichissement rapide et prenant un minimum de ressources. Que je puisse intégrer et manipuler des images avec une transparence si possible.

Thinker et Wx ne me semble pas des librairies viable pour ce projet. Si Turtle est la solution, comment je peux correctement le préparer pour mes besoins ? Car je suis plus confortable de dire à ma tortue va à X et Y que de lui dire déplace devant après tourne, va a droite etc… je veux pouvoir dessiner sur papier avec mes mesures et après transposé le tout en code facile et rapide.

import turtle
from turtle import *

def drawMain():
    print("Drawing main app")
    wn = turtle.Screen()
    wn.screensize(canvwidth=320, canvheight=240)
    wn.bgcolor("#aaaaff")
    wn.bgpic("bg.gif")
    wn.title("PCStats")
    
    wn.addshape("gauge_80x40.gif")
    
    wn.reset()
    wn.setworldcoordinates(0,0,320,240)
    
    turtle.penup()
    turtle.goto(0,0)
    drawGauge(wn)
    turtle.goto(80,0)
    drawGauge(wn)
    
    wn_run = turtle.Turtle()
    turtle.done()
    
def drawGauge(wn):
    print("Drawing a gauge")
    turtle.shape("gauge_80x40.gif")
    turtle.stamp()
    
def getData(path):
    print("Looking for "+path)
    
drawMain()


Ce qui me donne cela

Pour moi, 0,0 c’est le coin haut gauche, et non le coin bas gauche, si je « goto » a 80,40, je m’attendrais a voir la tortue à 80px de gauche et 40px du haut et non 80px du centre vers la droite et 40px du centre vers le bas. Et si je définie les coordonnées du monde de 0,0 à 320,240, je m’attend que les mouvement de goto soit entre 0~320 et 0~240 et ne contient aucune valeur négative.

Pour moi, les directions de Turtle doivent être sont déplacement de ou elle ce trouve et le goto devrais être la position absolue. Présentement, si je comprend, peut importe ce que je commande, il marche avec les axes X et Y en positif (+) et négatif (-), comme une carte.

A la limite, quelque chose plus proche du CSS serait le best.


Mon code contient des lignes en test, j’essai de comprendre la logique des paramètres et du résultat. J’ai aussi un document « turtle.cfg » dans lequel je met le 320x240 et les autres valeur par défaut, mais semble l’ignorer en partie.

你好,

si par là tu entends des gauges et des graphiques il y a plusieurs librairies orientée charts chez pypi qui en proposent.
matplotlib et ses « Third party » (Third-party and user-contributed packages — Matplotlib third-party packages documentation) offre aussi une foultitude de graphique ( courbe en temps réel - https://www.delftstack.com/fr/howto/matplotlib/how-to-plot-in-real-time-using-matplotlib/ )
pyecharts (en chinois mais pas que ) pyecharts · PyPI
Python pyecharts Draw instrument Cluster

Merci de la réponse rapide.

Ce n’est pas évident car la plupart affiche des « charts » de type historique. Quoi que pas mauvais, dans le but actuel je n’aime pas et ça reste limité. Je cherche pas nécessairement a avoir des modules de création facile, car par exemple tk_tools permet de créer des gauges. Mais reste très limité.

D’autres donne le rendu en serveur Web mais rendu la je ferais tout en HTML CSS, le problème es qu’un navigateur est lourd sur un Raspberry Pi Zero.

Avec Turtle, ou si ont trouve un équivalent, je pensai me créer mes propres design en commande, soit je charge une image et étampe, soit je dessine directement avec le crayon.

Turtle serais potable si j’arriverais a comprendre et maitriser ceci;

  • Avoir un espace de travail limité à l’écran déterminé,
  • Retirer la barre de caption (titre, réduire, agrandir, fermer)
  • Déterminer le World pour obtenir un quadrillage précis ou le point 0,0 est au coin haut,gauche comme ceux de l’écran (1)
  • Que le background soit ajusté aux coordonnés du World
  • Supprimer l’affichage pour actualiser avec le nouveau OU créer des layers pour créer une Background et avoir une autre niveau pour modifier/effacer les ajouts (barres, textes). Dans le plus simple est d’avoir le background en image et travailler sur le dessus, mais je veux pouvoir déplacer aux besoins, sans devoir faire un nouveau background. (2)

(1) Quand ont position une fenêtre dans un écran, les coordonné de l’écran commence par 0,0 pour aller chercher les valeurs selon la résolution, comme le maximum est de 1920,1080 sur une sortie 1080. Avec le projet actuel ce serais 320x240, donc 0,0 à 320,240 comme coordonnés possibles.

(2) Si la tortue est assez rapide pour produire de manière instantané et l’actualiser sans de « flicker », la recréation de tout le module affichable est profitable.

En attendant, je tente de comprendre Turtle.

J’ai un code pour retirer la barre de caption, et j’arrive à redimensionner mon affichage.

Cependant, la tortue a des valeurs plus qu’étrange. Après vérification, mon écran est plutot de 480x320, alors j’ai corrigé cette valeur.

Mon code:
import turtle
from turtle import *

def drawMain():
    print("Drawing main app")
    wn = turtle.Screen()
    #turtle.Screen().getcanvas()._root().overrideredirect(True)
    turtle.Screen().getcanvas()._root().wm_geometry("480x320")
    wn.reset()
    wn.screensize(480,320)
    wn.setworldcoordinates(-240,-160,240,160)
    wn.bgcolor("#aaaaff")
    wn.bgpic("bg.gif")
    wn.title("PCStats")
    wn.addshape("gauge_80x40.gif")
    turtle.resizemode("noresize")
    turtle.hideturtle()
    turtle.penup()
    turtle.pen(shown=True,pensize=1,speed=10)
    turtle.shapesize(1,1,1)
    
    #while True:
    drawGauge(wn,-226,0)
    drawGauge(wn,-200,0)
    drawGauge(wn,-174,0)
    drawGauge(wn,-148,0)
    drawGauge(wn,-122,0)
    drawGauge(wn,0,0)
    
    wn_run = turtle.Turtle()
    turtle.hideturtle()
        
    turtle.done()
    
def drawGauge(wn,x,y):
    turtle.penup()
    print("Drawing a gauge")
    turtle.goto(x,y)
    turtle.shape("gauge_80x40.gif")
    turtle.stamp()
    turtle.hideturtle()
    
def getData(path):
    print("Looking for "+path)
    
drawMain()

L’image « gauge_80x40.gif » est en 80px x 40px, et pourtant je dois déplacer la tortue de « 14 » pour comencer et de « 26 » par la suie pour mettre mes gauges une a côté de l’autre. Je pense avec le point de début a « -240 » et sont extrême à « 240 », mais clairement, Turtle travail dans d’autres mesure. j’ai tenté de mettre à 1 les valeur pour être au plus bas (que je crois) pour éviter ce problème, mais c’est clairement pas ça.

Comme j’ai dit, je peut travailler avec Turtle si il faut, mais il me faudrait un environnement précis.


La mise a l’échelle affecte le rendu sous Windows. Je suis a 125% et à 100% les stance sont moindre pour avoir les gauges collés, cependant, rien qui ce rapproche de la réalité d’une mesure de pixel.

Turtle étant trop lent et imprécis, je me suis tourné vers Glade et GTK, que j’avais déjà utilisé dans un projet précédent.

Il me permet d’avoir un « Level Bar » et de personnaliser rapidement et plus simplement l’apparence. Un peu lent au chargement, mais je peux changer les valeurs sans devoir tout redessiner.

Je reste ouvert à d’autres idée de librairies, ou à des modules pour Glade GTK ?

Salut, si vraiment tu finis par te rediriger vers Turtle, il existe une version plus simple qui permet d’enregistrer les images autrement qu’en .gif…

Le programme s’appelle TorPy… Le lien vers Torpy

Pour ce qui est de Glade, je ne connais pas du tout… Je laisse les autres, ils sauront mieux te guider…

Excellente fin de journée,

Glade est l’éditeur de GTK, je suis arrivé a créer de quoi de potable. J’ai pas de quoi de très design mais « ça fait la job ».

La j’ai un peu planté mon projet, la conversion du Raspberry en OTG c’est mal passé je crois, mais c’est un autre problème.

Mais je continuer à chercher de quoi qui me donnera encore un peu plus de liberté.

Dans l’état actuel du tests avec Turtle, je n’avais pas l’envie d’enregistrer le rendu, c’est plutôt au niveau du chargement d’une image, et dans le choix des couleurs. La palette est très limité et ne prend pas en charge les « bmp », qui me semblait un format basique.

Turtle est de mon avis plus un outils de projet avec un langage simple qu’un outils de graphisme précis. Déjà la différence entre l’unité de la tortue et celui du pixel ne semble pas cohérente et fiable.


TorPy, par la présentation est clairement une version Française de Turtle, avec quelques fix/personnalisations. Et confirme que l’usage de Turtle/Torpy est dans un but d’apprentissage. Torpy ce veux également un éditeur / interpréteur, ce qui est possible d’avoir avec Turtle.

Bref, ce n’est pas l’option valide pour mon projet, mis la possibilité de créer des formes, rien d’autres n’est avantageux.

Bon, le projet avance avec Glade (comme j’ai dis avant).

J’ai des Level Bar à gauche et passé au mode texte.

Je trouve étrange que je n’ai pas été en mesure de trouver des librairies pour créer des gauges, level bar, history graph etc pour GTK ou autres. C’est plus axé sur un module qui donne qu’un rendu au lieu d’ajouter à un GUI existant. Bon, en fait je crois qu’il est possible de créer une inclusion entre les deux modules mais qui n’est pas nécessairement pratique dans mon cas.

Le rendu faut qui soit rapide, sortir des rapport et des analyses statique, c’est modules peuvent faire très bien leur travail. Mais pour du Monitoring, faut actualiser rapidement.

Je vais ouvrir un autre sujet pour ce projet spécifique, mais je garde celui si, pour ceux qui désire fournir une réponse à cette question.

Comment dessiner de manière précise et avec une rapidité de rafraichissement rapide sous Python ?