`framebuf` — manipulation de tampon d’image¶

Le module framebuf fournit un petit tampon de pixels sans allocation, accompagné d’opérations de dessin primitives. Il est destiné à piloter des afficheurs externes (OLED, LCD, papier électronique, etc.).

Note

Pour le traitement d’images sur des trames capturées, utilisez plutôt la classe image.Image d’OpenMV, bien plus riche – elle offre nettement plus de primitives de dessin, de conversions de couleur et de fonctions d’analyse que framebuf.

class FrameBuffer¶

A FrameBuffer wraps a user-supplied buffer-protocol object (typically a bytearray) and exposes methods to draw pixels, lines, rectangles, ellipses, polygons, text and other FrameBuffers into it.

Exemple:

import framebuf

# FrameBuffer needs 2 bytes for every RGB565 pixel.
fbuf = framebuf.FrameBuffer(bytearray(100 * 10 * 2), 100, 10, framebuf.RGB565)

fbuf.fill(0)
fbuf.text("MicroPython!", 0, 0, 0xffff)
fbuf.hline(0, 9, 96, 0xffff)

Constructeurs¶

class framebuf.FrameBuffer(buffer: Any, width: int, height: int, format: int, stride: int | None = None, /)¶

Construit un objet FrameBuffer.

buffer – tout objet prenant en charge le protocole tampon ; il doit être suffisamment grand pour contenir stride * height pixels au format format choisi.
width – largeur du tampon d’image en pixels.
height – hauteur du tampon d’image en pixels.
format – format de pixel ; l’une des constantes énumérées sous Constantes ci-dessous. Le format détermine à la fois la taille de chaque pixel dans buffer et la façon dont un entier de couleur c passé à toute méthode de dessin est interprété.
stride – nombre de pixels par rangée horizontale, y compris tout remplissage. Vaut width par défaut. Définissez-le pour utiliser une sous-région d’un tampon plus grand.

Passer un buffer trop petit, ou des dimensions invalides, produira des résultats indéfinis – le constructeur ne valide pas toutes les combinaisons.

Méthodes de dessin¶

FrameBuffer.fill(c: int) → None¶: Remplit l’ensemble du tampon d’image avec la couleur c.

FrameBuffer.fill_rect(x: int, y: int, w: int, h: int, c: int) → None¶: Remplit un rectangle w x h à (x, y) avec la couleur c. Équivaut à rect() avec f=True.

FrameBuffer.pixel(x: int, y: int, c: int | None = None) → int | None¶: Sans argument c, renvoie la valeur de couleur du pixel à (x, y). Avec c fourni, fixe ce pixel à la couleur c.

FrameBuffer.hline(x: int, y: int, w: int, c: int) → None¶
FrameBuffer.vline(x: int, y: int, h: int, c: int) → None¶
FrameBuffer.line(x1: int, y1: int, x2: int, y2: int, c: int) → None¶: Dessine une ligne d’un pixel d’épaisseur dans la couleur c. hline() et vline() dessinent une ligne horizontale/verticale de la longueur donnée ; line() dessine une ligne entre deux points arbitraires.

FrameBuffer.rect(x: int, y: int, w: int, h: int, c: int, f: bool = False) → None¶: Dessine un rectangle à (x, y) de taille w x h dans la couleur c. Si f vaut True, le rectangle est rempli ; sinon, seul un contour d’un pixel est dessiné.

FrameBuffer.ellipse(x: int, y: int, xr: int, yr: int, c: int, f: bool = False, m: int = 0) → None¶

Dessine une ellipse centrée sur (x, y) avec un rayon en x de xr et un rayon en y de yr dans la couleur c. Des rayons égaux produisent un cercle. f=True remplit la forme au lieu de seulement en tracer le contour.

m est un masque de bits qui restreint le dessin à des quadrants spécifiques (numérotés dans le sens antihoraire à partir du coin supérieur droit) :

Bit	Quadrant	Région
bit 0	Q1	Haut-droit
bit 1	Q2	Haut-gauche
bit 2	Q3	Bas-gauche
bit 3	Q4	Bas-droit

La valeur par défaut m=0 dessine les quatre quadrants.

FrameBuffer.poly(x: int, y: int, coords: Any, c: int, f: bool = False) → None¶: Dessine un polygone fermé arbitraire (convexe ou concave) à l’offset (x, y) dans la couleur c. coords doit être un array d’entiers signés sur 16 bits disposés comme array('h', [x0, y0, x1, y1, ..., xn, yn]). f=True remplit le polygone au lieu de seulement en tracer le contour.

FrameBuffer.text(s: str, x: int, y: int, c: int = 1) → None¶: Dessine la chaîne s avec son coin supérieur gauche à (x, y) dans la couleur c. La police intégrée est fixée à 8x8 pixels et ne peut pas être changée. c vaut 1 par défaut.

FrameBuffer.scroll(xstep: int, ystep: int) → None¶: Décale le contenu du tampon de (xstep, ystep). Les pixels introduits depuis l’extérieur du tampon ne sont pas effacés, de sorte qu’un « fantôme » du contenu précédent peut subsister sur le bord de fuite.

FrameBuffer.blit(fbuf: FrameBuffer | Tuple, x: int, y: int, key: int = -1, palette: FrameBuffer | None = None) → None¶

Dessine un autre tampon d’image fbuf par-dessus celui-ci, avec son coin supérieur gauche à (x, y).

Si key est fourni, tout pixel source correspondant à cette valeur de couleur est traité comme transparent et n’est pas dessiné. Lorsqu’une palette est fournie, la comparaison se fait par rapport à la sortie de la palette, et non par rapport à la valeur brute de fbuf.

fbuf peut être une instance de FrameBuffer ou un tuple/une liste correspondant à la signature du constructeur:

(buffer, width, height, format)
(buffer, width, height, format, stride)

Lorsque la source est un tuple/une liste, buffer peut être en lecture seule.

palette permet le blit entre des tampons de formats différents – par exemple, le rendu d’un glyphe monochrome dans un tampon RGB565. Il s’agit d’un FrameBuffer dont le format correspond à la destination, avec une hauteur de 1 et une largeur égale au nombre de couleurs sources (2**N pour une source de N bits par pixel). La valeur de pixel source i est remplacée par la couleur située à palette[i, 0] avant le dessin.

Constantes¶

Les valeurs format suivantes sont acceptées par le constructeur. La colonne « octets par pixel » est le multiplicateur nécessaire pour dimensionner le tampon de stockage.

Constante	Octets/pixel	Disposition des pixels
`MONO_VLSB`	0.125	Monochrome (1 bit). Chaque octet contient 8 pixels empilés verticalement, le bit 0 étant le plus proche du haut. Les rangées de 8 pixels progressent de gauche à droite à travers le tampon, puis passent à la rangée de 8 pixels suivante.
`MONO_HLSB`	0.125	Monochrome (1 bit). Chaque octet contient 8 pixels horizontaux, le bit 7 étant le plus à gauche. Les rangées progressent d’un pixel à la fois verticalement.
`MONO_HMSB`	0.125	Monochrome (1 bit). Comme `MONO_HLSB` mais avec le bit 0 le plus à gauche.
`GS2_HMSB`	0.25	Niveaux de gris sur 2 bits (4 niveaux), empaquetés horizontalement, bit le plus significatif en premier.
`GS4_HMSB`	0.5	Niveaux de gris sur 4 bits (16 niveaux), empaquetés horizontalement, quartet le plus significatif en premier.
`GS8`	1	Niveaux de gris sur 8 bits (256 niveaux).
`RGB565`	2	RVB sur 16 bits avec 5 bits de rouge, 6 bits de vert et 5 bits de bleu.

framebuf.MVLSB est un alias obsolète de framebuf.MONO_VLSB ; privilégiez ce dernier dans le nouveau code.

Constructeur historique¶

framebuf.FrameBuffer1(buffer: Any, width: int, height: int, stride: int | None = None, /) → FrameBuffer¶: Raccourci obsolète pour FrameBuffer(buffer, width, height, framebuf.MONO_VLSB, stride). Conservé à des fins de rétrocompatibilité ; utilisez plutôt le constructeur FrameBuffer complet.