Manual de Funes - OpenCV 2.

3
Escrito por: Lucas Grassano Lattari (llattari@ic.uff.br)
IplImage* img:
Estrutura de dados do tipo imagem utilizada pelo OpenCV. um
struct (registro) da linguagem C que consta de uma srie de
informaes.
typedef struct _IplImage
{
int nSize;
int ID;
int nChannels;
int alphaChannel;
int depth;
char colorModel[4];
char channelSeq[4];
int dataOrder;
int origin;
int align;
int width;
int height;
struct _IplROI *roi;
struct _IplImage *maskROI;
void *imageId;
struct _IplTileInfo *tileInfo;
int imageSize;
char *imageData;
int widthStep;
int BorderMode[4];
int BorderConst[4];
char *imageDataOrigin;
}
IplImage;

//nmero de canais de cores

//nmero de bits por canal

//largura da imagem
//altura da imagem

//tamanho dos dados de cores em bytes

//os dados de cores propriamente ditos
//tamanho de uma linha em bytes

Apesar de ser um registro com uma grande quantidade de variveis,

a grande maioria delas so ignoradas pelo OpenCV ou utilizadas em
aplicaes muito especficas. As que sero utilizadas mais
frequentemente nesse curso sero: o nmero de canais de cores
(nChannels), profundidade de pixels em bits (depth), altura e largura
(height e width respectivamente), tamanho de uma linha alinhada em
bits (widthStep) etc. Finalmente, o acesso s cores feita no vetor
imageData.

O exemplo abaixo mostra como possvel imprimir na tela essas

informaes.
Exemplo 1. Carregando imagem na estrutura IplImage* e apresentando informaes
sobre ela na tela. A imagem deve estar na mesma pasta em que se encontra o executvel
gerado pelo cdigo.
//necessrios para executar o openCV
#include <opencv.hpp>
using namespace cv;
int main ( int argc, char **argv )
{
//nome da imagem
string filename = "lena.bmp";
//carrega imagem dentro da estrutura de dados imagem
IplImage* im = cvLoadImage(filename.c_str());
//nmero de canais de cores
printf("Essa imagem possui %d canais de cores.\n", im->nChannels);
//nmero de canais de cores
printf("As dimensoes dessa imagem sao: %d x %d.\n", im->width, im>height);

um

um

um

um

um

um

um

//profundidade
if(im->depth == IPL_DEPTH_8U)
printf("Alem disso, possui 8 bits por canal, representados por
inteiro sem sinal (unsigned).\n");
else if(im->depth == IPL_DEPTH_8S)
printf("Alem disso, possui 8 bits por canal, representados por
inteiro com sinal (signed).\n");
else if(im->depth == IPL_DEPTH_16U)
printf("Alem disso, possui 16 bits por canal, representados por
inteiro sem sinal (unsigned).\n");
else if(im->depth == IPL_DEPTH_16S)
printf("Alem disso, possui 16 bits por canal, representados por
inteiro com sinal (signed).\n");
else if(im->depth == IPL_DEPTH_32S)
printf("Alem disso, possui 32 bits por canal, representados por
inteiro com sinal (signed).\n");
else if(im->depth == IPL_DEPTH_32F)
printf("Alem disso, possui 32 bits por canal, representados por
nmero de ponto flutuante (float).\n");
else if(im->depth == IPL_DEPTH_64F)
printf("Alem disso, possui 64 bits por canal, representados por
nmero de ponto flutuante (float).\n");
//desaloca a imagem
cvReleaseImage(&im);
//para o aplicativo no encerrar enquanto uma tecla no for pressionada
cvWaitKey(0);
return 0;

 Criar uma imagem com OpenCV - cvCreateImage(cvSize size, int

depth, int channels)
A funo cvCreateImage aloca uma nova imagem que poder ser
manuseada, salva em disco ou exibida imediatamente na tela. Essa
funo recebe trs parmetros, que respectivamente so: altura e
largura (estrutura cvSize), profundidade em bits e canais por pixel.
//aloca imagem monocromtica de 640x480 com 1 byte por canal
IplImage* imagem1 = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 1);
//aloca imagem de 1024x768 de 3 canais com 4 bytes por canal
IplImage* imagem2 = cvCreateImage(cvSize(1024, 768), IPL_DEPTH_32F, 3);

Carregar uma imagem com OpenCV - cvLoadImage(const char*

filename, int iscolor)
Utilizada para carregar uma imagem em disco para o OpenCV. Ela
suporta a grande maioria dos formatos, como BMP, DIB, JPG, JPEG,
PNG, PBM, TIFF etc. O primeiro parmetro uma string pro endereo e
nome do arquivo fsico da imagem. O segundo parmetro recebe uma
constante que fora a maneira como a imagem carregada: se tem
que possuir trs canais (CV_LOAD_IMAGE_COLOR), monocromtica
(CV_LOAD_IMAGE_GRAYSCALE) ou da maneira em que est
(CV_LOAD_IMAGE_UNCHANGED). Se o segundo parmetro no for
passado, por padro ele tenta carregar a imagem colorida.
//nome da imagem
string filename = "lena.bmp";
//carrega a imagem como monocromtica
IplImage* mono = cvLoadImage(filename.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
//carrega outra imagem mas colorida
IplImage* color = cvLoadImage(filename.c_str(), CV_LOAD_IMAGE_COLOR);

Desaloca uma imagem com OpenCV - cvReleaseImage(IplImage* i)

Sempre que uma nova imagem for alocada (cvCreateImage) ou
carregada (cvLoadImage) ela deve ser desalocada, a fim de que esses
recursos fiquem disponveis para uso novamente. Para isso, basta

passar por parmetro um ponteiro para a estrutura IplImage utilizada

(ponteiro de ponteiro).
//aloca imagem monocromtica de 640x480 com 1 byte por canal
IplImage* imagem1 = cvCreateImage(cvSize(640, 480), IPL_DEPTH_8U, 1);
//desaloca a imagem alocada
cvReleaseImage(&imagem1);

Exibe uma imagem na tela cvShowImage(const char* name,

IplImage* i)
Essa funo faz parte do mdulo de interface grfica do OpenCV.
Com ela, possvel exibir uma imagem que esteja sendo manipulada
pelo OpenCV diretamente na tela. Mas para isso, necessrio invocar
outra funo antes (cvNamedWindow), que cria uma janela grfica,
conforme o exemplo.
Ao criar uma janela utilizando cvNamedWindow, passado por
parmetro o nome da mesma. Esse mesmo nome ser o parmetro
para cvShowImage, para que seja identificada a janela que ter a
imagem mostrada. O segundo parmetro a imagem a ser mostrada.
//nome da imagem
string filename = "lena.bmp";
//carrega a imagem como monocromtica
IplImage* imagem = cvLoadImage(filename.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
//cria uma janela, passando seu nome como parmetro
cvNamedWindow("Principal");
//mostra imagem na tela, passando o nome da janela e uma referncia pra
imagem
cvShowImage("Principal", imagem);

Salva uma imagem em disco cvSaveImage(const char* name,

IplImage* i)
De maneira parecida com a funo anterior, os parmetros so
idnticos. Mas ao invs de exibir uma imagem na tela, esse
procedimento tem como objetivo salvar uma imagem em disco. O

primeiro parmetro o endereo e o nome da imagem a ser salva, e o

segundo a estrutura de dados que referencia a imagem a ser salva.
//carrega a imagem como monocromtica
IplImage* imagem = cvLoadImage(filename.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
//salva imagem
cvSaveImage("lenaBlackAndWhite.bmp", imagem);

Espera por um comando do teclado cvWaitKey(int delay)

Essa funo aguarda por um comando do teclado feito pelo usurio
e retorna a tecla pressionada em padro ASCII. Ela utilizada no
apenas para fazer um programa com tratamento de eventos elaborado
pelo usurio, mas tambm para exibir uma imagem na tela
indefinidamente, at que o usurio encerre o aplicativo.
O parmetro da funo um tempo em milissegundos que o
aplicativo aguarda o comando. Se nenhum parmetro for passado, ele
aguarda indefinidamente. Recomenda-se o seu uso para as aplicaes
do curso.
//carrega a imagem como monocromtica
IplImage* imagem = cvLoadImage(filename.c_str(), CV_LOAD_IMAGE_GRAYSCALE);
//cria uma janela
cvNamedWindow("Principal");
//mostra imagem na tela
cvShowImage("Principal", imagem);
//para o aplicativo no encerrar enquanto uma tecla no for pressionada
cvWaitKey(0);

Outros exemplos mais elaborados:

Exemplo. Limiarizao global simples de uma imagem, modificando para o tom branco
todo pixel que possuir algum canal de cor maior do que 100. Caso contrrio, o tom
transformado em preto.
//necessrios para executar o openCV
#include <opencv.hpp>
using namespace cv;
int main ( int argc, char **argv )
{

//nome da imagem
string filename = "lena.bmp";
//carrega imagem dentro da estrutura de dados imagem
IplImage* im = cvLoadImage(filename.c_str());
//ponteiro para as cores da imagem
unsigned char* colorData = (unsigned char*)im->imageData;
//para cada pixel da imagem carregada
for(int i = 0 ; i < im->width * im->height * 3 ; i += 3)
{
//para cada coordenada RGB, se um determinado canal estiver com
tom acima de 100
if(colorData[i] > 100 || colorData[i + 1] > 100 || colorData[i +
2] > 100)
{
//transformar pixel em branco
colorData[i]
= 255;
colorData[i + 1]
= 255;
colorData[i + 2]
= 255;
}else
{
//transformar pixel em preto
colorData[i]
= 0;
colorData[i + 1]
= 0;
colorData[i + 2]
= 0;
}
}
//cria uma janela
cvNamedWindow("Principal", CV_WINDOW_AUTOSIZE);
//mostra imagem na tela
cvShowImage("Principal", im);
//para o aplicativo no encerrar enquanto uma tecla no for pressionada
cvWaitKey(0);
//libera os recursos usados pela imagem
cvReleaseImage(&im);
return 0;
}

Exemplo. Programa que realiza alguns clculos estatsticos, tais como: mdia,
varincia, histograma de uma imagem colorida.
//necessrios para executar o openCV
#include <opencv.hpp>
using namespace cv;
int main ( int argc, char **argv )
{
//nome da imagem
string filename = "lena.bmp";
//carrega imagem dentro da estrutura de dados imagem
IplImage* im = cvLoadImage(filename.c_str());

//ponteiro para as cores da imagem

unsigned char* colorData = (unsigned char*)im->imageData;
//clculo da mdia de cores de uma imagem
float mediaRed, mediaGreen, mediaBlue;
mediaRed = mediaGreen = mediaBlue = 0.f;
//para cada pixel da imagem carregada
for(int i = 0 ; i < im->width * im->height * 3 ; i += 3)
{
mediaBlue
+= colorData[i];
mediaGreen
+= colorData[i + 1];
mediaRed
+= colorData[i + 2];
}
mediaBlue
/= im->width * im->height;
mediaGreen
/= im->width * im->height;
mediaRed
/= im->width * im->height;
printf("Media das cores por canal:\n");
printf("Vermelho = %f\n", mediaRed);
printf("Verde = %f\n", mediaGreen);
printf("Blue = %f\n", mediaBlue);
printf("\n");
//clculo da varincia de cores de uma imagem
float varianciaRed, varianciaGreen, varianciaBlue;
varianciaRed = varianciaGreen = varianciaBlue = 0.f;
for(int i = 0 ; i < im->width * im->height * 3 ; i += 3)
{
varianciaBlue
+= (colorData[i] - mediaBlue)
(colorData[i] - mediaBlue);
varianciaGreen
+= (colorData[i + 1] - mediaGreen)
(colorData[i + 1] - mediaGreen);
varianciaRed
+= (colorData[i + 2] - mediaRed)
(colorData[i + 2] - mediaRed);
}
varianciaBlue
/= im->width * im->height;
varianciaGreen
/= im->width * im->height;
varianciaRed
/= im->width * im->height;
printf("Variancia das cores por canal:\n");
printf("Vermelho = %f\n", varianciaRed);
printf("Verde = %f\n", varianciaGreen);
printf("Blue = %f\n", varianciaBlue);
printf("\n");
//clculo de histograma
int histogramaRed[256];
int histogramaGreen[256];
int histogramaBlue[256];
//funo que inicializa cada posio dos vetores com 0
memset(histogramaRed, 0, sizeof(int) * 256);
memset(histogramaGreen, 0, sizeof(int) * 256);
memset(histogramaBlue, 0, sizeof(int) * 256);
//para cada pixel da imagem carregada
for(int i = 0 ; i < im->width * im->height * 3 ; i += 3)
{
histogramaBlue[colorData[i]]++;
histogramaGreen[colorData[i + 1]]++;

*
*
*

histogramaRed[colorData[i + 2]]++;
}
//computa a moda pra cada canal (cor que aparece com mais frequncia)
int modaRed, modaGreen, modaBlue, maiorRed, maiorGreen, maiorBlue;
modaRed = modaGreen = modaBlue = 0;
maiorRed
= histogramaRed[0];
maiorGreen
= histogramaGreen[0];
maiorBlue
= histogramaBlue[0];
for(int i = 1 ; i < 256 ; i++)
{
if(maiorRed < histogramaRed[i])
{
maiorRed
= histogramaRed[i];
modaRed
= i;
}
if(maiorGreen < histogramaGreen[i])
{
maiorGreen
= histogramaGreen[i];
modaGreen
= i;
}
if(maiorBlue < histogramaBlue[i])
{
maiorBlue
= histogramaBlue[i];
modaBlue
= i;
}
}
printf("Moda para cada canal: \n");
printf("Vermelho = %d\n", modaRed);
printf("Verde = %d\n", modaGreen);
printf("Azul = %d\n", modaBlue);
printf("\n");
//cria um arquivo de texto e escreve o histograma
FILE* f = fopen("histograma.txt", "w+");
fprintf(f, "Canal vermelho: \n");
for(int i = 0 ; i < 256 ; i++)
fprintf(f, "%d ", histogramaRed[i]);
fprintf(f, "\n");
fprintf(f, "Canal verde: \n");
for(int i = 0 ; i < 256 ; i++)
fprintf(f, "%d ", histogramaGreen[i]);
fprintf(f, "\n");
fprintf(f, "Canal azul: \n");
for(int i = 0 ; i < 256 ; i++)
fprintf(f, "%d ", histogramaBlue[i]);
fprintf(f, "\n");
//fecha arquivo
fclose(f);
//cria uma janela
cvNamedWindow("Principal", CV_WINDOW_AUTOSIZE);
//mostra imagem na tela
cvShowImage("Principal", im);
//para o aplicativo no encerrar enquanto uma tecla no for pressionada
cvWaitKey(0);

//libera os recursos usados pela imagem

cvReleaseImage(&im);
return 0;
}