imagem.c

/*============================================================================*/
/* MANIPULA��O DE ARQUIVOS BMP                                                */
/*----------------------------------------------------------------------------*/
/* Autor: Bogdan T. Nassu - nassu@dainf.ct.utfpr.edu.br                       */
/*============================================================================*/
/** Este arquivo traz declara��es de um tipo e rotinas para manipula��o de
 * arquivos bmp. Como temos um prop�sito puramente did�tico, apenas um sub-
 * conjunto m�nimo do formato foi implementado. Usamos aqui matrizes alocadas
 * dinamicamente e n�meros de ponto flutuante. Esta n�o � a forma mais eficiente
 * de se trabalhar com imagens, mas procuramos priorizar a clareza e a
 * facilidade de uso. */
/*============================================================================*/

#include <stdlib.h>
#include <stdio.h>
#include <math.h>

#include "imagem.h"
#include "base.h"

/*============================================================================*/

#define MIN(a,b) ((a<b)?a:b)
#define MAX(a,b) ((a>b)?a:b)

unsigned long getLittleEndianULong (unsigned char* buffer);
int leHeaderBitmap (FILE* stream, unsigned long* offset);
int leHeaderDIB (FILE* stream, unsigned long* largura, unsigned long* altura);
int leDados (FILE* stream, Imagem* img);

void putLittleEndianULong (unsigned long val, unsigned char* buffer);
void putLittleEndianUShort (unsigned short val, unsigned char* buffer);
int salvaHeaderBitmap (FILE* stream, Imagem* img);
int salvaHeaderDIB (FILE* stream, Imagem* img);
int salvaDados (FILE* stream, Imagem* img);

/*============================================================================*/
/* FUN��ES DO M�DULO                                                          */
/*============================================================================*/
/** Cria uma imagem vazia.
 *
 * Par�metros: int largura: largura da imagem.
 *             int altura: altura da imagem.
 *             int n_canais: n�mero de canais.
 *
 * Valor de retorno: a imagem alocada. A responsabilidade por desaloc�-la � do
 *                   chamador. */

Imagem* criaImagem (int largura, int altura, int n_canais)
{
	int i, j;
	Imagem* img;

	if (largura <= 0 || altura <= 0 || n_canais <= 0)
    {
        printf ("criaImagem: imagens devem ter altura, largura e n_canais maiores que 0.\n");
        return (NULL);
    }

	img = (Imagem*) malloc (sizeof (Imagem));

	img->largura = largura;
	img->altura = altura;
	img->n_canais = n_canais;

    img->dados = (unsigned int***) malloc (sizeof (unsigned int**) * n_canais); /* Uma matriz por canal. */
	for (i = 0; i < n_canais; i++)
	{
		img->dados [i] = (unsigned int**) malloc (sizeof (unsigned int*) * altura);
		for (j = 0; j < altura; j++)
			img->dados [i][j] = (unsigned int*) malloc (sizeof (unsigned int) * largura);
	}

	return (img);
}

/*----------------------------------------------------------------------------*/
/** Destroi uma imagem dada.
 *
 * Par�metros: Imagem* img: a imagem a destruir.
 *
 * Valor de retorno: nenhum. */

void destroiImagem (Imagem* img)
{
	int i, j;

	for (i = 0; i < img->n_canais; i++)
	{
		for (j = 0; j < img->altura; j++)
			free (img->dados [i][j]);
		free (img->dados [i]);
	}
	free (img->dados);
	free (img);
}

/*----------------------------------------------------------------------------*/
/** Abre um arquivo de imagem dado.
 *
 * Par�metros: char* arquivo: caminho do arquivo a abrir.
 *             int n_canais: n�mero de canais. Deve ser 1 ou 3. Se for 1,
 *               converte a imagem para escala de cinza.
 *
 * Valor de retorno: uma imagem alocada contendo os dados do arquivo, ou NULL
 *                   se n�o for poss�vel abrir a imagem. */

Imagem* abreImagem (char* arquivo, int n_canais)
{
	FILE* stream;
	unsigned long data_offset = 0, largura = 0, altura = 0;
	Imagem* img;

    if (n_canais != 1 && n_canais != 3)
	{
        printf ("abreImagem: so pode abrir imagens com 1 ou 3 canais.\n");
        return (NULL);
	}

	/* Abre o arquivo. */
	stream = fopen (arquivo, "rb");
	if (!stream)
		return (NULL);

	if (!leHeaderBitmap (stream, &data_offset))
	{
		fclose (stream);
		return (NULL);
	}

	if (!leHeaderDIB (stream, &largura, &altura))
	{
		fclose (stream);
		return (NULL);
	}

	/* Pronto, cabe�alhos lidos! Vamos agora colocar o fluxo nos dados... */
	if (fseek (stream, data_offset, SEEK_SET) != 0)
	{
		printf ("abreImagem: erro lendo dados do arquivo.\n");
		fclose (stream);
		return (NULL);
	}

	/* ... e tudo pronto para criar nossa imagem! */
	img = criaImagem (largura, altura, 3);

	/* L� os dados. */
	if (!leDados (stream, img))
	{
		printf ("abreImagem: erro lendo dados do arquivo.\n");
		fclose (stream);
		free (img);
		return (NULL);
	}

	fclose (stream);

	/* Se o chamador espera uma imagem de 1 canal, converte para escala de cinza. */
    if (n_canais == 1)
    {
        int i, j;
        float** ptr_canal0;

        /* Para n�o ficar t�o ineficiente, reaproveita a mem�ria da imagem RGB original. */
        for (i = 0; i < img->altura; i++)
            for (j = 0; j < img->largura; j++) {
                img->dados [0][i][j] = img->dados [0][i][j] * 0.299f + img->dados [1][i][j] * 0.587f + img->dados [2][i][j] * 0.114f;
			}

        /* Modifica a imagem original. */
        ptr_canal0 = img->dados [0];
        for (i = 1; i < img->n_canais; i++)
        {
            for (j = 0; j < img->altura; j++)
                free (img->dados [i][j]);
            free (img->dados[i]);
        }
        img->n_canais = 1;
        free (img->dados);
        img->dados = (float***) malloc (sizeof (float**));
        img->dados [0] = ptr_canal0;
    }

    return (img);
}

/*----------------------------------------------------------------------------*/
/** Salva uma imagem em um arquivo dado.
 *
 * Par�metros: Imagem* img: imagem a salvar.
 *             char* arquivo: caminho do arquivo a salvar.
 *
 * Valor de retorno: 0 se ocorreu algum erro, 1 do contr�rio. */

int salvaImagem (Imagem* img, char* arquivo)
{
	FILE* stream;

	if (img->n_canais != 1 && img->n_canais != 3)
	{
        printf ("salvaImagem: so pode salvar imagens com 1 ou 3 canais.\n");
        return (0);
	}

	/* Abre o arquivo. */
	stream = fopen (arquivo, "wb");
	if (!stream)
		return (0);

	/* Escreve os blocos. */
	if (!salvaHeaderBitmap (stream, img))
	{
		fclose (stream);
		return (0);
	}

	if (!salvaHeaderDIB (stream, img))
	{
		fclose (stream);
		return (0);
	}

	if (!salvaDados (stream, img))
	{
		fclose (stream);
		return (0);
	}

	fclose (stream);
	return (1);
}

/*----------------------------------------------------------------------------*/
/** Cria uma c�pia de uma imagem.
 *
 * Par�metros: Imagem* img: imagem a clonar.
 *
 * Valor de retorno: uma nova imagem, igual � imagem dada. */

Imagem* clonaImagem (Imagem* img)
{
    int i, j, k;
    Imagem* clone = criaImagem (img->largura, img->altura, img->n_canais);

    for (i = 0; i < img->n_canais; i++)
        for (j = 0; j < img->altura; j++)
            for (k = 0; k < img->largura; k++)
                clone->dados [i][j][k] = img->dados [i][j][k];

    return (clone);
}

/*----------------------------------------------------------------------------*/
/** Copia o conte�do de uma imagem para outra.
 *
 * Par�metros: Imagem* in: copia desta imagem...
 *             Imagem* out: ... para esta.
 *
 * Valor de retorno: nenhum. */

void copiaConteudo (Imagem* in, Imagem* out)
{
    int i, j, k;

    if (in->largura != out->largura || in->altura != out->altura || in->n_canais != out->n_canais)
    {
        printf ("ERRO: copiaConteudo: as imagens precisam ter o mesmo tamanho e numero de canais.\n");
        exit (1);
    }

    for (i = 0; i < in->n_canais; i++)
        for (j = 0; j < in->altura; j++)
            for (k = 0; k < in->largura; k++)
                out->dados [i][j][k] = in->dados [i][j][k];
}

/*----------------------------------------------------------------------------*/
/** Redimensionamento por vizinho mais pr�ximo. Simples e barato. Eu nem estou
 * pegando o vizinho mais pr�ximo de verdade, estou truncando para baixo - o
 * resultado � quase o mesmo.
 *
 * Par�metros: Imagem* in: imagem de entrada.
 *             Imagem* out: imagem de sa�da. Deve ter o mesmo n�mero de canais
 *               da imagem de entrada.
 *
 * Valor de retorno: nenhum. */

void redimensionaNN (Imagem* in, Imagem* out)
{
    if (in->n_canais != out->n_canais)
    {
        printf ("ERRO: redimensionaNN: as imagens precisam ter o mesmo numero de canais.\n");
        exit (1);
    }

    float vscale = in->altura / (float) out->altura;
    float hscale = in->largura / (float) out->largura;

    int row, col, channel;
    for (row = 0; row < out->altura; row++)
    {
        int y = (int)(row*vscale);
        for (col = 0; col < out->largura; col++)
        {
            int x = (int)(col*hscale);
            for (channel = 0; channel < out->n_canais; channel++)
                out->dados [channel][row][col] = in->dados [channel][y][x];
        }
    }
}

/*----------------------------------------------------------------------------*/
/** Redimensionamento com interpola��o bilinear.
 *
 * Par�metros: Imagem* in: imagem de entrada.
 *             Imagem* out: imagem de sa�da. Deve ter o mesmo n�mero de canais
 *               da imagem de entrada.
 *
 * Valor de retorno: nenhum. */

void redimensionaBilinear (Imagem* in, Imagem* out)
{
    if (in->n_canais != out->n_canais)
    {
        printf ("ERRO: redimensionaBilinear: as imagens precisam ter o mesmo numero de canais.\n");
        exit (1);
    }

    float vscale = in->altura / (float) out->altura;
    float hscale = in->largura / (float) out->largura;

    int row, col, channel;
    float y, floor_y, peso_t, peso_b;
    float x, floor_x, peso_l, peso_r;
    float peso_tl, peso_tr, peso_bl, peso_br;
    int l, r, t, b;

    for (row = 0; row < out->altura; row++)
    {
        // Calcula os par�metros verticais.
        y = row*vscale-0.5f;
        floor_y = floorf (y);
        t = ((int) floor_y);
        if (t < 0) t = in->altura-1;
        if (t >= in->altura) t = 0;
        b = (t+1)%in->altura;

        peso_b = y - floor_y;
        peso_t = 1 - peso_b;

        for (col = 0; col < out->largura; col++)
        {
            // Calcula os par�metros horizontais.
            x = col*hscale-0.5f;
            floor_x = floorf (x);
            l = ((int) floor_x);
            if (l < 0) l = in->largura-1;
            if (l >= in->largura) l = 0;
            r = (l+1)%in->largura;

            peso_r = x - floor_x;
            peso_l = 1 - peso_r;

            peso_tl = peso_t * peso_l;
            peso_tr = peso_t * peso_r;
            peso_bl = peso_b * peso_l;
            peso_br = peso_b * peso_r;

            for (channel = 0; channel < out->n_canais; channel++)
                out->dados [channel][row][col] = in->dados [channel][t][l] * peso_tl + in->dados [channel][b][l] * peso_bl + in->dados [channel][t][r] * peso_tr + in->dados [channel][b][r] * peso_br;
        }
    }
}

/*============================================================================*/
/* FUN��ES INTERNAS (LEITURA)                                                 */
/*============================================================================*/
/** Pega os 4 primeiros bytes do buffer e coloca em um unsigned long,
 * considerando os bytes em ordem little endian.
 *
 * Par�metros: unsigned char* buffer: l� 4 bytes daqui.
 *
 * Valor de Retorno: um unsigned long com os dados do buffer reorganizados. */

unsigned long getLittleEndianULong (unsigned char* buffer)
{
	return (buffer [3] << 24) | (buffer [2] << 16) | (buffer [1] << 8) | buffer [0];
}

/*----------------------------------------------------------------------------*/
/** L� o header de 14 bytes do formato BMP.
 *
 * Par�metros: FILE* stream: arquivo a ser lido. Supomos que j� est� aberto.
 *             unsigned long* offset: par�metro de sa�da, � o deslocamento dos
 *               dados a partir do in�cio do arquivo.
 *
 * Valor de Retorno: 1 se n�o ocorreram erros, 0 do contr�rio. */

int leHeaderBitmap (FILE* stream, unsigned long* offset)
{
	unsigned char data [14]; /* O bloco tem exatamente 14 bytes. */

	if (fread ((void*) data, 1, 14, stream) != 14)
	{
		printf ("leHeaderBitmap: erro lendo header.\n");
		return (0);
	}

	/* Os 2 primeiros bytes precisam ser 'B' e 'M'. */
	if (data [0] != 'B' || data [1] != 'M')
	{
		printf ("leHeaderBitmap: pode ler apenas formato BM.\n");
		return (0);
	}

	/* Vou pular todo o resto e ir direto para o offset. */
	*offset = getLittleEndianULong (&(data [10]));
	return (1);
}

/*----------------------------------------------------------------------------*/
/** L� o header DIB.
 *
 * Par�metros: FILE* stream: arquivo a ser lido. Supomos que j� est� aberto.
 *             unsigned long* largura: par�metro de sa�da. Largura da imagem.
 *             unsigned long* altura: par�metro de sa�da. Altura da imagem.
 *
 * Valor de Retorno: 1 se n�o ocorreram erros, 0 do contr�rio. */

int leHeaderDIB (FILE* stream, unsigned long* largura, unsigned long* altura)
{
	unsigned long size = 0; /* O tamanho do cabe�alho DIB. */

	if (fread ((void*) &size, 4, 1, stream) != 1)
	{
		printf ("leHeaderDIB: erro lendo header.\n");
		return (0);
	}

	if (size == 12) /* Formato BITMAPCOREHEADER. */
	{
		printf ("leHeaderDIB: BITMAPCOREHEADER nao suportado (arquivo antigo!?)\n");
		return (0);
	}
	else if (size >= 40) /* Outros formatos. */
	{
		unsigned short tmp_short = 0;
		unsigned long tmp_long = 0;

		/* Largura. */
		if (fread ((void*) largura, 4, 1, stream) != 1 || *largura <= 0)
		{
			printf ("leHeaderDIB: largura invalida.\n");
			return (0);
		}

		/* Altura. */
		if (fread ((void*) altura, 4, 1, stream) != 1 || *altura <= 0)
		{
			printf ("leHeaderDIB: altura invalida.\n");
			return (0);
		}

		/* Color planes. Precisa ser 1. */
		if (fread ((void*) &tmp_short, 2, 1, stream) != 1 || tmp_short != 1)
		{
			printf ("leHeaderDIB: erro lendo header.\n");
			return (0);
		}

		/* Bpp. Aqui, estou for�ando 24 bpp. */
		if (fread ((void*) &tmp_short, 2, 1, stream) != 1 || tmp_short != 24)
		{
			printf ("leHeaderDIB: supporta apenas arquivos com 24 bpp.\n");
			return (0);
		}

		/* Compress�o. Vou aceitar s� imagens sem compress�o. */
		if (fread ((void*) &tmp_long, 4, 1, stream) != 1 || tmp_long != 0)
		{
			printf ("leHeaderDIB: suporta apenas arquivos sem compressao.\n");
			return (0);
		}

		/* Pula os pr�ximos 12 bytes. */
		if (fseek (stream, 12, SEEK_CUR) != 0)
		{
			printf ("leHeaderDIB: erro lendo header.\n");
			return (0);
		}

		/* Paleta. N�o � para usar! */
		if (fread ((void*) &tmp_long, 4, 1, stream) != 1 || tmp_long != 0)
		{
			printf ("leHeaderDIB: sem suporte a arquivos com paletas de cores.\n");
			return (0);
		}

		return (1);
	}

	return (0);
}

/*----------------------------------------------------------------------------*/
/** L� os dados de um arquivo.
 *
 * Par�metros: FILE* stream: arquivo a ser lido. Supomos que j� est� aberto.
 *             Imagem* img: imagem a preencher.
 *
 * Valor de Retorno: 1 se n�o ocorreram erros, 0 do contr�rio. */

int leDados (FILE* stream, Imagem* img)
{
	long long i, j, k;
	int line_padding;
	unsigned char data;

	/* Calcula quantos bytes preciso pular no fim de cada linha.
	  Aqui, cada linha precisa ter um m�ltiplo de 4. */
	line_padding = (int) ceil (img->largura*3.0/4.0)*4 - (img->largura*3);

	/* L�! */
	for (i = img->altura-1; i >= 0; i--)
	{
		for (j = 0; j < img->largura; j++)
		{
		    /* L� 3 bytes, na ordem BGR. */
		    for (k = 0; k < 3; k++)
		    {
                if (fread (&data, 1, 1, stream) != 1)
                    return (0);

                img->dados [2-k][i][j] = (unsigned int) data; // 2-k -> 0 = R, 1 = G, 2 = B. Coloca na faixa [0,1]
		    }
		}

		if (fseek (stream, line_padding, SEEK_CUR) != 0)
			return (0);
	}

	return (1);
}

/*============================================================================*/
/* FUN��ES INTERNAS (ESCRITA)                                                 */
/*============================================================================*/
/** Coloca um unsigned long nos 4 primeiros bytes do buffer, em ordem little
 * endian.
 *
 * Par�metros: unsigned long val: valor a escrever.
 *             unsigned char* buffer: coloca o valor aqui.
 *
 * Valor de Retorno: NENHUM */

void putLittleEndianULong (unsigned long val, unsigned char* buffer)
{
	buffer [0] = (unsigned char) val;
	buffer [1] = (unsigned char) (val >> 8);
	buffer [2] = (unsigned char) (val >> 16);
	buffer [3] = (unsigned char) (val >> 24);
}

/*----------------------------------------------------------------------------*/
/** Coloca um unsigned short nos 2 primeiros bytes do buffer, em ordem little
 * endian.
 *
 * Par�metros: unsigned short val: valor a escrever.
 *             unsigned char* buffer: coloca o valor aqui.
 *
 * Valor de Retorno: NENHUM */

void putLittleEndianUShort (unsigned short val, unsigned char* buffer)
{
	buffer [0] = (unsigned char) val;
	buffer [1] = (unsigned char) (val >> 8);
}

/*----------------------------------------------------------------------------*/
/** Escreve o header Bitmap.
 *
 * Par�metros: FILE* file: arquivo a ser escrito. Supomos que j� est� aberto.
 *             Imagem* img: imagem a ser salva.
 *
 * Valor de Retorno: 1 se n�o ocorreram erros, 0 do contr�rio. */

int salvaHeaderBitmap (FILE* stream, Imagem* img)
{
	unsigned char data [14]; /* O bloco tem exatamente 14 bytes. */
	int pos = 0;
	unsigned long bytes_por_linha;

	data [pos++] = 'B';
	data [pos++] = 'M';

	/* Tamanho do arquivo. Definimos como sendo 14+40 (dos cabe�alhos) + o espa�o dos dados. */
	bytes_por_linha = (unsigned long) ceil (img->largura*3.0/4.0)*4;
	putLittleEndianULong (14+40+img->altura*bytes_por_linha, &(data [pos]));
	pos+=4;

	/* Reservado. */
	putLittleEndianULong (0, &(data [pos]));
	pos+=4;

	/* Offset. Definimos como 14+40 (o tamanho dos cabe�alhos). */
	putLittleEndianULong (14+40, &(data [pos]));

	if (fwrite ((void*) data, 1, 14, stream) != 14)
	{
		printf ("salvaHeaderBitmap: erro escrevendo header.\n");
		return (0);
	}

	return (1);
}

/*----------------------------------------------------------------------------*/
/** Escreve o header DIB.
 *
 * Par�metros: FILE* file: arquivo a ser escrito. Supomos que j� est� aberto.
 *             Imagem* img: imagem a ser salva.
 *
 * Valor de Retorno: 1 se n�o ocorreram erros, 0 do contr�rio. */

int salvaHeaderDIB (FILE* stream, Imagem* img)
{
	unsigned char data [40]; /* O bloco tem exatamente 40 bytes. */
	int pos = 0;
	unsigned long bytes_por_linha;

	/* Tamanho do header. Vamos usar um BITMAPINFOHEADER. */
	putLittleEndianULong (40, &(data [pos]));
	pos += 4;

	/* Largura. */
	putLittleEndianULong (img->largura, &(data [pos]));
	pos += 4;

	/* Altura. */
	putLittleEndianULong (img->altura, &(data [pos]));
	pos += 4;

	/* Color planes. */
	putLittleEndianUShort (1, &(data [pos]));
	pos += 2;

	/* bpp. */
	putLittleEndianUShort (24, &(data [pos]));
	pos += 2;

	/* Compress�o. */
	putLittleEndianULong (0, &(data [pos]));
	pos += 4;

	/* Tamanho dos dados. */
	bytes_por_linha = (unsigned long) ceil (img->largura*3.0/4.0)*4;
	putLittleEndianULong (img->altura*bytes_por_linha, &(data [pos]));
	pos += 4;

	/* Resolu��o horizontal e vertical (simplesmente copiei este valor de algum arquivo!). */
	putLittleEndianULong (0xF61, &(data [pos]));
	pos += 4;
	putLittleEndianULong (0xF61, &(data [pos]));
	pos += 4;

	/* Cores. */
	putLittleEndianULong (0, &(data [pos]));
	pos += 4;
	putLittleEndianULong (0, &(data [pos]));
	pos += 4;

	if (fwrite ((void*) data, 1, 40, stream) != 40)
	{
		printf ("salvaHeaderDIB: erro escrevendo header.\n");
		return (0);
	}

	return (1);
}

/*----------------------------------------------------------------------------*/
/** Escreve o bloco de dados.
 *
 * Par�metros: FILE* file: arquivo a ser escrito. Supomos que j� est� aberto.
 *             Imagem* img: imagem a ser salva.
 *
 * Valor de Retorno: 1 se n�o ocorreram erros, 0 do contr�rio. */

int salvaDados (FILE* stream, Imagem* img)
{
    unsigned char dado;
	long long i, j, k;
	unsigned long largura_linha, line_padding;
	unsigned char* linha;
	unsigned long pos_linha;

	/* Calcula quantos bytes preciso pular no fim de cada linha.
	  Aqui, cada linha precisa ter um m�ltiplo de 4. */
	largura_linha = (unsigned long) ceil (img->largura*3.0/4.0)*4;
	line_padding = largura_linha - (img->largura*3);
	linha = (unsigned char*) malloc (sizeof (unsigned char) * largura_linha);

    for (i = img->altura-1; i >= 0; i--)
	{
		pos_linha = 0;
		for (j = 0; j < img->largura; j++)
		{
		    /* Imagem de 3 canais: converte para uchar na ordem BGR. */
		    if (img->n_canais == 3)
		    {
		        for (k = 0; k < 3; k++)
		            linha [pos_linha++] =  (img->dados [2-k][i][j]);
		    }
		    else /* Imagem de 1 canal: converte para uchar e replica 3 vezes. */
		    {
		        dado =  (img->dados [0][i][j]);
                for (k = 0; k < 3; k++)
                    linha [pos_linha++] = dado;
            }
		}

		for (j = 0; j < line_padding; j++)
			linha [pos_linha++] = 0;

		if (fwrite ((void*) linha, 1, largura_linha, stream) != largura_linha)
		{
			printf ("salvaDados: errro escrevendo dados da imagem.\n");
			free (linha);
			return (0);
		}
	}

	free (linha);
	return (1);
}

/*============================================================================*/