SDK Multiplataforma en C logo

SDK Multiplataforma en C

Pixel Buffer

❮ Anterior
Siguiente ❯

Funciones

Pixbuf*pixbuf_create (...)
Pixbuf*pixbuf_copy (...)
Pixbuf*pixbuf_convert (...)
Pixbuf*pixbuf_rotate (...)
Pixbuf*pixbuf_scale (...)
Pixbuf*pixbuf_convolution (...)
voidpixbuf_destroy (...)
uint32_tpixbuf_size (...)
uint32_tpixbuf_width (...)
uint32_tpixbuf_height (...)
pixformat_tpixbuf_format (...)
const byte_t*pixbuf_cdata (...)
byte_t*pixbuf_data (...)
uint32_tpixbuf_format_bpp (...)
uint32_tpixbuf_get (...)
voidpixbuf_set (...)
voidpixbuf_fill (...)
voidpixbuf_fill_rect (...)
voidpixbuf_line (...)
voidpixbuf_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.

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.
  • Fórmula de convolución.
    Fórmula 1: Fórmula 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


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.

❮ Anterior
Siguiente ❯