Dessiner en Python sur l'écran de la brique EV3

La brique graphique d'action Affichage proposée par le logiciel de programmation des robots livré propose des déclinaisons permettant de dessiner sur l'écran LCD de la brique EV3.

La bibliothèque ev3dev2 propose des fonctions équivalentes dans la classe Display.

Méthodes de dessin de la classe Display

Ces méthodes permettent de dessiner sur l'écran. Elles correspondent aux variantes des briques graphiques d'affichage ci-dessus. Elles sont déclarées comme suit :
line(clear_screen=True, x1=10, y1=10, x2=50, y2=50, line_color='black', width=1)
rectangle(clear_screen=True, x1=10, y1=10, x2=80, y2=40, fill_color='black', outline_color='black')
circle(clear_screen=True, x=50, y=50, radius=40, fill_color='black', outline_color='black')
point(clear_screen=True, x=10, y=10, point_color='black')
Les paramètres passés correspondent, à quelques exceptions près, aux paramètres des briques graphiques :

• clear_screen indique si l'écran doit être effacé avant l'affichage. Par défaut, ce paramètre est initialisé à True. Mais, la plupart du temps, un dessin comporte plusieurs figures nécessitant un appel multiple des méthodes. C'est pourquoi, il vaut mieux préciser la valeur False pour que chaque méthode invoquée n'efface pas ce qu'a fait la précédente. Quitte à utiliser la méthode clear() pour effacer l'écran au début du dessin.
• x1, y1, x2, y2 (pour les méthodes line() et rectangle()) correspondent aux coordonnées des deux extrémité de la ligne ou du rectangle dessiné. Pour la méthode rectangle(), le fonctionnement diffère de la brique dans le sens ou pour la brique les paramètres passé sont les coordonnées du coin supérieur gauche et ses dimension largeur et hauteur, alors que pour la méthode rectangle(), il s'agit des coordonnées des coins supérieur gauche et inférieur droit.
• x et y (pour la méthode circle() uniquement) correspondent aux coordonnées du cente du cercle.
• radius (pour la méthode circle() uniquement) indique le rayon du cercle.
• line_color, outline_color, point_color désignent la couleur du dessin. Cette couleur ne peut prendre que deux valeurs 'black' ou 'white'. Pour dessiner, il faut utiliser la valeur 'black'. Pour effacer,il faut utiliser la couleur 'white'. 
• fill_color (pour les méthodes rectangle() et cercle()) désigne la couleur de remplissage. La valeur par défaut est 'black'. Ce qui signifie que l'intérieur du cercle ou du rectangle sera colorié en noir. Si l'on ne veut que le contour, il faut préciser fill_color='white' dans les paramètres passés.
• width (pour la méthode line() uniquement) indique l'épaisseur du trait.

Remarque sur l'usage des couleurs

L'écran LCD de la brique EV3 est monochrome. C'est à dire qu'il ne peut afficher que du noir ou du blanc. Ce sont d'ailleurs les deux seules couleurs proposées par les briques graphiques du logiciel de programmation Lego MindStorm : Vrai ('white') et Faux ('black').

La librairie ev3dev2 s'appuie sur la bibliothèque Python PIL. Celle-ci accepte toutes les couleurs comme elles sont exprimées en HTML. L'usage de la valeur 'red', par exemple, dans un paramètre de couleur, ne provoque pas d'erreur. La couleur est traduite dans une nuance de gris.

Exemple d'utilisation des méthodes de dessin

Dans l'exemple, il s'agit de dessiner une étoile à cinq branches dans un cercle. Afin d'illustrer l'usage des couleurs et leur affichage sur une écran noir et blanc, l'étoile est dessinée en blanc sur un fond de cercles concentriques de couleurs (en fait de nuances de gris) différentes comme le montre la figure ci-dessous :

Programmation

import time
import math
from ev3dev2.display import Display

#1#
SCREEN = Display()
CENTER = (SCREEN.xres // 2, SCREEN.yres // 2)
COLORS = ['violet', 'blue', 'green', 'yellow', 'orange', 'red']

#2#
def to_radian(a):
    return math.pi * a / 180.0

#3#
def draw_star(pos=CENTER, radius=50):
    #4#
    SCREEN.clear()
    #5#
    SCREEN.circle(clear_screen=False, x=CENTER[0], y=CENTER[1], radius=radius+5)
    #6#
    r = radius
    for color in COLORS:
        SCREEN.circle(clear_screen=False, x=CENTER[0], y=CENTER[1], radius=r, fill_color=color, outline_color=color)
        r -= 5
    #7# 
    a = to_radian(-90)
    x2=CENTER[0] + radius * math.cos(a)
    y2=CENTER[1] + radius * math.sin(a)
    for _ in range(0, 5):
        x1, y1 = x2, y2
        a += to_radian(144)
        x2=CENTER[0] + radius * math.cos(a)
        y2=CENTER[1] + radius * math.sin(a)
        SCREEN.line(clear_screen=False, x1=x1, y1=y1, x2=x2, y2=y2, width=3, line_color='white')
    #8#
    SCREEN.update()


#
#
##############################################################################
if __name__ == '__main__':
    draw_star()
    time.sleep(10)

Explications

1. Le programme commence par la déclaration de quelques constantes :
1. SCREEN est instanciée par l'invocation du constructeur de la classe Display. Cette classe est importée à partir du module display de la bibliothèque ev3dev2.
2. CENTER est un tuple correspondant au centre de l'écran calculé à partir des propriétés xres et yres de l'instance SCREEN correspondant respectivement aux résolutions horizontale et verticale de l'écran LCD de la brique EV3.
3. COLORS est une liste de couleurs utilisées pour l'affichage des cercles concentriques qui constituent le fond de l'étoile.
2. La fonction to_radian() est ici pour faciliter le tracé de l'étoile en exprimant les angles en degrés. Cette conversion en radian est indispensable car les fonctions trigonométriques du module math de Python fonctionnent en radians.
3. La fonction draw_star() dessine l'étoile telle que spécifiée ci dessus.
4. On commence par invoquer la méthode clear() sur l'instance SCREEN pour effacer l'écran. En effet, même si les méthodes de dessin disposent d'un paramètre clear_screan indiquant que l'écran doit être effacé, celles-ci, étant utilisées dans des structures répétitives, le paramètre sera initialise à False pour éviter qu'une instruction n'efface ce que la précédente a dessiné.
5. L'invocation de la méthode circle() dessine un cercle noir (couleur par défaut) dont le rayon excède de 5 pixels les dimensions de l'étoile.
6. Puis suit une succession de cercle de plus en plus petits dont la couleur est extraite de la liste COLORS. par l'invocation de la méthode circle() centrée sur  le centre de l'écran.
7. On procède de même pour tracer les cinq traits qui composent l'étoile à cinq branches en invoquant la méthode line() dont les extrémités sont calculées par l'utilisation des fonctions trigonométriques du module math de Python. Les traits sont dessinés en blanc avec 3 pixels d'épaisseur.
8. Si on s'arrête là, rien ne s'affiche sur l'écran après les invocations successives des méthodes circle() et line() dans la fonction draw_star(). L'affichage n'est effectif que si la méthode update() est invoquée.