framebuf — manipulering av bildbuffert

Modulen framebuf tillhandahåller en liten, allokeringsfri pixelbuffert med primitiva ritoperationer. Den är avsedd för att driva externa skärmar (OLED, LCD, e-papper osv.).

Anteckning

För bildbehandlingsarbete på infångade bildrutor, använd istället OpenMV:s mycket rikare klass image.Image – den erbjuder betydligt fler ritprimitiver, färgkonverteringar och analysfunktioner än 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.

Exempel:

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)

Konstruktorer

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

Konstruera ett FrameBuffer-objekt.

• buffer – valfritt objekt som stöder buffertprotokollet; måste vara tillräckligt stort för att rymma stride * height pixlar i det valda format.

• width – bildbuffertens bredd i pixlar.

• height – bildbuffertens höjd i pixlar.

• format – pixelformat; en av konstanterna som listas under Konstanter nedan. Formatet avgör både storleken på varje pixel i buffer och hur ett färgheltal c som skickas till någon ritmetod tolkas.

• stride – antal pixlar per horisontell rad, inklusive eventuell utfyllnad. Standardvärdet är width. Ange detta för att använda en delregion av en större buffert.

Att skicka en buffer som är för liten, eller ogiltiga dimensioner, ger odefinierade resultat – konstruktorn validerar inte varje kombination.

Ritmetoder

FrameBuffer.fill(c: int) → None

Fyll hela bildbufferten med färgen c.

FrameBuffer.fill_rect(x: int, y: int, w: int, h: int, c: int) → None

Fyll en w x h-rektangel vid (x, y) med färgen c. Motsvarar rect() med f=True.

FrameBuffer.pixel(x: int, y: int, c: int | None = None) → int | None

Utan argumentet c, returnera färgvärdet för pixeln vid (x, y). Om c anges, sätt den pixeln till färgen 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

Rita en 1 pixel tjock linje i färgen c. hline() och vline() ritar en horisontell/vertikal linje av den angivna längden; line() ritar en linje mellan två godtyckliga punkter.

FrameBuffer.rect(x: int, y: int, w: int, h: int, c: int, f: bool = False) → None

Rita en rektangel vid (x, y) av storleken w x h i färgen c. Om f är True fylls rektangeln; annars ritas endast en 1 pixel tjock kontur.

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

Rita en ellips centrerad på (x, y) med x-radien xr och y-radien yr i färgen c. Lika radier ger en cirkel. f=True fyller formen istället för att bara rita konturen.

m är en bitmask som begränsar ritandet till specifika kvadranter (numrerade moturs från övre högra):

Bit	Kvadrant	Region
bit 0	Q1	Övre höger
bit 1	Q2	Övre vänster
bit 2	Q3	Nedre vänster
bit 3	Q4	Nedre höger

Standardvärdet m=0 ritar alla fyra kvadranterna.

FrameBuffer.poly(x: int, y: int, coords: Any, c: int, f: bool = False) → None

Rita en godtycklig sluten polygon (konvex eller konkav) vid offset (x, y) i färgen c. coords måste vara en array av 16-bitars heltal med tecken upplagda som array('h', [x0, y0, x1, y1, ..., xn, yn]). f=True fyller polygonen istället för att bara rita konturen.

FrameBuffer.text(s: str, x: int, y: int, c: int = 1) → None

Rita strängen s med dess övre vänstra hörn vid (x, y) i färgen c. Det inbyggda typsnittet är fast på 8x8 pixlar och kan inte ändras. c har standardvärdet 1.

FrameBuffer.scroll(xstep: int, ystep: int) → None

Förskjut buffertens innehåll med (xstep, ystep). Pixlar som skiftas in utifrån bufferten rensas inte, så ett ”spöke” av det tidigare innehållet kan finnas kvar vid den efterföljande kanten.

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

Rita en annan bildbuffert fbuf ovanpå denna med dess övre vänstra hörn vid (x, y).

Om key anges behandlas varje källpixel som matchar det färgvärdet som transparent och ritas inte. När en palette tillhandahålls görs jämförelsen mot palettens utdata, inte mot det råa fbuf-värdet.

fbuf kan vara en FrameBuffer-instans eller en tupel/lista som matchar konstruktorns signatur:

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

När källan är en tupel/lista får buffer vara skrivskyddad.

palette möjliggör blitting mellan buffertar av olika format – till exempel rendering av en monokrom glyf i en RGB565-buffert. Det är en FrameBuffer vars format matchar destinationen, med höjd 1 och bredd lika med antalet källfärger (2**N för en källa med N bitar per pixel). Källpixelvärdet i ersätts med färgen vid palette[i, 0] före ritandet.

Konstanter

Följande format-värden accepteras av konstruktorn. Kolumnen ”byte per pixel” är multiplikatorn som behövs vid dimensionering av den bakomliggande bufferten.

Konstant	Byte/pixel	Pixellayout
MONO_VLSB	0.125	Monokrom (1-bitars). Varje byte håller 8 vertikalt staplade pixlar med bit 0 närmast toppen. Rader om 8 pixlar fortskrider från vänster till höger genom bufferten och slår sedan om till nästa rad om 8 pixlar.
MONO_HLSB	0.125	Monokrom (1-bitars). Varje byte håller 8 horisontella pixlar med bit 7 längst till vänster. Rader fortskrider en pixel åt gången vertikalt.
MONO_HMSB	0.125	Monokrom (1-bitars). Som MONO_HLSB men med bit 0 längst till vänster.
GS2_HMSB	0.25	2-bitars gråskala (4 nivåer), packad horisontellt med mest signifikant bit först.
GS4_HMSB	0.5	4-bitars gråskala (16 nivåer), packad horisontellt med mest signifikant nibble först.
GS8	1	8-bitars gråskala (256 nivåer).
RGB565	2	16-bitars RGB med 5 röda, 6 gröna och 5 blå bitar.

framebuf.MVLSB är ett föråldrat alias för framebuf.MONO_VLSB; föredra det senare i ny kod.

Äldre konstruktor

framebuf.FrameBuffer1(buffer: Any, width: int, height: int, stride: int | None = None, /) → FrameBuffer

Föråldrad genväg för FrameBuffer(buffer, width, height, framebuf.MONO_VLSB, stride). Bibehållen för bakåtkompatibilitet; använd istället den fullständiga FrameBuffer-konstruktorn.