`framebuf` — manipulación del búfer de fotogramas (frame buffer)¶

El módulo framebuf proporciona un pequeño búfer de píxeles sin asignación de memoria con operaciones primitivas de dibujo. Está pensado para controlar pantallas externas (OLED, LCD, papel electrónico, etc.).

Nota

Para el procesamiento de imágenes sobre fotogramas capturados, utilice en su lugar la clase image.Image de OpenMV, mucho más completa, que ofrece muchas más primitivas de dibujo, conversiones de color y funciones de análisis 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.

Ejemplo:

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)

Constructores¶

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

Construye un objeto FrameBuffer.

buffer – cualquier objeto que admita el protocolo de búfer; debe ser lo bastante grande como para contener stride * height píxeles en el format elegido.
width – ancho del búfer de fotogramas en píxeles.
height – alto del búfer de fotogramas en píxeles.
format – formato de píxel; uno de los constantes enumeradas en Constantes más abajo. El formato determina tanto el tamaño de cada píxel en buffer como la forma en que se interpreta un entero de color c pasado a cualquier método de dibujo.
stride – número de píxeles por fila horizontal, incluido cualquier relleno. Su valor predeterminado es width. Establézcalo para usar una subregión de un búfer mayor.

Pasar un buffer demasiado pequeño, o dimensiones no válidas, producirá resultados indefinidos: el constructor no valida todas las combinaciones.

Métodos de dibujo¶

FrameBuffer.fill(c: int) → None¶: Rellena todo el búfer de fotogramas con el color c.

FrameBuffer.fill_rect(x: int, y: int, w: int, h: int, c: int) → None¶: Rellena un rectángulo de w x h en (x, y) con el color c. Equivale a rect() con f=True.

FrameBuffer.pixel(x: int, y: int, c: int | None = None) → int | None¶: Sin el argumento c, devuelve el valor de color del píxel en (x, y). Si se proporciona c, establece ese píxel al color 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¶: Dibuja una línea de 1 píxel de grosor en el color c. hline() y vline() dibujan una línea horizontal/vertical de la longitud indicada; line() dibuja una línea entre dos puntos arbitrarios.

FrameBuffer.rect(x: int, y: int, w: int, h: int, c: int, f: bool = False) → None¶: Dibuja un rectángulo en (x, y) de tamaño w x h en el color c. Si f es True el rectángulo se rellena; de lo contrario solo se dibuja un contorno de 1 píxel.

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

Dibuja una elipse centrada en (x, y) con radio en x xr y radio en y yr en el color c. Radios iguales producen un círculo. f=True rellena la forma en lugar de solo dibujar su contorno.

m es una máscara de bits que restringe el dibujo a cuadrantes específicos (numerados en sentido antihorario desde la parte superior derecha):

Bit	Cuadrante	Región
bit 0	Q1	Superior derecho
bit 1	Q2	Superior izquierdo
bit 2	Q3	Inferior izquierdo
bit 3	Q4	Inferior derecho

El valor predeterminado m=0 dibuja los cuatro cuadrantes.

FrameBuffer.poly(x: int, y: int, coords: Any, c: int, f: bool = False) → None¶: Dibuja un polígono cerrado arbitrario (convexo o cóncavo) en el desplazamiento (x, y) en el color c. coords debe ser un array de enteros con signo de 16 bits dispuestos como array('h', [x0, y0, x1, y1, ..., xn, yn]). f=True rellena el polígono en lugar de solo dibujar su contorno.

FrameBuffer.text(s: str, x: int, y: int, c: int = 1) → None¶: Dibuja la cadena s con su esquina superior izquierda en (x, y) en el color c. La fuente integrada es fija de 8x8 píxeles y no se puede cambiar. El valor predeterminado de c es 1.

FrameBuffer.scroll(xstep: int, ystep: int) → None¶: Desplaza el contenido del búfer en (xstep, ystep). Los píxeles que entran desde fuera del búfer no se borran, por lo que puede quedar un «fantasma» del contenido anterior en el borde de salida.

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

Dibuja otro búfer de fotogramas fbuf encima de este, con su esquina superior izquierda en (x, y).

Si se proporciona key, cualquier píxel de origen que coincida con ese valor de color se trata como transparente y no se dibuja. Cuando se proporciona una palette, la comparación se realiza con la salida de la paleta, no con el valor fbuf sin procesar.

fbuf puede ser una instancia de FrameBuffer o una tupla/lista que coincida con la firma del constructor:

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

Cuando el origen es una tupla/lista, buffer puede ser de solo lectura.

palette permite hacer blitting entre búferes de distintos formatos; por ejemplo, renderizar un glifo monocromo en un búfer RGB565. Es un FrameBuffer cuyo formato coincide con el de destino, con altura 1 y anchura igual al número de colores de origen (2**N para un origen de N bits por píxel). El valor de píxel de origen i se reemplaza por el color situado en palette[i, 0] antes de dibujar.

Constantes¶

El constructor acepta los siguientes valores de format. La columna «bytes por píxel» es el multiplicador necesario al dimensionar el búfer de respaldo.

Constante	Bytes/píxel	Disposición de píxeles
`MONO_VLSB`	0.125	Monocromo (1 bit). Cada byte contiene 8 píxeles apilados verticalmente, con el bit 0 más cercano a la parte superior. Las filas de 8 píxeles avanzan de izquierda a derecha por el búfer y luego pasan a la siguiente fila de 8 píxeles.
`MONO_HLSB`	0.125	Monocromo (1 bit). Cada byte contiene 8 píxeles horizontales, con el bit 7 a la izquierda. Las filas avanzan un píxel cada vez verticalmente.
`MONO_HMSB`	0.125	Monocromo (1 bit). Como `MONO_HLSB` pero con el bit 0 a la izquierda.
`GS2_HMSB`	0.25	Escala de grises de 2 bits (4 niveles), empaquetada horizontalmente con el bit más significativo primero.
`GS4_HMSB`	0.5	Escala de grises de 4 bits (16 niveles), empaquetada horizontalmente con el nibble más significativo primero.
`GS8`	1	Escala de grises de 8 bits (256 niveles).
`RGB565`	2	RGB de 16 bits con 5 bits de rojo, 6 de verde y 5 de azul.

framebuf.MVLSB es un alias obsoleto de framebuf.MONO_VLSB; prefiera este último en código nuevo.

Constructor heredado¶

framebuf.FrameBuffer1(buffer: Any, width: int, height: int, stride: int | None = None, /) → FrameBuffer¶: Atajo obsoleto para FrameBuffer(buffer, width, height, framebuf.MONO_VLSB, stride). Se conserva por compatibilidad con versiones anteriores; utilice en su lugar el constructor completo FrameBuffer.