`framebuf` — Framebuffer-Manipulation¶

Das Modul framebuf stellt einen kleinen, allokationsfreien Pixelpuffer mit elementaren Zeichenoperationen bereit. Es ist für die Ansteuerung externer Displays gedacht (OLEDs, LCDs, E-Paper usw.).

Bemerkung

Für die Bildverarbeitung an aufgenommenen Einzelbildern verwenden Sie stattdessen OpenMVs deutlich umfangreichere Klasse image.Image – sie bietet weitaus mehr Zeichen-Primitive, Farbkonvertierungen und Analysefunktionen als 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.

Beispiel:

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)

Konstruktoren¶

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

Erzeugt ein FrameBuffer-Objekt.

buffer – ein beliebiges Objekt, das das Puffer-Protokoll unterstützt; muss groß genug sein, um stride * height Pixel im gewählten format aufzunehmen.
width – Breite des Framebuffers in Pixel.
height – Höhe des Framebuffers in Pixel.
format – Pixelformat; eine der unter Konstanten aufgeführten Konstanten. Das Format bestimmt sowohl die Größe jedes Pixels in buffer als auch, wie ein an eine Zeichenmethode übergebener Farb-Integer c interpretiert wird.
stride – Anzahl der Pixel pro horizontaler Zeile, einschließlich etwaiger Auffüllung. Standardwert ist width. Setzen Sie dies, um einen Teilbereich eines größeren Puffers zu verwenden.

Die Übergabe eines zu kleinen buffer oder ungültiger Abmessungen führt zu undefinierten Ergebnissen – der Konstruktor validiert nicht jede Kombination.

Zeichenmethoden¶

FrameBuffer.fill(c: int) → None¶: Füllt den gesamten Framebuffer mit der Farbe c.

FrameBuffer.fill_rect(x: int, y: int, w: int, h: int, c: int) → None¶: Füllt ein w x h großes Rechteck an (x, y) mit der Farbe c. Entspricht rect() mit f=True.

FrameBuffer.pixel(x: int, y: int, c: int | None = None) → int | None¶: Ohne c-Argument wird der Farbwert des Pixels an (x, y) zurückgegeben. Mit angegebenem c wird dieses Pixel auf die Farbe c gesetzt.

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¶: Zeichnet eine 1 Pixel dicke Linie in der Farbe c. hline() und vline() zeichnen eine horizontale/vertikale Linie der angegebenen Länge; line() zeichnet eine Linie zwischen zwei beliebigen Punkten.

FrameBuffer.rect(x: int, y: int, w: int, h: int, c: int, f: bool = False) → None¶: Zeichnet ein Rechteck an (x, y) der Größe w x h in der Farbe c. Wenn f gleich True ist, wird das Rechteck gefüllt; andernfalls wird nur eine 1 Pixel breite Umrandung gezeichnet.

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

Zeichnet eine Ellipse mit Mittelpunkt (x, y), x-Radius xr und y-Radius yr in der Farbe c. Gleiche Radien ergeben einen Kreis. f=True füllt die Form, anstatt sie nur zu umranden.

m ist eine Bitmaske, die das Zeichnen auf bestimmte Quadranten beschränkt (gegen den Uhrzeigersinn von oben rechts beginnend nummeriert):

Bit	Quadrant	Bereich
Bit 0	Q1	Oben rechts
Bit 1	Q2	Oben links
Bit 2	Q3	Unten links
Bit 3	Q4	Unten rechts

Der Standardwert m=0 zeichnet alle vier Quadranten.

FrameBuffer.poly(x: int, y: int, coords: Any, c: int, f: bool = False) → None¶: Zeichnet ein beliebiges geschlossenes Polygon (konvex oder konkav) am Offset (x, y) in der Farbe c. coords muss ein array aus vorzeichenbehafteten 16-Bit-Integern sein, angeordnet als array('h', [x0, y0, x1, y1, ..., xn, yn]). f=True füllt das Polygon, anstatt es nur zu umranden.

FrameBuffer.text(s: str, x: int, y: int, c: int = 1) → None¶: Zeichnet die Zeichenkette s mit ihrer oberen linken Ecke an (x, y) in der Farbe c. Die eingebaute Schriftart ist fest auf 8x8 Pixel eingestellt und kann nicht geändert werden. c ist standardmäßig 1.

FrameBuffer.scroll(xstep: int, ystep: int) → None¶: Verschiebt den Pufferinhalt um (xstep, ystep). Von außerhalb des Puffers hereingeschobene Pixel werden nicht gelöscht, sodass am nachlaufenden Rand ein „Geisterbild“ des vorherigen Inhalts verbleiben kann.

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

Zeichnet einen weiteren Framebuffer fbuf über diesen, mit seiner oberen linken Ecke an (x, y).

Wenn key angegeben ist, wird jedes Quellpixel, das diesem Farbwert entspricht, als transparent behandelt und nicht gezeichnet. Wenn eine palette bereitgestellt wird, erfolgt der Vergleich gegen die Palettenausgabe, nicht gegen den rohen fbuf-Wert.

fbuf kann eine FrameBuffer-Instanz oder ein Tupel/eine Liste sein, das/die der Konstruktorsignatur entspricht:

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

Wenn die Quelle ein Tupel/eine Liste ist, darf buffer schreibgeschützt sein.

palette ermöglicht das Blitten zwischen Puffern unterschiedlicher Formate – zum Beispiel das Rendern eines monochromen Glyphen in einen RGB565-Puffer. Es ist ein FrameBuffer, dessen Format dem Ziel entspricht, mit Höhe 1 und einer Breite gleich der Anzahl der Quellfarben (2**N für eine Quelle mit N Bit pro Pixel). Der Quellpixelwert i wird vor dem Zeichnen durch die Farbe an palette[i, 0] ersetzt.

Konstanten¶

Die folgenden format-Werte werden vom Konstruktor akzeptiert. Die Spalte „Bytes pro Pixel“ ist der Multiplikator, der zum Dimensionieren des Hintergrundpuffers benötigt wird.

Konstante	Bytes/Pixel	Pixel-Layout
`MONO_VLSB`	0.125	Monochrom (1-Bit). Jedes Byte enthält 8 vertikal gestapelte Pixel, wobei Bit 0 am nächsten an der Oberseite liegt. Zeilen von 8 Pixeln verlaufen von links nach rechts durch den Puffer und springen dann zur nächsten 8-Pixel-Zeile.
`MONO_HLSB`	0.125	Monochrom (1-Bit). Jedes Byte enthält 8 horizontale Pixel, wobei Bit 7 ganz links liegt. Zeilen verlaufen Pixel für Pixel vertikal.
`MONO_HMSB`	0.125	Monochrom (1-Bit). Wie `MONO_HLSB`, aber mit Bit 0 ganz links.
`GS2_HMSB`	0.25	2-Bit-Graustufen (4 Stufen), horizontal gepackt, höchstwertiges Bit zuerst.
`GS4_HMSB`	0.5	4-Bit-Graustufen (16 Stufen), horizontal gepackt, höchstwertiges Nibble zuerst.
`GS8`	1	8-Bit-Graustufen (256 Stufen).
`RGB565`	2	16-Bit-RGB mit 5 Rot-, 6 Grün- und 5 Blau-Bits.

framebuf.MVLSB ist ein veralteter Alias für framebuf.MONO_VLSB; bevorzugen Sie in neuem Code Letzteres.

Veralteter Konstruktor¶

framebuf.FrameBuffer1(buffer: Any, width: int, height: int, stride: int | None = None, /) → FrameBuffer¶: Veraltete Kurzform für FrameBuffer(buffer, width, height, framebuf.MONO_VLSB, stride). Aus Gründen der Abwärtskompatibilität beibehalten; verwenden Sie stattdessen den vollständigen FrameBuffer-Konstruktor.