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 (...)

1. Formatos de píxel
2. Imágenes procedimentales
3. Filtros y convolución
4. Transformaciones geométricas
5. Dibujo de primitivas
6. Copia y conversión

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.

Tabla 1: Formatos de pixel.

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.

Diferentes arrays de bytes con datos de píxeles. — Figura 1: **(a)** Color real, **(b)** tonos de gris, **(c)** indexados.

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.

Representación de un conjunto de Julia. — Figura 2: Conjunto de Julia. Imagen generada píxel a píxel mediante algoritmos fractales.

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.

Aplicación de un filtro de imagen. — Figura 3: Convolución aplicada a un píxel.

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.

Operativa de un filtro de imagen. — Figura 4: Proceso básico de un filtro de 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).

Tabla 2: Conversión entre formatos.

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	`TRUE` la imagen resultado tendrá las mismas dimensiones que la original, perdiendo parte del contenido. `FALSE` la imagen resultado se redimensionará para que quepa toda la original.
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

Ver Filtros y convolución.

pixbuf_destroy ()

Destruye el búfer.

void
pixbuf_destroy(Pixbuf **pixbuf);

pixbuf

El búfer. Será puesto a NULL tras la destrucción.

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.