Pixel Buffer
Funciones
Pixbuf* | pixbuf_create (...) |
Pixbuf* | pixbuf_copy (...) |
Pixbuf* | pixbuf_convert (...) |
Pixbuf* | pixbuf_rotate (...) |
Pixbuf* | pixbuf_scale (...) |
Pixbuf* | pixbuf_convolution (...) |
void | pixbuf_destroy (...) |
uint32_t | pixbuf_size (...) |
uint32_t | pixbuf_width (...) |
uint32_t | pixbuf_height (...) |
pixformat_t | pixbuf_format (...) |
const byte_t* | pixbuf_cdata (...) |
byte_t* | pixbuf_data (...) |
uint32_t | pixbuf_format_bpp (...) |
uint32_t | pixbuf_get (...) |
void | pixbuf_set (...) |
void | pixbuf_fill (...) |
void | pixbuf_fill_rect (...) |
void | pixbuf_line (...) |
void | pixbuf_circle (...) |
Un pixel buffer es una área de memoria que representa una rejilla de puntos de color o píxeles. Permiten el acceso directo a la información pero no están optimizados para el dibujo en pantalla, por lo que deberemos crear un objeto Image para poder visualizarlos. Son muy eficientes para la generación procedimental o la aplicación de filtros, ya que leer o escribir un valor no requiere más que acceder a su posición dentro del búfer.
- Utiliza pixbuf_create para crear un nuevo píxel búfer.
- Utiliza image_pixels para obtener los píxeles de una imagen.
- Utiliza pixbuf_width para obtener la anchura de la rejilla.
- Utiliza pixbuf_height para obtener la altura de la rejilla.
Todas las operaciones sobre pixel buffers se realizan en la CPU. Son eficientes en la medida que accedemos directamente a memoria, pero no se pueden comparar con alternativas que utilicen la GPU para el procesamiento digital de imágenes.
1. Formatos de píxel
El formato hace referencia a como se codifica el valor de cada píxel dentro del búfer (Tabla 1) (Figura 1).
- Utiliza pixbuf_format para obtener el formato del píxel.
Valor | Descripción |
ekRGB24 | True color +16 Millones simultáneos, 24 bits por píxel. |
ekRGBA32 | True color con canal alpha (transparencias), 32 bits por píxel. |
ekGRAY8 | 256 tonos de gris, 8 bits por píxel. |
ekINDEX1 | Indexado, 1 bit por pixel. |
ekINDEX2 | Indexado, 2 bits por pixel. |
ekINDEX4 | Indexado, 4 bits por pixel. |
ekINDEX8 | Indexado, 8 bits por pixel. |

2. Imágenes procedimentales
Una forma de "rellenar" los buffers es mediante algoritmos que calculen el valor de cada píxel. Un claro ejemplo lo encontramos en la representación de conjuntos fractales (Figura 2), un área de la matemática dedicada al estudio de determinados sistemas dinámicos. En Fractals tienes la aplicación completa.
- Utiliza pixbuf_data para obtener un puntero al contenido del búfer.
- Utiliza pixbuf_set para escribir el valor de un píxel.
- Utiliza pixbuf_get para leer el valor de un píxel.

3. Filtros y convolución
La convolución es una operación sobre la imagen donde el valor resultante de cada píxel se calcula en función de sus vecinos (Fórmula 1) (Figura 3). El operador se codifica mediante una matriz que se va desplazando de forma secuencial por todos los puntos del búfer original. Los valores de la dicha matriz determinarán la naturaleza del filtro y desarrollan con detalle dentro de la teoría del tratamiento digital de imágenes. En Filters tienes una aplicación de ejemplo.
- Utiliza pixbuf_convolution para aplicar un filtro de convolución.


La convolución no soporta formatos indexados, debido a que promedia entre valores de color real. Sí que funciona con tonos de gris.
4. Transformaciones geométricas
- Utiliza pixbuf_rotate para rotar el búfer.
- Utiliza pixbuf_scale para estirar o estrechar la imagen.

5. Dibujo de primitivas
- Utiliza pixbuf_fill para rellenar todo el búfer con el mismo valor.
- Utiliza pixbuf_fill_rect para rellenar una región.
- Utiliza pixbuf_line para dibujar una línea.
- Utiliza pixbuf_circle para dibujar el contorno de un círculo.
6. Copia y conversión
Durante el procesamiento digital de una imagen es posible que tengamos que encadenar varias operaciones, por lo que será de utilidad poder realizar copias de los búfer o conversiones de formato.
- Utiliza pixbuf_copy para realizar una copia.
- Utiliza pixbuf_convert para convertir a otro formato (Tabla 2).
Desde | Hacia | Observaciones |
RGB24 | RGB32 | Se añade canal alfa con el valor 255 |
RGB32 | RGB24 | Se elimina el canal alfa con posible pérdida de información. |
RGB | Gray | Se ponderan los canales RGB a razón de 77/255, 148/255, 30/255. Se pierde el canal alfa. |
Gray | RGB | Se duplican los canales RGB(gray, gray, gray). Canal alfa a 255. |
RGB | Indexed | Si se especifica una paleta, se calcula la menor distancia entre cada píxel y la paleta. Si no, se calcula la Paleta óptima. Posible pérdida de información. |
Indexed | RGB | Se utilizará una Paleta predefinida si no se especifica ninguna otra. |
Indexed | Indexed | Si el destino tiene menor número de bits, se aplicará out = in % bpp con posible pérdida de información. |
Gray | Indexed | El formato Gray8 se considerará indexado a todos los efectos. |
Indexed | Gray | El formato Gray8 se considerará indexado a todos los efectos. |
pixbuf_create ()
Crea un nuevo pixel búfer.
Pixbuf* pixbuf_create(const uint32_t width, const uint32_t height, const pixformat_t format);
width | Anchura. |
height | Altura. |
format | Formato de píxel. |
Retorna
El píxel búfer.
Observaciones
El contenido inicial estará indeterminado.
pixbuf_copy ()
Crea una copia del pixel búfer.
Pixbuf* pixbuf_copy(const Pixbuf *pixbuf);
pixbuf | El búfer original. |
Retorna
La copia.
pixbuf_convert ()
Cambia el formato de un píxel búfer.
Pixbuf* pixbuf_convert(const Pixbuf *pixbuf, const Palette *palette, const pixformat_t oformat);
pixbuf | El búfer original. |
palette | Paleta de colores necesaria para determinadas conversiones. |
oformat | Formato del búfer resultado. |
Retorna
El búfer convertido.
Observaciones
Ver Copia y conversión.
pixbuf_rotate ()
Crea un píxel búfer rotando un búfer de entrada.
Pixbuf* pixbuf_rotate(const Pixbuf *pixbuf, const real32_t cx, const real32_t cy, const real32_t angle, const bool_t clip, const uint32_t background);
pixbuf | El búfer original. |
cx | Coordenada x del centro de giro (en imagen original). |
cy | Coordenada y del centro de giro (en imagen original). |
angle | Ángulo en radianes. |
clip |
|
background | Valor de fondo con el que rellenar aquellos píxeles que no correspondan a ninguno de la original. |
Retorna
El nuevo búfer rotado.
Observaciones
Ver Transformaciones geométricas.
pixbuf_scale ()
Crea un píxel búfer escalando un búfer de entrada.
Pixbuf* pixbuf_scale(const Pixbuf *pixbuf, const uint32_t nwidth, const uint32_t nheight);
pixbuf | El búfer original. |
nwidth | La anchura del búfer resultado. |
nheight | La altura del búfer resultado. |
Retorna
El nuevo búfer escalado.
Observaciones
Ver Transformaciones geométricas.
pixbuf_convolution ()
Aplica un filtro de convolución al búfer de entrada.
Pixbuf* pixbuf_convolution(const Pixbuf *pixbuf, const real32_t *matrix, const uint32_t mwidth, const uint32_t mheight, const real32_t factor, const real32_t bias);
pixbuf | El búfer original. |
matrix | La matriz de convolución. |
mwidth | Número de columnas de la matriz. |
mheight | Número de filas de la matriz. |
factor | Factor de escala a aplicar al resultado. |
bias | Offset o desplazamiento a aplicar al resultado. |
Retorna
El nuevo búfer con el resultado.
Observaciones
pixbuf_destroy ()
Destruye el búfer.
void pixbuf_destroy(Pixbuf **pixbuf);
pixbuf | El búfer. Será puesto a |
pixbuf_size ()
Obtiene el tamaño del búfer (en píxeles).
uint32_t pixbuf_size(const Pixbuf *pixbuf);
pixbuf | El búfer. |
Retorna
Anchura x altura.
pixbuf_width ()
Obtiene la anchura del búfer.
uint32_t pixbuf_width(const Pixbuf *pixbuf);
pixbuf | El búfer. |
Retorna
Anchura.
pixbuf_height ()
Obtiene la altura del búfer.
uint32_t pixbuf_height(const Pixbuf *pixbuf);
pixbuf | El búfer. |
Retorna
Altura.
pixbuf_format ()
Obtiene el formato de píxel.
pixformat_t pixbuf_format(const Pixbuf *pixbuf);
pixbuf | El búfer. |
Retorna
El formato.
Observaciones
Ver Formatos de píxel.
pixbuf_cdata ()
Obtiene un puntero de solo lectura al contenido del búfer.
const byte_t* pixbuf_cdata(const Pixbuf *pixbuf);
pixbuf | El búfer. |
Retorna
Puntero al primer elemento.
Observaciones
Manipular correctamente el búfer requiere conocer los Formatos de píxel y, en ocasiones, utilizar los operadores a nivel de bit. Utilizar pixbuf_get para leer correctamente un píxel.
pixbuf_data ()
Obtiene un puntero de lectura/escritura al contenido del búfer.
byte_t* pixbuf_data(Pixbuf *pixbuf);
pixbuf | El búfer. |
Retorna
Puntero al primer elemento.
Observaciones
Manipular correctamente el búfer requiere conocer los Formatos de píxel y, en ocasiones, utilizar los operadores a nivel de bit. Utilizar pixbuf_get y pixbuf_set para leer/escribir correctamente un píxel.
pixbuf_format_bpp ()
Obtiene los bits por píxel según el formato.
uint32_t pixbuf_format_bpp(const pixformat_t format);
format | El formato. |
Retorna
Bits por píxel.
Observaciones
Ver Formatos de píxel.
pixbuf_get ()
Obtiene el valor de un píxel.
uint32_t pixbuf_get(const Pixbuf *pixbuf, const uint32_t x, const uint32_t y);
pixbuf | El búfer. |
x | Coordenada x del píxel. |
y | Coordenada y del píxel. |
Retorna
El valor.
Observaciones
Ver Formatos de píxel para interpretar correctamente el valor.
pixbuf_set ()
Establece el valor de un píxel.
void pixbuf_set(Pixbuf *pixbuf, const uint32_t x, const uint32_t y, const uint32_t value);
pixbuf | El búfer. |
x | Coordenada x del píxel. |
y | Coordenada y del píxel. |
value | El valor. |
Observaciones
Ver Formatos de píxel para interpretar correctamente el valor.
pixbuf_fill ()
Rellena todo el búfer con el mismo valor.
void pixbuf_fill(Pixbuf *pixbuf, const uint32_t value);
pixbuf | El búfer. |
value | El valor. |
Observaciones
Ver Dibujo de primitivas.
pixbuf_fill_rect ()
Rellena una región rectangular con el mismo valor.
void pixbuf_fill_rect(Pixbuf *pixbuf, const uint32_t x, const uint32_t y, const uint32_t width, const uint32_t height, const uint32_t value);
pixbuf | El búfer. |
x | Coordenada x de la esquina superior-izquierda. |
y | Coordenada y de la esquina superior-izquierda. |
width | Anchura del rectángulo. |
height | Altura del rectángulo. |
value | El valor. |
Observaciones
Ver Dibujo de primitivas.
pixbuf_line ()
Dibuja una línea, mediante el algoritmo de Bresenham.
void pixbuf_line(Pixbuf *pixbuf, const uint32_t x0, const uint32_t y0, const uint32_t x1, const uint32_t y1, const uint32_t value);
pixbuf | El búfer. |
x0 | Coordenada x del primer punto. |
y0 | Coordenada y del primer punto. |
x1 | Coordenada x del segundo punto. |
y1 | Coordenada y del segundo punto. |
value | El valor. |
Observaciones
Ver Dibujo de primitivas.
pixbuf_circle ()
Dibuja una círculo, mediante el algoritmo de Bresenham.
void pixbuf_circle(Pixbuf *pixbuf, const uint32_t x, const uint32_t y, const uint32_t r, const uint32_t value);
pixbuf | El búfer. |
x | Coordenada x del centro. |
y | Coordenada y del centro. |
r | Radio. |
value | El valor. |
Observaciones
Ver Dibujo de primitivas.