Trabalhando com imagens em tons de cinza

Este artigo abre o blog Processamento Digital de Imagens em C com o objetivo de oferecer ferramentas simples para manipulação de imagens.

Para os próximos artigos, pretendo abordar tópicos variados sobre processamento de imagens. Em cada trabalho, vou utilizar algoritmos e exemplos de implementações em C visando documentar as minhas experiências e também atender as necessidades reportadas pelos leitores.

O objetivo desse artigo é apresentar duas ferramentas que irei utilizar futuramente: a primeira é um conversor de imagem JPEG para tons de cinza. A segunda ferramenta faz o contrário: converte uma imagem crua (raw em tons de cinza) para JPEG.
Assim, poderemos pegar um JPEG, gerar um arquivo manipulável dessa imagem, fazer alterações e gerar uma nova imagem em JPEG.Para exemplificar o uso destas ferramentas, fiz também um programa que abre uma imagem em raw a aplica um filtro de média.

O código foi testado no Ubuntu 12.04, mas acredito que não será muito difícil recompilar tudo em uma distribuição linux diferente.

Conversão de JPEG para tons de cinza

Para facilitar o trabalho, utilizei a biblioteca libjpeg. Disponibilizei aqui um pacote com os fontes do meu programa.
A biblioteca libjpeg poderá ser instalada no Ubuntu com o seguinte comando:

sudo apt-get install libjpeg-dev

Ao descompactar o arquivo jpeg_tools.tar.bz2, você terá acesso a quatro diretórios: build guardará os arquivos compilados, em src está o código do programa que aplica um filtro de média na imagem em raw, em utils estão os códigos dos conversores para JPEG e em images há uma imagem de exemplo. Para compilar, basta digitar "make".

O arquivo "utils/jpeg2raw.c" é quem faz toda a mágica. A função jpeg_decompress abre um arquivo JPEG no espaço de cores RGB e extrai a luminância (imagem em tons de cinza), que volta para a função main através da struct raw_img. Por fim, a luminância é gravada em um arquivo especificado pelo usuário.

O trexo de código abaixo mostra a conversão de RGB para tons de cinza.

#include <jpeglib.h>
/* ... */
static int jpeg_decompress(const char *file, struct raw_img *raw)
{
        /* ... */
        while (jdec.output_scanline < jdec.image_height) {
                jpeg_read_scanlines(&jdec, row_pointer, 1);
                for (i = 0; i < raw->width * raw->num_comp; i += 3) {
                        r = (float) row_pointer[0][i];
                        g = (float) row_pointer[0][i + 1];
                        b = (float) row_pointer[0][i + 2];
                        /* here convert to grayscale */
                        raw->img[j] = (uint8_t)
                                        (0.2126 * r + 0.7152 * g + 0.0722 * b);
                        j++;
                }
        }
        /* ... */
}

O restante do código é basicamente a configuração do libjpeg para descompactar a imagem em JPEG e a gravação do arquivo em raw.

Conversão de tons de cinza para JPEG

O processo inverso é semelhante e foi implementado no arquivo utils/raw2jpeg.c. A função jpeg_compress recebe uma imagem raw já aberta, faz a compressão para JPEG e salva no arquivo que foi especificado no parâmetro file.

static int jpeg_compress(const char *file, struct raw_img *raw)
{
        struct jpeg_compress_struct cinfo;
        struct jpeg_error_mgr jerr;
        JSAMPROW row_ptr[1];
        FILE* out_jpeg;
        uint8_t *image;
        int row_stride;
        int err;

        err = 0;
        image = raw->img;
        out_jpeg = fopen(file, "w+");
        if (out_jpeg == NULL) {
                printf("Could no open '%s' filen", file);
                err = -1;
                goto error;
        }


        jpeg_create_compress(&cinfo);
        jpeg_stdio_dest(&cinfo, out_jpeg);

        cinfo.image_width = raw->width;
        cinfo.image_height = raw->height;
        cinfo.input_components = IMAGE_NCHANNELS;
        cinfo.in_color_space = JCS_GRAYSCALE;
        cinfo.err = jpeg_std_error(&jerr);
        jpeg_set_defaults(&cinfo);
        jpeg_start_compress(&cinfo, TRUE);
        row_stride = raw->width * IMAGE_NCHANNELS;

        while (cinfo.next_scanline < cinfo.image_height) {
                row_ptr[0] = &image[cinfo.next_scanline * row_stride];
                jpeg_write_scanlines(&cinfo, row_ptr, 1);
        }

        jpeg_finish_compress(&cinfo);
        jpeg_destroy_compress(&cinfo);
        fclose(out_jpeg);

error:
        return err;
}

Como a imagem em raw não guarda informações sobre profundidade de cor e resolução da imagem, neste programa estou assumindo que cada pixel é representado por um byte (uint8_t) e a resolução deverá ser passada como parâmetro.

Resultado das transformações

Para gerar uma imagem em raw e depois converter para JPEG execute os seguintes comandos:

./build/jpeg2raw images/sapo_380x254.jpg images/grayscale.raw
./build/raw2jpeg images/grayscale.raw images/grayscale.jpeg 380 254

A imagem gerada em escala de cinza ficará no diretório images, junto com a imagem original colorida.

Imagem de arquivo pessoal

Filtro de média bidimensional

Como havia dito, fiz um outro programa que aplica um filtro de médias em uma imagem em tons de cinza. O código está em src/mean_filter_2d.c. A função mean_filter_2d aplica um filtro de médias 3x3, ou seja, cada píxel é calculado como a média dos nove pixels mais próximos:

static void mean_filter_2d(uint8_t *in, uint8_t *out, size_t w, size_t h)
{
        uint32_t l;
        uint32_t c;
        uint32_t i;
        uint32_t pix;

        for (l = 1; l < h; l++) {
                for (c = 1; c < w; c++) {
                        i = (l * w) + c;
                        pix = (uint32_t) in[i - w - 1];
                        pix += (uint32_t) in[i - w];
                        pix += (uint32_t) in[i - w + 1];
                        pix += (uint32_t) in[i - 1];
                        pix += (uint32_t) in[i];
                        pix += (uint32_t) in[i + 1];
                        pix += (uint32_t) in[i + w - 1];
                        pix += (uint32_t) in[i + w];
                        pix += (uint32_t) in[i + w + 1];
                        out[i] = (uint8_t) (pix / 9);
                }
        }
}

Este programa recebe como parâmetros uma imagem de entrada (em raw), uma imagem de saída (também em raw) e a resolução da imagem.

Resultado do filtro

Para aplicar o filtro na imagem gerada com o comando anterior e gerar um JPEG da imagem filtrada, digite:

./build/mean_filter_2d images/grayscale.raw images/mean.raw 380 254
./build/raw2jpeg images/mean.raw images/mean.jpeg 380 254

Para simplificar tudo isso, fiz o script run.sh que faz todo esse processo para uma imagem JPEG qualquer.

Nos próximos artigos vou trabalhar com outros tipos de filtros e o primeiro será halftoning.

Se você tem alguma sugestão, deixe um comentário!