computação gráfica - 2011

Prof Kesede R Julio

Prof Kesede R [email protected]

Apostila de

Computação Gráfica

e

Processamento de Imagem

versão 2011

Computação Gráfica e Processamento de Imagem 1

Prof Kesede R Julio

ÍndiceCapítulo 1.Introdução..............................................................................................................3

1.1.Breve Histórico 31.2.Contextualização 71.3Aplicações 71.4Dispositivos Gráficos 81.5Resolução Gráfica 91.6Sistemas de Coordenadas 101.1Exercícios 11

Capítulo 2.Conversão Matricial de Curvas...........................................................................132.1.Objetivo 132.2Primitivas de Saída Gráfica 132.3.Algoritmo de Ponto Médio (Bresenham)242.1. Exercícios 30

Capítulo 3.Transformações Geométricas..............................................................................313.1Transformações 2D 31 3.2 Laboratório TG 2D em MatLab 33 3.1 Transformações 3D 37 3.4 Coordenadas Homogêneas 38 3.5 Composição de Transformações 40

Capítulo 4.Modelagem Geométrica......................................................................................42 4.1 Wireframe 45 4.2 Instanciamento Primitivo 454.3 Varredura 464.4 Decomposição 464.5 GSC – Geometria Sólida Construtiva 474.6 Fronteira 48

Capítulo 5 Curvas e Superfícies..........................................................................................50Capítulo 5 .1 Curvas.............................................................................................................50Capítulo 6.Fundamentos de Cor............................................................................................55

6.1 Conceitos Básicos 556.2.Sistemas de Cores Primárias 56

Capítulo 7 Processamento de Imagem.................................................................................58 7.1 Representação Digital de Imagem 58 7.2 Quantização 61 7.3 Amostragem 667.4.Histograma 687.5.Thresholding 69 5.6 Filtros 72 5.7 Morfologia Matemática 77 5.8 Estudo de Casos 82 5.9 Reconhecimento de Padrões 86


Prof Kesede R Julio

1.Introdução

1.1.Breve Histórico

A história da Computação Gráfica (CG) remonta a história dos

computadores. Daremos, no entanto, um breve histórico de como tudo começou.

1950-1960 :- Primeiros pontos, linhas e figuras visualizadas em tubos de raio

catódicos (CRT).

1960-1970 :- Primeiros jogos utilizando CG: SpaceWar (1961 - estudantes do

MIT), Odyssey (primeiro video game comercial). É fundada a “Evans &

Sutherland”, primeira empresa de CG da história. Em 1968, o primeiro comercial

de televisão utilizando gráficos vetoriais. Primeiros simuladores de Realidade

Virtual (RV).


Prof Kesede R Julio

Espaço – Restart

P - Pause

Ação Nave Gorda

Nave Magra

Atira

Acelera

Gira sentido horário

Gira sentido anti-horário

V

C

X

Z

.

,

M

N

SpaceWars- Além de ter sido o primeiro jogo eletrônico, foi também a primeira simulação de computador a exibir uma representação gráfica. Desenvolvido em 1961, no MIT, por um hacker chamado "Slug" Russell, funcionava num computador do tipo mainframe, o PDP-1, da empresa DEC.

Ano de lançamento: 1961Instituto: MITGênero: Arcade (?)Gráfico: Duas coresSom: NenhumComportamento: Regras

1970-1980 :- Os jogos tornam-se o centro das atenções comerciais. Grande uso

da CG em filmes tendo como principal estrela, Star Wars (1977).

Pong: Primeiro game a ter uma distribuição de massa, o Pong foi inspirado no osciloscópio, um instrumento eletrônico que permite observar sinais elétricos num tubo de raios catódicos, como a TV e as telas de computador. Depois que a General Instruments lançou o primeiro chip barato, foi possível construir um sistema completo de Pong com poucos componentes externos. Uma indústria inteira foi criada e centenas de fabricantes lançaram sua própria linha do produto.

Ano de lançamento: 1972Empresa: AtariGênero: ArcadeGráfico: Duas coresSom: 1 bitComportamento: Regras

1980-1990 :- Surgiram os computadores domésticos com interface gráfica.

Aumento significativo do uso de CG em filmes de Holywood, videoclipes (Dire

Straits-1985), curta-metragens de animação digital.


Prof Kesede R Julio

IBM PC™ (Personal Computer), is a trade mark of IBM. The predecessor of the current personal computers and progenitor of the IBM PC compatible hardware platform, it was introduced in August 1981. The original model was designated the IBM 5150. It was created by a team of 12 engineers and designers under the direction of Don Estridge of the IBM Entry Systems Division. The introduction of the PC changed the world of IBM in 1981.

1990-2000 :- Grandes produções cinematográficas usando CG (Jurrassic Park,

Independence Day, Godzilla, Men in Black etc). Primeiro longa-metragem de

animação digital (Cassiopéia (Brasil), Toy Story(EUA)).


http://en.wikipedia.org/wiki/Don_Estridge

http://en.wikipedia.org/wiki/1981

http://en.wikipedia.org/wiki/Platform_(computing)

http://en.wikipedia.org/wiki/IBM_PC_compatible

http://en.wikipedia.org/wiki/IBM_PC_compatible

http://en.wikipedia.org/wiki/International_Business_Machines

http://en.wikipedia.org/wiki/Trade_mark

Prof Kesede R Julio

Cassiopédia – 1992 - Primeiro longa-metragem totalmente computadorizado

Toy Story – 1995 – Primeira animação longa-metragem totalmente computadorizada feita pela Disney. Diferentemente do Cassiopéia, usaram massas como modelos.

2000-atual :- Tendência na produção de “atores digitais” (Aki Ross em Final

Fantasy). Biometria. RV.

Atores Digitais. Dr. Aki Ross é a atriz digital do filme “Final Fantasy” produzido em 2001. Ela é a primeira atriz fotorealística gerada por computador.

Biometria. O uso de biometria digital na Disney World.


Prof Kesede R Julio

Realidade Virtual. O modelo de uma rua da cidade de Nova York.

1.2.Contextualização

1.3Aplicações

As aplicações de CG são inúmeras e eu diria até infinitas, as possibilidades. Indo desde a área médica, passando pelo entretenimento e chegando as indústrias. Podemos citar algumas destas aplicações, como: medicina, animação digital, simulação visual, multimídia na web etc

1.4Dispositivos Gráficos

Os dispositivos gráficos se dividem em dois: Vetorial e Matricial.

Os Vetoriais se utilizam de um tipo de varredura chamada “Randon Scan”, que significa que os desenhos são apresentados aleatoriamente, ou seja, apenas os pontos que representarão a figura são acessados. Este processo se utiliza de um “Display List” armazenado na memória, o qual armazena todos os comandos e informações (coordenadas x,y) para o desenho das figuras. O


ModelagemGeométrica

Síntese de Imagens

Análise de Imagens

Processamento de Imagens

DADOS

IMAGENS

Computação Gráfica

Visão Computacional

Prof Kesede R Julio

principal problema destes dispositivos é que a permanencia da figura é de aproximadamente 40 microsegundos apenas, por isso esta lista (Display List) deve ser acessada várias vezes, afim de executar o “refresh” e manter a figura sendo exibida por mais tempo. Quando o tempo de refresh é maior que a persistência do fósforo (elemento químico que é aceso em cada ponto do dispositivo) temos o que chamamos de “flickering” (piscada) de tela. É quase impossível para estes dispositivos o preenchimento de áreas. Abaixo vemos um exemplo do desenho de um triângulo.

Já os Matriciais se utilizam de uma técnica de rastreamento chamada “Raster Scan”, onde todas as posições endereçaveis do dispositivo são percorridas (de cima para baixo e da esquerda para direita). A medida que há o rastreamento a figura é desenhada nas posições onde se encontram. Todo o display é armazenado através de uma matriz de pixels (pontos do video) em um frame buffer (memória de video), por isso não há “Display List”, ficando muito mais fácil a execução do refresh. Um grande problema deste tipo de dispositivo é o desenho de linhas, principalmente quando fora dos eixos simétricos. Apesar deste problema, estes dispositivos se tornaram populares com o evento dos computadores domésticos em meados de 1980, devido a grande redução de custo das memórias e apesar dos dispositivos Randon Scan terem melhor resolução que os Raster Scan. A figura abaixo mostra um exemplo de Raster Scan.


Prof Kesede R Julio

A qualidade de um dispositivo raster é dada por vários fatores inerentes as suas dimensões físicas e gráficas.

1.5Resolução Gráfica

Todos os dispositivos gráficos possuem uma grade (matriz) lógica capaz de endereçar cada uma de suas intersecções e, assim, representar pontos de visualização. Ao número de pontos endereçáveis na vertical e na horizontal damos o nome de resolução gráfica. Existem 4 parâmetros básicos para o cálculo desta resolução:

NDH -> número de posições (dots) endereçáveis horizontalmente

NDV -> número de posições endereçáveis verticalmente

WIDTH -> largura física (em milímetros) da área endereçável

HEIGHT -> altura física (em milímetros) da área endereçável

Através destes valores podemos conhecer algumas características importantes dos dispositivos.

Resolução Horizontal -> ResHoriz = NDH/WIDTH

Tamanho do ponto na horizontal -> TamPtHoriz = WIDTH/NDH

Resolução Vertical -> ResVert = NDV/HEIGTH

Tamanho do ponto na vertical -> TamPtVert = HEIGTH/NDV

Total de pontos endereçaveis -> NDV*NDH

Aspect Ratio Gráfico -> AspRatGraf -> TamPtVert/TamPtHoriz

Aspect Ratio Físico -> AspRatFis -> HEIGTH/WIDTH


Prof Kesede R Julio

1.6Sistemas de Coordenadas

1.6.1.Coordenada de Dispositivo

Quando uma imagem é visualizada em um dispositivo, um modelo do mundo real está ali sendo representado. Bem, ambientes diferentes, coordenadas diferentes. Toda visualização em qualquer dispositivo deve ser dimensionada e posicionada de acordo com as dimensões do próprio dispositivo, localização da imagem no visor e claro, do zoom de imagem que se pretende aplicar. Tudo isso requer transformações e conversões nas medidas reais daquilo que se quer representar. Verificaremos agora, como transformar medidas do mundo real para medidas de dispositivo. A visualização em dispositivos gráficos matriciais é realizada através de uma matriz de pixels, Cada pixel possui uma coordenada x,y, onde x e y são números inteiros (pois não conseguimos endereçar meio pixel). Portanto:

0 ≤ dcx ≤ ndhm1

0 ≤ dcy ≤ ndvm1

Onde:

dcx -> coordenada x (coluna) do dispositivo

dcy -> coordenada y (linha) do dispositivo

ndhm1 -> numero de pontos(dots) na horizontal menos 1

ndvm1 -> numero de pontos(dots) na vertical menos 1

Devemos considerar que o primeiro pixel endereçável (0,0) está no canto inferior esquerdo do retângulo de visualização.

1.6.2Coordenadas Normalizadas

Devido a grande variedade de dispositivos existentes e cada um ter a sua representação de coordenadas, o uso das coordenadas normalizadas de dispositivos (NDC) tornaram-se imprescindíveis. Estas coordenadas variam de 0 a 1. Logo:

0 ≤ ndcx ≤ 1

0 ≤ ndcy ≤ 1

Onde:

ndcx -> coordenada de dispositivo normalizada x

ndcy -> coordenada de dispositivo normalizada y

Considere que a posição NDC(0,0) corresponde a DC(0,0) e NDC(1,1) corresponde a DC(ndhm1,ndvm1).

A transformação das coordenadas do mundo em coordenadas normalizadas, faz com que a discussão de posicionamento fique independente do dispositivo de


Prof Kesede R Julio

visualização. Claro que quando do momento da visualização estas coordenadas devem ser transformadas para dispositivo. Portanto:

dcx=round(ndcx.ndhm1)

dcy=round(ndcy.ndvm1)

1.6.3Coordenada Física ou do Objeto

Neste caso, cada objeto a ser representado, torna-se seu próprio sistema de coordenada. Suas medidas podem ser dadas em milímetros ou polegadas. Sua representação é dada por PC(pcx,pxy), onde:

pcx -> é a distância física ao longo do eixo x a partir do extremo esquerdo do retângulo de visualização até a posição em referência.

pcy -> é a distância física ao longo do eixo y a partir do extremo inferior do retângulo de visualização até a posição em referência.

A transformação de PC para DC é dada por:

dcx = trunc(ndhm1. (pcx/width))

dcy = trunc(ndvm1. (pcy/heigth))

Repare que a divisão retorna um valor em percentual a ser multiplicado pela quantidade de pontos endereçáveis, tanto na horizontal quanto na vertical. O valor deve ser truncado, pois a medida em milímetros deve ser convertida em pixel.

1.6.4Coordenada do Usuário ou do mundo

Tem seus limites e unidade de medida definidos pelo usuário, ou seja, dependerão da aplicação. Para fins de exercícios consideraremos uma representação no plano cartesiano. Será representado por UC(x,y).

xmin ≤ x ≤ xmax

ymin ≤ y ≤ ymax

ndcx = (x-xmin) / (xmax-xmin)

ndcy = (y-ymin) / (ymax-ymin)

Note que no denominador temos a medida exata da janela (horizontal e vertical) e no numerador temos a distância do ponto inicial da janela até o ponto que queremos converter. O resultado desta divisão é uma proporção, bem próprio da coordenada normalizada.

1.1Exercícios


Prof Kesede R Julio

1.1.1.Faça uma pesquisa sobre 3 diferentes aplicações de CG, diferentes das apresentadas anteriormente. Defina qual a área específica (Visão Computacional, Processamento de Imagem etc) de cada aplicação, exemplificando com imagens, videos etc.

1.1.2.Faça uma pesquisa das características de resolução de 3 modelos diferentes de fabricantes diferentes e mostre um relatório da sua pesquisa.

1.1.3.Escreva funções (em qualquer linguagem) de todas as conversões possíveis de coordenadas. Crie um pequeno aplicativo que se utilize destas funções.


Prof Kesede R Julio

2.Conversão Matricial de Curvas

Um estudo das técnicas para implementação de algoritmos de conversão Matricial (Scan Converting Algorithms ) de curvas de um modo geral (linhas, circunferências, elipses).

2.1.Objetivo

Quais pixels devem ser alterados para garantir uma visualização contínua de linhas, curvas e objetos.

2.2Primitivas de Saída Gráfica

• Procedimentos que tomam a coordenada de entrada, e invocam algoritmos de display para construir uma forma geométrica em localizações designadas em um dispositivo de saída.

• Os componentes geométricos mais simples de um quadro são pontos e linhas. Outros tipos de primitivas de saída são áreas poligonais, figuras curvas e linhas de caracteres. Para cada tipo de primitiva de saída, consideramos as técnicas básicas e algoritmos para mostrar as primitivas em diferentes tipos de sistemas gráficos, tais como sistemas vetoriais e raster.

• A plotagem de pontos é implementada num pacote gráfico pela conversão das coordenadas de informação de um programa de aplicações com instruções para o equipamento de saída em uso.

2.2.1Desenho de linhas

Equação da reta: y = m.x + b


Ilustração 2Reflexão sem deformaçãoIlustração 1Eixos de Simetria

Prof Kesede R Julio

onde:

m é a inclinação da linha (coeficiente angular) e

b a interceptação de y (coeficiente linear).

Dados dois pontos (x1, y1) e (x2, y2), temos:

m = (y2 – y1 )/(x2 – x1) = D y / D x

b = y1 – m . x1

b = y1 – (D y / D x ) . x1

Afim de escolher qual pixel plotar quando do traçado de uma reta, podemos levar em consideração vários critérios de escolha. Estudaremos estes critérios a partir de um modelo de reta localizado no primeiro octante (0o < inclinação < 45o). Por isso, não teremos problemas em escolher a coordenada x, a qual será sempre escolhido a cada intersecção, porém a coordenada y exige um estudo de critérios, os quais possuem vantagens e desvantagens.

Critério 1 :- Seleciona-se o pixel imediatamente abaixo e acima do ponto de intersecção do segmento em cada vertical, exceto quando o ponto de intersecção coincide com um pixel (ponto endereçável). Problemas: linhas densas

Critério 2 :- Seleciona-se o pixel através do arredondamento do valor da coordenada. Problemas: com segmentos no ponto médio da vertical, cria-se linhas densas.

Critério 3 :- Seleciona-se o pixel mais próximo do ponto de intersecção do segmento com o eixo vertical. Vantagens: aparência leve e continuidade

Critério 4 :- Seleciona-se o pixel mais próximo do ponto de intersecção do segmento com o eixo horizontal. Problemas: descontinuidade


x

y

x1

x2

y1

y2

Prof Kesede R Julio

Características de um bom conversor.

1. Linearidade:- aparência de reta

2. Precisão:- Evitar gaps no início ou final do segmento

3. Espessura uniforme:- Intensidade e espessura constante em todo o segmento

4. Intensidade independente da inclinação:- no caso de segmentos com diferentes inclinações

5. Continuidade:- Segmento sem interrupção (gaps internos)

6. Rapidez no traçado dos segmentos:- Velocidade ótima em qualquer inclinação.

De todos os critérios que estudamos, o terceiro critério nos parece a melhor solução.

Seja um segmento de reta definido por seus extremos P(x1, y1) e P(x2, y2).

Supondo que este segmento se encontra no primeiro octante, vale as relações:

0 < x1 < x2

0 < y1 < y2

y2 - y1 < x2 - x1


Prof Kesede R Julio

Nestas condições o segmento corta um maior numero de verticais que horizontais

Exemplos de resultados pelo critério 3

Neste estudo estamos desconsiderando:

• Linhas grossas e estilos diferentes

• Cantos de polígonos arredondados

Afim de exercitarmos o que vimos, segue abaixo o código em C que implementa a teoria, utilizando biblioteca Allegro e outro exemplo usando a biblioteca OpenGL.

Equação da reta: y=y1+m (x-x1)

Onde: m = (y2-y1) / (x2-x1)

Exemplo 2.1: Este código traça qualquer linha no primeiro octante. Estaremos usando a biblioteca Allegro instalada no Dev-Cpp. Nas opções de parâmetros de linker (Tools/Compiler Options) deve ser setado (-lalleg)

// Tracado de reta no primeiro quadrante

#include <allegro.h>

#include <iostream.h>

void traca(float x1, float x2, float y1, float y2);

int main(){

float x1,x2,y1,y2;

cout <<"Entre com o valor de x1: ";

cin >>x1;

cout <<"Entre com o valor de y1: ";

cin >>y1;

cout <<"Entre com o valor de x2: ";

cin >>x2;

cout <<"Entre com o valor de y2: ";

cin >>y2;

cout <<"\n";

traca(x1,y1,x2,y2);


Prof Kesede R Julio

}

void traca( float x1, float y1, float x2, float y2){

float m;

float x,y;

allegro_init();

install_keyboard();

set_gfx_mode(GFX_AUTODETECT_WINDOWED,640,480,0,0);

m=(y2-y1) / (x2-x1);

cout<<"valor de m: "<<m<<"\n\n";

for(x=x1; x<=x2; x++){

y= (y1 + m * (x-x1));

putpixel(screen,(int)x, 500-(int)y, makecol(255,255,0));

}

readkey();

}

END_OF_MAIN()

Exemplo 2.2: Este código traça qualquer linha no primeiro octante. Estamos usando aqui a biblioteca Opengl no ambiente do Dev. Este codigo deve ser criado dentro de um projeto (.dev) e nas opções de parâmetros de linker do projeto deve ser setado (-lopengl32 -lglut32 -lglu). A Glut tambem deve estar instalada.

#include <GL/glut.h>

#include <stdlib.h>

// prototipos das funcoes

void init(void);

void display(void);

void keyboard(unsigned char key, int x, int y);

// funcao principal

int main(int argc, char** argv){

glutInit(&argc, argv); // inicializa o glut

glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);// especifica o uso de buffer e modo de

//cores

glutInitWindowSize (256, 256); // especifica as dimensoes da janela


Prof Kesede R Julio

glutInitWindowPosition (100, 100); // especifica aonde a janela aparece na tela

glutCreateWindow ("Desenhando uma linha"); // cria a janela

init();

glutDisplayFunc(display); // funcao que sera redesenhada pelo GLUT

glutKeyboardFunc(keyboard); // funcoes de teclado

glutMainLoop(); // mostra todas as janelas criadas

return 0;

}

// definicao de cada funcao

void init(void){

glClearColor(0.0, 0.0, 0.0, 1.0); // cor de fundo

glOrtho (0, 256, 0, 256, -1 ,1); // define os eixos do modo de projecao ortogonal

}

void display(void){

GLfloat m,x1,x2,y1,y2,y,x;

glClear(GL_COLOR_BUFFER_BIT); // apaga tela

// define pontos iniciais e finais para a reta no primeiro octante

x1=10; y1=50; x2=280; y2=100;

m=(y2-y1)/(x2-x1); // calcula inclinacao

// traça reta incrementando x de 1 em 1 e y sendo calculado

for(x=x1;x<=x2;x++){

y=(y1+m*(x-x1));

glBegin(GL_POINTS);

glVertex2f(x,y);

glEnd();

}

glFlush(); // descarrega na tela tudo o que foi traçado

}

void keyboard(unsigned char key, int x, int y){

switch (key) {

case 27: // tecla Esc (encerra o programa)

exit(0);

break;

}

}


Prof Kesede R Julio

2.2.1Desenho de Circunferências

Os parâmetros básicos que definem uma circunferência são as coordenadas do centro e o raio r. Podemos expressar a equação de uma circunferência de várias formas, usando parâmetros de coordenadas Cartesianas ou Polares.

Coordenadas Cartesianas :- ( x - xc )2 + ( y - yc )2 = r2

Coordenadas Polares :-

x = xc + r . cos Θ

y = yc + r . sen Θ

Onde:

xc é a coordenada x do centro da circunferência

yc é a coordenada y do centro da circunferência

r é o raio da circunferência

Θ é o ângulo de x e de y, respectivamente

Exemplo 2.3: Traça uma circunferência usando o Allegro.

// Traca circunferencia


#include <stdio.h>

#include <math.h>

void circ(float xc,float yc,float r);

int main(){

float xc, yc, raio;

printf("Entre com o valor de xc: ");

scanf("%f",&xc);


Prof Kesede R Julio

printf("Entre com o valor de yc: ");

scanf("%f",&yc);

printf("Entre com o valor do raio: ");

scanf("%f",&raio);

circ(xc,yc,raio);

}

END_OF_MAIN()

void circ(float xc,float yc,float r){

float ang,ang_rad,x,y;

allegro_init();

install_keyboard();


// traça circunferencia incrementando o ângulo (ang) de 1 em 1.

// o ângulo tambem está sendo convertido para radianos.

for(ang=1;ang<=360;ang++){

ang_rad=(ang*3.14)/180;

x = xc + (r * cos (ang_rad));

y = yc + (r * sin (ang_rad));


}

readkey();

}

Exemplo 2.4: Troque a função display() do exemplo 2.2 por esta.

void display(void){

GLfloat m,xc,yc,r,ang,ang_rad,x,y;


Prof Kesede R Julio

glClear(GL_COLOR_BUFFER_BIT); // apaga tela

// define ponto central e raio

xc=80;

yc=80;

r=50;




ang_rad=(ang*3.14)/180;

x = xc + (r * cos (ang_rad));

y = yc + (r * sin (ang_rad));

glBegin(GL_POINTS);

glVertex2f(x,y);

glEnd();

}

glFlush(); // descarrega na tela tudo o que foi traçado

}

2.2.3Elipses

O Algoritmo de desenho de circunferências pode ser estendido para traçar elipses. Uma circunferência é uma elipse, onde tanto o raio maior como o raio menor são iguais. No caso, quando vamos determinar a equação da elipse, determinamos dois raios diferentes, r1 chamado de raio maior e r2 chamado de raio menor, o centro está no ponto (xc, yc). Logo, temos que:

Coordenadas cartesianas:- ( x – xc / r1 )2 + ( y – yc / r2 ) 2 = 1

Coordenadas polares :-

x = xc + r1 . cos Θ

y = yc + r2 . sen Θ


Prof Kesede R Julio

Estas implementações de traçado de curvas são experimentais. Existem vários outras propostas para traçarmos estas primitivas de forma mais otimizada.

Exemplo 2.5 : Traça elipse usando Allegro

// Traca circunferencia


#include <stdio.h>

#include <math.h>

void circ(float xc,float yc,float r1,float r2);

int main(){

float xc, yc, raio1, raio2;

printf("Entre com o valor de xc: ");

scanf("%f",&xc);

printf("Entre com o valor de yc: ");

scanf("%f",&yc);

printf("Entre com o valor do raio 1: ");

scanf("%f",&raio1);

printf("Entre com o valor do raio 2: ");

scanf("%f",&raio2);

circ(xc,yc,raio1,raio2);

}

END_OF_MAIN()

void circ(float xc,float yc,float r1, float r2){

float ang,ang_rad,x,y;

allegro_init();

install_keyboard();



Prof Kesede R Julio




ang_rad=(ang*3.14)/180;

x = xc + (r1 * cos (ang_rad));

y = yc + (r2 * sin (ang_rad));


}

readkey();

}

2.3.Algoritmo de Ponto Médio (Bresenham)

O Algoritmo visto anteriormente tem o problema de ser muito lento para ser traçado, uma vez que se utiliza de ponto flutuante para cálculo de x e y (dependendo da inclinação). O algoritmo de Ponto Médio, desenvolvido por Bresenham em 1965 tem a vantagem de eliminar o uso do ponto flutuante substituindo-o por inteiro. Este método também é chamado de "Incremental", uma vez que para calcular (xi+1, yi+1) usamos os valores já calculados de x i e yi. Este Algoritmo foi desenvolvido tanto para o desenho de linhas como para o desenho de circunferências e elipses. A seguir veremos cada um deles.

2.3.1Ponto Médio para Linhas

O nosso problema sempre será decidir qual pixel iremos escolher para continuar o traçado. Considere, no traçado de linhas, a figura abaixo.


Prof Kesede R Julio

Neste estudo, estaremos considerando um segmento cuja inclinação está entre 0 e 1 (primeiro octante) e x1 < x2 e y1 < y2 (o segmento começa na esquerda e segue para direita), as outras inclinações poderão ser feitas por simetria.

Dado que o pixel P(xp,yp) foi escolhido, precisamos escolher qual o próximo pixel (E ou NE). Para proceder esta escolha verificamos onde se localiza o ponto M (Ponto Médio) em relação a I (ponto de intersecção da próxima vertical com a reta a ser traçada). Caso este Ponto Médio esteja acima da reta, o pixel E é escolhido, caso esteja abaixo dela, o pixel NE é escolhido. Dessa forma, o erro da escolha neste algoritmo será sempre menor ou igual a ½.

Precisamos agora de um método matemático para verificar de que lado (acima ou abaixo) M está em relação a reta.

Considerando a equação da reta em termos de sua inclinação:

y=axb ,

sendo a=dydx

e dy= y2− y1 e dx=x2− x1

Substituindo na equação temos:

y=dydx

xb

Agora podemos igualar esta equação a zero, assim:


NE

P=(xp,y

p) E

MI

xp+1x

p

yp

yp+1

Prof Kesede R Julio

y=dydx

x+ b

y=dy⋅xdx

+ b (multiplicação da fração por x /1)

y=dy⋅x+ b⋅dx

dx(divide pelo denominador e multiplica pelo numerador )

dx⋅y=dy⋅x+ b⋅dx (transporta o dx paraa esquerda)

dy⋅x−dx⋅y+ b⋅dx=0 (iguala aequação a zero)

Agora, considere a equação implícita da reta:

Através da equação da reta em termos de sua inclinação, conseguimos os termos da equação implícita, assim:

Logo,

Para pontos sobre a reta, teremos sempre F(x,y)=0, acima da reta F(x,y) < 0 (negativa) e abaixo dela teremos F(x,y)>0 (positiva). Para efetuar a verificação desta afirmação, escolha dois pontos quaisquer e, através da equação da reta, encontre pelo menos mais dois pontos. Agora, substitua qualquer desses pontos na equação implícita.

Caso o ponto médio pertença a reta, o cálculo de F(M) = F(xp+1, yp+ ½ ), será 0 (zero) e então podemos escolher E ou NE. Caso a função seja positiva, significa que o ponto médio está abaixo do segmento e, portanto escolhemos o pixel NE; caso seja negativa, o ponto está acima do segmento, e portanto escolhemos o pixel E.

Como estaremos decidindo através de F(M), passaremos a chamá-lo de variável de decisão (d).

Esta decisão definirá a escolha do próximo ponto E ou NE. Portanto, se E for escolhido, incrementamos 1 em x; caso NE seja escolhido incrementamos 1 em x e também em y.

Caso E seja escolhido,


F x , y =axbyc=0

F x , y =dy⋅x−dx⋅yB⋅dx=0

a=dyb=−dxc=b⋅dx

Prof Kesede R Julio

d novo=F x p2, y p12=ax p2b y p

12c

e

d anterior=a x p1b y p12c

Subtraindo danterior de dnovo obtemos a diferença incremental ΔE.

ax p2aby p12

bc

−

ax p aby p12

bc

=a

ΔE = a = dy

Afim de eliminar a fração de b multiplicamos toda a equação por 2, o que não muda em nada no resultado que nos interessa que é o seu sinal. Portanto: ΔE=2dy.

Caso NE seja escolhido,

d novo=F x p2, y p32=ax p2b y p

32c

e

d anterior=a x p1b y p12c

Subtraindo danterior de dnovo obtemos a diferença incremental ΔNE.

ax p2aby p32

bc

−

ax p aby p12

bc

=ab

ΔNE= a + b = dy - dx

Aqui também afim de eliminar a fração de b multiplicamos toda a equação por 2. Portanto: ΔNE=2(dy-dx).


Prof Kesede R Julio

Com isso encontramos o incremento caso o ponto E seja escolhido e o incremento caso NE seja escolhido. Bem, agora precisamos da variável dinicial , pois é ela que será incrementada. Sabendo que o ponto inicial (x1, y1) é um ponto da reta, podemos então calcular o dinicial para escolha do primeiro E ou NE. Então,

F M =d inicial=a x p1b y p12

c=

=ax paby pb2

c=

=ax pby pcab2

=

= F x p , y pab2

=

=ab2

Também afim de eliminar a fração multiplicamos por 2, e portanto, d inicial=2ab=2dy−dx .

2.3.2 Ponto Médio para Circunferências

Assim como para linhas, o objetivo do algoritmo para as circunferências é plotar o próximo ponto. Para isso, consideraremos a equação da circunferência:

F x , y =x2 y2

−R2

Trataremos do traçado da circunferência apenas para o segundo octante (0≤ x≤R⋅ 2e R≥ y≤R 2 ), todos os demais pontos poderão ser traçados por

simetria.


SE

E

M

P=(xp,y

p)

xp x

p+1

yp

yp-1

Prof Kesede R Julio

Neste caso, dado um ponto Px p , y p , queremos traçar o próximo ponto E ou SE. Novamente avaliamos o F(M) = d (variável de decisão), afim de tomarmos a melhor decisão. O ponto inicial escolhido é P(0,R), portanto o próximo ponto

médio está em 1, R−12 . Substituindo este ponto da equação, temos:

F 1, R−12=1R2

−R14−R2

=54−R2

Para determinarmos os incrementos (ΔE e ΔSE), procedemos da mesma forma que no algoritmo da linha. Caso seja escolhido E, incrementamos 1 em x; caso seja SE incrementamos 1 em x e decrementamos 1 em y.

Caso seja escolhido E, então:

d anterior=F x p1, y p−12=x p12 y p−

12

2

−R2

d novo=F x p2, y p−12=x p22

y p−12

2

−R2

Ao subtrairmos o danterior de dnovo, encontramos a diferença incremental de ΔE. Podemos cancelar os dois últimos termos e calcular apenas o primeiro, assim:

d anterior=x p12− = x p

22x p 112

− = x p22x p1−

d novo =x p22− = x p

22x p 222

− = x p24x p4−

ΔE=2x p3

Caso SE seja escolhido, temos:

d novo=F x p2, y p−32=x p22 y p−

32

2

−R2

Desta forma, fazendo a subtração com o d anterior , teremos ΔSE. Como os terceiros termo são iguais, podemos cancelá-los, calculando apenas o primeiro e o segundo termo. A subtração do primeiro termo já foi calculada no ΔE, assim podemos calcular apenas o segundo termo:


Prof Kesede R Julio

d anterior=x p12 y p−

12

2

−=

x p12 y p

2−2⋅y p⋅

12

12

2

− =

x p12 y p

2− y p

14

−

d novo = x p22y p−32

2

− =

x p22 y p

2−2⋅y p⋅

32

32

2

− =

x p22 y p

2−3y p

94

−

ΔE=2x p3−2y p2=2x p−2y p5

2.1. Exercícios

2.4.1.Desenvolva métodos para implementação destas curvas, utilizando qualquer linguagem de programação (Java, C++, C, pascal etc).

2.4.2.Desenhe um boneco utilizando apenas as primitivas vistas. O boneco deve possuir: cabeça (circulo), olhos (elipse), braços, pernas e tronco (linhas).

2.4.3.Faça este boneco piscar os olhos.2.4.4.Modifique a função que desenha a reta, trocando-a pelo algoritmo de Ponto Médio

(Bresenham).


Prof Kesede R Julio

3.Transformações Geométricas

A Transformação Geométrica (TG) nos permite modificar a dimensão de um objeto em uma cena, assim como mudá-lo de posição ou menos girá-lo sob um determinado grau, a partir de um determinado ponto.

3.1Transformações 2D

As Transformações 2D são realizadas no plano cartesiano. Existem, basicamente, 3 transformações possíveis: translação, rotação e escala. As transformações aqui apresentadas serão efetuadas em relação à origem.

3.1.1 Translação

O movimento de translação é realizado através da soma de um deslocamento em x (tx) e/ou em y (ty). Dado um ponto P(x, y), podemos transladá-lo em x, assim o novo ponto seria P'(x', y'). Para deslocarmos o ponto em y a regra é a mesma. Então x' é x transladado de tx e y' é o y transladado de ty. O deslocamento pode ser positivo ou negativo, dependendo do destino que se quer dar ao ponto.

x' = tx + x

y' = ty + y

Podemos representar estes pontos e deslocamento em matriz, assim:

P =[ xy]

P '=[ x 'y ' ]

T =[ txty ]

Portanto, a equação em termos destes vetores, é:

P'= T + P

Podemos transladar um objeto, transladando ponto a ponto da forma vista acima, no entanto isto torna-se caro computacionalmente. Então podemos, por exemplo, para transladar um linha, transladar apenas o seu ponto inicial e o seu ponto final, retraçando a linha no destino. Isto pode ser feito com polígonos através de seus vértices.

Veja o exemplo de um objeto translado em T(1,2).


Prof Kesede R Julio

3.1.2Escala

Podemos também, ao invés de transladar o objeto, escaloná-lo afim de adequá-lo a uma determinada cena. Aplicamos, para isso, um fator de escala em x (sx) e um fator de escala em y (sy). Estes fatores devem ser multiplicados pelos valores de x e de y do ponto, respectivamente.

x'= sx * x

y' = sy * y

E portanto, matricialmente, teríamos:

P '=S∗P [ x 'y ' ]=[ sx 0

0 sy ]⋅[ xy]

Aplicando um fator sx=0.5 e sy=1.5 no objeto abaixo, teríamos:

3.1.3 Rotação


(4,2)(1,2)

(2.5, 5)

x

y

Objeto na Posição inicial

(2,4)

(3.5, 7)

x

y

Objeto Transladado

(5,4)

(4,2)(1,2)

(2.5, 5)

x

y

Objeto na Posição inicial

(1.25, 7.5)

x

y

Objeto Escalonado

(0.5,3) (2,3)

Prof Kesede R Julio

A TG de rotação permite girarmos um objeto de acordo com um determinado ângulo (Θ) especificado. Para isso, precisamos aplicar fatores de rotação em x e em y. Matematicamente, teríamos:

x '= x⋅cosΘ y⋅−sen Θy '= x⋅sen Θ y⋅cos Θ

e matricialmente, teríamos:

P '=R⋅P [ x 'y ' ]=[ cos −sen

sen cos ]⋅[ xy]

Aplicando uma rotação de 45o positivos no objeto abaixo, teremos a seguinte transformação:

3.2 Laboratório TG 2D em MatLab

Primeiramente precisamos construir a matriz de pontos do objeto a ser transformado. Trabalharemos com um quadrado 2x2, com o cse(2,4) e com o cid(4,2). Para plotarmos este objeto criaremos uma matriz de pontos P, onde a primeira linha representará o eixo “x” e a segunda linha o eixo “y”. O último ponto deve ser igual ao primeiro para que o objeto seja fechado.

Vamos lá: No prompt do Matlab digite:

>> P=[2 4 4 2 2;4 4 2 2 4]

P =

2 4 4 2 2

4 4 2 2 4

Aqui construímos uma matriz 2x5, onde cada coluna representa um ponto (x,y) do objeto (sendo o último igual ao primeiro afim de fechar o quadrado). Vamos plotar para visualizarmos o objeto. Digite:


(4,2)(1,2)

(2.5, 5)

x

y

Objeto na Posição inicialx

y

Objeto Rotacionado

(-1.1, 1.9 )

(-2.9, 4.7 )(0.3, 4.4 )

Prof Kesede R Julio

>> plot(P(1,:),P(2,:)), xlim([0 10]), ylim([0 10]), grid on

Será mostrado um quadrado em um plano cartesiano x,y com escala de 0 a 10.

Agora mostraremos como efetuar as transformações neste objeto.

3.2.1 Translação

Vamos agora transladar o objeto com os fatores tx=2 e ty=1. Construa a matriz translação digitando:

>> T=[2;1]

T =

2

1

Como a transformação de translação é aditiva e não multiplicativa, não podemos somar toda a matriz Ponto (P) com a matriz Translação (T), devido a inconsitência da ordem das matrizes. Assim, devemos somar cada coluna da matriz Ponto com a matriz Translação, gerando cada coluna da matriz resultante Pt (Pontos transladados). No prompt do MatLab digite:

>> Pt(:,1)=T+P(:,1)

Pt =

4

5

>> Pt(:,2)=T+P(:,2)

Pt =

4 6

5 5

>> Pt(:,3)=T+P(:,3)

Pt =

4 6 6

5 5 3


Prof Kesede R Julio

>> Pt(:,4)=T+P(:,4)

Pt =

4 6 6 4

5 5 3 3

>> Pt(:,5)=T+P(:,5)

Pt =

4 6 6 4 4

5 5 3 3 5

Com a matriz Pt pronta, podemos plotá-la. Digite:

>> hold on;

>> plot(Pt(1,:),Pt(2,:)), xlim([0 10]), ylim([0 10]),grid on

>> hold off;

Pronto! Temos agora duas imagens do mesmo objeto, uma na posição inicial outra na final (transladada).

Exercícios

1. Plote um triângulo P1(2,3) , P2(6,3) ,P3(4,5) e aplique a translação

T(3, -2).

3.2.2 Escalonamento

Construiremos uma matriz escala S, afim de escalonar o objeto com fator 0,5 em “x” e 1,5 em “y”. Digite:

>> S=[0.5 0;0 1.5]

S =

0.5000 0

0 1.5000


Prof Kesede R Julio

Com a matriz escala S construída podemos multiplica-la pela matriz de pontos, afim de obter os novos pontos do objeto. Digite:

>> Ps=S*P

Ps =

1 2 2 1 1

6 6 3 3 6

Plotamos agora o objeto escalonado. Digite:


>> hold on;

>> plot(Ps(1,:),Ps(2,:)), xlim([0 10]), ylim([0 10]);

>> hold off;

Perceba que o objeto teve uma diminuição em 50% em “x” e teve um aumento de 50% em sua dimensão em “y”.

Exercícios

1. Plote um triângulo P1(2,3) , P2(6,3) ,P3(4,5) e aplique um fator de escalonamento

S(0.3,0.7).

3.2.3 Rotação

Agora construiremos a matriz rotação R, assumindo que queremos rotacionar 17o19’ positivos (0,3 em radianos). Digite:

>> R=[cos(0.3) -sin(0.3); sin(0.3) cos(0.3)]

R =

0.9553 -0.2955

0.2955 0.9553

Pronto! Com a matriz ponto P e a matriz rotação R construída, podemos fazer a multiplicação das duas para conseguirmos os novos pontos da matriz rotacionada Pr.


Prof Kesede R Julio

>> Pr=R*P

Pr =

0.7286 2.6393 3.2303 1.3196 0.7286

4.4124 5.0034 3.0928 2.5017 4.4124

Estes são os novos pontos do objeto rotacionado. Agora podemos plotá-lo sobre o objeto em sua posição inicial para percebermos a rotação sendo realizada.


>> hold on;

>> plot(Pr(1,:),Pr(2,:)), xlim([0 10]), ylim([0 10]);

>> hold off;

Para limpar a janela do gráfico, digite:

>> clf

Exercícios

1. Crie uma matriz de pontos para um triângulo P1(2,3), P2(6,3) ,

P3(4,5) e aplique uma transformação R-15.

3.3 Transformações 3D

A Transformação 3D acontece no espaço (x, y, z) e obedece as mesmas regras das transformações 2D. Para gerar suas matrizes basta acrescentar uma coluna e uma linha a cada uma delas. Assim:

Translação:

T =[txtytz ]


Prof Kesede R Julio

Escala:

S=[sx 0 00 sy 00 0 sz ]

Rotação:

R=[cos −sen 0sen cos 0

0 0 1]Na rotação em 3D, temos a opção de escolhermos qual dos eixos ficará fixo, ou seja, sobre qual eixo queremos que a rotação seja realizada. Por isso, teremos 3 matrizes possíveis.

Sobre o eixo z (no plano xy):

R=[cos −sen 0sen cos 0

0 0 1]Sobre o eixo x (no plano yz):

R=[1 0 00 cos −sen

0 sen cos ]Sobre o eixo y (no plano xz):

R=[cos 0 −sen

0 1 0sen 0 cos ]

3.4 Coordenadas Homogêneas

As matrizes de Rotação e de Escala são aplicadas sobre a matriz de Pontos através de uma multiplicação, diferente da matriz Translação que tem um efeito aditivo sobre a matriz de pontos.


Prof Kesede R Julio

Rotação : P’ = R * P

Escala : P’ = S * P

Translação : P’ = T + P

A fim de possibilitar as múltiplas transformações no ponto, utilizando composição de matrizes (rotação, escala e translação), temos que fazer com que as operações das matrizes de transformação com os pontos sejam consistentes (todas devem ser multiplicativas em relação a matriz ponto).

Vamos demonstrar isto com as matrizes no plano (2D), mas por extensão, pode ser aplicado as matrizes no espaço (3D).

Para que todas as operações possam ser multiplicativas, devemos converter as coordenadas de cartesianas (x,y) para homogêneas (x,y,W). Na realidade, isso significa que estaremos tratando pontos do plano (2D) através de três coordenadas. A coordenada W poderá ser dividida por x e y, voltando assim para sua representação cartesiana. Assim, P(2,3,5) também pode ser representada por P(2/5,3/5,1). Ao usarmos este tipo de representação temos também que modificar a forma de representação matricial. Desta forma, todo ponto teria o acréscimo da coordenada homogênea representada pelo plano 1 do espaço 3D. Abaixo apresentamos as novas matrizes de transformação.

Translação: P’ = T * P

P '=T⋅P[x 'y '1 ]=[

1 0 tx0 1 ty0 0 1 ]⋅[

xy1]

Escala: P’ = S * P

P '=S⋅P[x 'y '1 ]=[

sx 0 00 sy 00 0 1]⋅[

xy1 ]

Rotação: P’ = R * P

P '=R⋅P [x 'y '1 ]=[

cos −sen 0sen cos 0

0 0 1]⋅[xy1 ]


Prof Kesede R Julio

No sentido de aplicarmos várias transformações sobre uma matriz de pontos, podemos executar multiplicações consecutivas sobre as matrizes, obedecendo a ordem de multiplicação da direita para a esquerda.

P’ = R * S * T * P

3.5 Composição de Transformações

As transformações realizadas sobre um mesmo ponto podem ser combinadas em uma única matriz, no intuito de aumentar a eficiência da transformação. Esta matriz é chamada de Matriz Composição.

Até agora todas as transformações foram realizadas a partir da origem, no entanto, podemos desejar uma transformação a partir de qualquer ponto. Para isso, podemos seguir os seguintes procedimentos:

1. Transladar a matriz de Pontos para a origem (To)

2. Aplicar as transformações necessárias (R e/ou S e/ou T) na origem.

3. Transladar a matriz de Pontos de volta (Tv ) para sua posição original.

MC = Tv * R * S * To

P´ = MC * P

Assim, se quisermos fazer uma rotação de 45o negativa a partir do ponto (2,3), no quadrado p1(3,3), p2(6,3), p3(6,6) e p4(3,6), executaremos a seguinte seqüência de transformação:

MC = T(2,3) * (R-45 * T(-2,-3))

P´ = MC * P


Prof Kesede R Julio

4.Modelagem Geométrica

Modelagem geométrica é um conjunto de métodos utilizados para descrever a forma e características de um objeto.

A modelagem geométrica é de grande importância devido ao barateamento do custo do processo industrial que as simulações oferecem. È mais barato construir, analisar, alterar e manipular modelos que objetos.

As técnicas de modelagem são fartamente utilizadas em sistemas de CAD (Computer Aided Design), animação, robótica etc. Os primeiros sistemas serviram à indústria aeroespacial e automobilística e estavam baseados em estudos matemáticos desenvolvidos nas décadas de 50 e 60. Estes sistemas eram chamados de modeladores de superfície e eram computacionalmente caros devido as restrições de hardware e algoritmos ainda não tão bem otimizados.

No fim dos anos 60, as pranchetas eram trocadas pelo monitor, através de sistemas CAD que permitia a geração de linhas retas, arcos, além de acréscimo de dimensões e informações sobre o objeto desenhado, podendo ainda a impressão ser direcionada a uma ploter. Estes sistemas caracterizavam-se pela representação dos objetos através de suas “vistas” (elevação, planta, lateral), como na figura 4.1.


Prof Kesede R Julio

Em meados de 70, informações de profundidade foram acrescidas às linhas, podendo o computador gerar um objeto unificado, chamado de objeto semi-tridimensional, desenhado por um conjunto de arestas no espaço.

A idéia foi logo generalizada e foram gerados os primeiros modelos tridimensionais chamados de wireframe (fio de arame). Neste caso qualquer parte do objeto poderia ser representada em qualquer ponto de vista e qualquer projeção escolhida pelo usuário. Podemos ver um exemplo na Figura 4.2.


Figura 4.1: Vistas de uma peça

Prof Kesede R Julio

Como este modelo era composto por um conjunto de arestas, dependendo da complexidade do objeto e do ponto de vista do usuário, as arestas se confundiam e ficava difícil a interpretação. Faltava as informações sobre as superfícies visíveis e não-visíveis para tornar o objeto mais compreensível visualmente.

Daí surgiram os modeladores de sólidos, unindo as vantagens do wireframe e a dos modeladores de superfície. Agora os modelos poderiam conter informações sobre faces do objeto (superfícies e arestas) visíveis e escondidas, ou seja, informações referentes as fronteiras do objeto, além de detalhes sobre suas conectividades. Um grande ganho destes modelos é o calculo de volume, massa momento de inércia, interferência entre componentes etc.

Uma grande barreira até hoje para a modelagem de sólidos é a tecnologia de hardware e de software, que ainda são fatores limitantes para o bom desempenho dos sistemas.

Este modelo permite, em princípio, o cálculo de qualquer propriedade geométrica do objeto modelado gerada pela sua capacidade de distinguir superfície, interior e exterior do objeto. Estes cálculos dependem da validação do objeto (o sólido deve ser válido) que devem satisfazer as seguintes propriedades:


Figura 4.2: Modelo Wireframe

Prof Kesede R Julio

Rigidez: transformações rígidas aplicadas sobre ele não podem modificar sua forma.

Finitude: ocupar uma parte finita do espaço

Homogeneidade: não pode possuir objetos adendos a ele.

Determinismo da fronteira: a fronteira, o interior e o exterior do objeto devem ser passíveis de descrição.

Finitude de descrição: um número finito de símbolos deve descrever o objeto.

Fechamento sobre operações: operações geométricas efetuadas sobre objetos válidos devem resultar em um objeto válido.

Segundo Mortengen existem 6 métodos diferentes de modelagem: Wireframe, Instanciamento primitivo, Varredura, Decomposição, Geometria Sólida Construtiva (CSG-Constructive Solid Geometry), Fronteira (B-Rep ou Polygonal Representation).

4.1 Wireframe

Este modelo é também conhecido como fio de arame. O grande problema deste método é a representação de objetos complexos, onde o traçado de suas linhas pode gerar interpretações ambíguas. Figura 4.2

4.2 Instanciamento Primitivo

A representação dos sólidos são gerados a partir da representação de sólidos primitivos alterando-se os parâmetros.


Prof Kesede R Julio

4.3 Varredura

Neste modelo, o sólido é representado por uma região bidimensional e um vetor diretor. O sólido é gerado pelo caminho feito pelo vetor diretor.

4.4 Decomposição


Figura 4.3: Modelo por Instanciamento Primitivo

Figura 4.4: Modelagem por Varredura

Prof Kesede R Julio

O sólido, neste modelo, é representado por um conjunto de sólidos primitivos que são unidos por uma operação de colagem. Na Figura 4.5 podemos ver um modelo por Decomposição utilizando a técnica de Enumeração exaustiva (conjunto de sólidos primitivos todos de mesmo tamanho). Esta abordagem é aproximada, uma vez que suas curvas são aproximadas.

4.5 GSC – Geometria Sólida Construtiva

A representação aqui é realizada por operações e transformações sobre sólidos primitivos, ou seja, cone, cilindro, cubo e esfera para representar qualquer outro objeto.

Aplicando transformações geométricas (rotação, translação e escala) e operações booleanas (união, intersecção e diferença) sobre as formas primitivas podemos construir quaisquer outras formas de representação.

Um grande problema deste método é o custo computacional, devido a grande quantidade de intersecções (ray tracing) a serem calculadas. Além disso, alguns objetos são impossíveis de serem representados apenas com primitivas. Abaixo mostramos um exemplo desta representação em uma estrutura de árvore.


Figura 4.5: Modelagem por Decomposição

Prof Kesede R Julio

4.6 Fronteira

Os objetos aqui são representados por um conjunto de faces de polígonos planos, onde as fronteiras dos polígonos demarcam as curvas do objeto.


Figura 4.6: Modelagem por GCS

Prof Kesede R Julio

Este é um método de representação muito utilizado nos sistemas gráficos atuais, porém sua construção é complexa, uma vez que as curvas requerem muitas faces para representá-las. O efeito de suavização pode ser feito através de sombreamento e a sua renderização realizada através de programas embutidos no hardware.


Figura 4.7: Modelagem por Fronteira

Prof Kesede R Julio

5 Curvas e Superfícies

5 .1 Curvas

5.1.1 Conjunto de Pontos

Uma curva é representada, matematicamente, por um conjunto infinito de pontos. Claro que esta representação infinita é impossível de ser descrita analiticamente, portanto, um conjunto finitos de pontos deve ser escolhido para definir uma curva. Enfim, uma curva é representada por uma sequência de pontos no plano cartesiano (x, y). Exemplo: {(-2,8), (-1,3), (0,0), (1,-1), (2,0), (3,3), (4,8)}. Cada um destes pontos representam a distância entre o ponto e a origem dos eixos x e y, respectivamente. Resultados de experimentos se utilizam deste forma de representação.

Dependendo da aplicação, apenas os pontos são suficientes para mostrar satisfatoriamente os dados, porém se queremos representar uma curva


Prof Kesede R Julio

geométrica e não pontos representativos de dados, precisaremos de mais pontos quanto mais acentuada for a curva. Exemplo:

5.1.2 Bézier

Em meados de 1960, Pierre Bézier desenvolvendo um projeto para os automóveis da Renault francesa, baseou suas curvas em pontos de controle, inclusive para o cálculo da tangente dos pontos iniciais e finais. Os softwares mais populares do mercado (Corel Draw, 3D Max, Auto CAD etc) se utilizam deste conceito para o traçado de curvas.

A curva paramétrica de Bézier é definida por:

Pt =∑i=0

n

B i J n , it 0≤t≤1

Onde:

– Bi é cada um dos pontos de controle da curva

– Jn,i (t) são as funções de combinação (blending functions) que influenciam todos os pontos de controle. Estas funções são definidas pelos polinômios de Bernstein:

J n , it =niti

1−t n−i


Prof Kesede R Julio

Onde: n é o grau dos polinômios e

ni=

n !i ! n−i!

i=0,1, ... n

são os coeficientes binomiais. Estas funções devem satisfazer as condições:

J n , it ≥0 para todo i entre 0 e 1, isto é, 0≤i≤1

e

∑i=0

n

J n , it=1, , 0≤t≤1

esta última condição força a curva permanecer dentro do polígono convexo (convex hull) definido por todos os pontos de controle.

Quando movemos qualquer ponto de controle na curva de Bézier, movemos toda a curva, pois eles estão relacionados pelo polinômio de Bernstein. A esta característica damos o nome de “controle global”. Isto pode ser prejudicial quando queremos um ajuste fino na curva. Neste caso, teremos que aumentar o número de pontos para um maior controle.

Quando aumentamos o número de pontos de uma curva, deixamos sua expressão muito complexa. Uma solução para isto é a divisão em várias curvas de menor grau. Neste caso, para que haja continuidade das curvas, devemos definir três pontos em uma mesma reta, ou seja, a reta terá seus pontos extremos definidos pelo penúltimo ponto de uma das curvas e o segundo ponto da outra, sendo o ponto do meio da reta coincidentes às duas curvas. Veja a figura abaixo.


Figura 5.4: Curva de Bézier contida no polígono formado pelos seus pontos de controle

B1

B0

B2

B3

B4

Curva de Bézier

B1

B0

B2

B3

B4

B5

Prof Kesede R Julio

Podemos, como exemplo considerar o traçado de uma curva com três pontos de controle: B0, B1 e B2.

Substituindo os polinômios de grau 2, na expressão da curva paramétrica de Bézier, teremos:

Pt =B0 J 2,0t B1 J 2,1t B2 J 2,2t

Portanto, as funções de combinação (polinômios de Bernstein) seriam:

J 2,0=2 !

0 !2 !t 0

1−t 2=1−t 2=1−2tt 2

J 2,1=2!

1! 1!t11−t 1=2t1−t =2t−2t2

J 2,2=2 !

2 !0 !t 2

1−t 0=t 2

assim, substituindo estes resultados na expressão da curva, teremos:

Pt =1−t 2 B02t1−t B1t 2 B2

Matricialmente, teremos:

Pt =[1−t 2 2t1−t t 2

][B0

B1

B2]

podemos também separar t em uma matriz de potência, assim:


Figura 5.5: Curvas de menor grau conectadas

B1

B0

B2

B3

B4

B0

B1

B2

B3

Prof Kesede R Julio

Pt =[ t 2 t 1][1 −2 1

−2 2 01 0 0] [

B0

B1

B2]

Resumindo, poderíamos ter a seguinte representação:

Pt =T M B CB

Onde:

T é o vetor potência

MB são os coeficientes da matriz de Bézier

CB são os pontos de controle.


Prof Kesede R Julio

6.Fundamentos de Cor

6.1 Conceitos Básicos

As cores nada mais são que frequências eletromagnéticas, porém não são quaisquer frequências, uma vez que a grande maioria delas não são visíveis. Na verdade, o que os olhos humanos conseguem ver é uma pequena faixa do espectro de frequência eletromagnética conhecida. Esta faixa se localiza entre as radiação infravermelha e ultravioleta. A cada espectro visível está associada uma cor, variando entre o vermelho, passando pelo amarelo, verde, azul e chegando ao violeta. As ilustrações abaixo mostram estas variações.

Quando temos emissão de uma fonte de luz branca (emissão de todas as frequências do espectro visível), como o sol, por exemplo, parte desta luz é refletida e parte é absorvida pelos objetos expostos. Caso a parte refletida tenha dominância de alta frequência no escopo visível, dizemos que o objeto tem cor vermelha; caso a dominância seja de baixa frequência dizemos que o objeto é de cor violeta.

Podemos chamar as frequências dominantes refletidas de cor ou de matiz da luz. As características da luz são determinadas pela sua matiz, brilho e saturação. Usamos a matiz para dar nome a cor, o brilho é determinado pelo nível de luminância de uma cor em relação a outra cor, e a saturação é o nível de pureza de um determinada cor. As cores branca, preta e cinza tem saturação uniforme em todos os comprimentos de onda e por isso, são diferenciadas apenas pelo seu


Prof Kesede R Julio

brilho. A propriedade de cromaticidade é determinada pela saturação e pela matiz da cor.

6.2.Sistemas de Cores Primárias

Quanto falamos de Sistema de Cor, estamos falando de cores primárias, ou seja, cores que são utilizadas para visualizar outras cores. Existem vários sistemas de cores primárias, porém falaremos apenas de dois deles: RGB (Red, Green, Blue) e HSV (Hue, Saturation, Value). Chamamos de espaço de cor a área formada pelas cores intermediárias das cores primárias de cada sistema.

6.2.1 RGB

Este sistema está baseado na teoria de Young-Helmholtz, que diz que a percepção humana para cores acontece através da estimulação de 3 pigmentos presentes nos cones da retina, os quais tem seus picos de sensibilidade nos seguintes comprimentos de onda: 630 nm (Red), 530 nm (Green) e 450 nm (Blue).

Os monitores CRT se utilizam deste sistema. Este modelo é aditivo,o que significa que a contribuição individual de cada cor deve ser somada para obtermos a cor resultante.

O sistema RGB pode ser representado por um cubo unitário, onde a posição (0,0,0) representa a cor preta, a posição (1,1,1) a cor branca e a reta diagonal traçada entre estes dois pontos, os níveis de cinza.


Red=(1,0,0)

Blue=(0,0,1)

Green=(0,1,0)

branco=(1,1,1)

preto=(0,0,0)

Níveis de cinza

Ciano=(0,1,1)

Amarelo=(1,1,0)

Magenta=(1,0,1)

Prof Kesede R Julio

6.2.2.HSV (Hue, Saturation, Value)

Neste sistema, a cor é definida pelo seu espectro combinado com a quantidade de cor branca e de cor preta adicionados a ele. A representação do sistema é realizada através de um cone de seis lados, derivado do cubo unitário RGB.


Vermelho

AmareloVerde

Ciano

Azul Magenta

Luminância

Saturação

Hue (Matiz)

Luminância=0 (preto)

Luminância=1 (branco)

Prof Kesede R Julio

7 Processamento de Imagem

Por muitos autores a área de Processamento de Imagem é uma sub-área da Computação Gráfica, seja como for, está longe de perder a sua importância, uma vez que o reconhecimento intuitivo das informações pelo olho humano é realizado através de imagens. Processar a imagem significa manipular os valores que a representam de forma a torná-la adequada aos seus objetivos. Muita manipulação pode ser feita com imagens, porém precisamos antes de tudo entender o que é imagem digital.

7.1 Representação Digital de Imagem

Qualquer imagem do mundo real é representada no espaço contínuo, quando digitalizamos esta imagem devemos, obrigatoriamente, discretizar o espaço de representação. À discretização do espaço ocupado pela imagem damos o nome de Amostragem e à discretização da sua luminosidade damos o nome de Quantização. Veremos cada um deles adiante. Uma imagem digital, portanto, pode ser representada por uma matriz de dimensões definidas, onde cada posição representa a discretização de uma área da imagem (pixel = picture elements) e o valor atribuído a esta posição representa a discretização da luminosidade naquele ponto. O canto superior esquerdo da matriz será o pixel (0,0), que contem a intensidade de cor f(0,0). A origem da imagem se dará neste pixel, ou seja, o eixo X começará neste ponto ponto e caminhará no sentido horizontal para a direita, enquanto que o eixo Y, começará neste ponto e caminhará no sentido vertical para baixo. Por exemplo, uma imagem em branco e preto (binária) pode ser discretizada através de uma matriz 10x10, e a representação da luminosidade em cada pixel por valores 0´s (preto) e 1´s (branco).

0 0 0 0 1 1 0 0 0 0

0 0 1 1 0 0 1 1 0 0

0 1 1 0 0 0 0 1 1 0

0 1 1 0 0 0 0 1 1 0

1 1 0 0 0 0 0 0 1 1

1 1 0 0 0 0 0 0 1 1

0 1 1 0 0 0 0 1 1 0

0 1 1 0 0 0 0 1 1 0

0 0 1 1 0 0 1 1 0 0

0 0 0 0 1 1 0 0 0 0


x

y

(0,0)

Prof Kesede R Julio

A esta matriz poderíamos chamar de imagem binária, uma vez que apenas dois valores são possíveis para representar a cor do pixel (1 bit de profundidade). Poderíamos também representar uma imagem em 256 níveis de cinza (8 bits de profundidade) onde cada número de 0 a 255 representaria na matriz uma determinada intensidade de cinza da imagem. Por exemplo, poderíamos ter uma imagem gradiente representada na matriz:

0 0 0 0 0 0 0 0 0 0

30 30 30 30 30 30 30 30 30 30

60 60 60 60 60 60 60 60 60 60

90 90 90 90 90 90 90 90 90 90

120 120 120 120 120 120 120 120 120 120

150 150 150 150 150 150 150 150 150 150

180 180 180 180 180 180 180 180 180 180

210 210 210 210 210 210 210 210 210 210

240 240 240 240 240 240 240 240 240 240

255 255 255 255 255 255 255 255 255 255

Para compreendermos melhor, vamos trabalhar com algumas imagens pequenas, criadas por nós mesmos.

7.1.1 Laboratório

1. Crie e mostre uma matriz gradiente.

- Carregue o MatLab.

- Crie um vetor com os valores de 0 a 255, com passo de 1.

>> im=[0:1:255];

>> im

Caso você não coloque o ponto-e-vírgula o retorno é imediato. Neste caso, foi criado uma matriz 1x256. Para gerar uma transposta de im, basta adicionar um apóstrofo após o nome da matriz (im').


Prof Kesede R Julio

Agora você deve criar uma matriz 256x256, repetindo os valores deste vetor nas diversas linhas da matriz

>> im=repmat(im,256,1);

>> im

A função repmat() replica o primeiro argumento em cada posição da matriz definida pelos argumentos 2 e 3. Desta forma, a matriz im é replicada em 256 linha, mas apenas em uma coluna. Como a matriz tem 256 colunas, logo teremos como resultado uma matriz de 256x256.

Mostre a matriz

>> imshow(im, [])

A função imshow mostra o primeiro argumento como uma imagem. O segundo argumento desta função permite assumir uma escala de cinza do menor até o maior elemento do primeiro argumento.

2. Crie uma lista de -15 a 18, variando de 3 em 3.

>> a=[-15:3:18]

a =

-15 -12 -9 -6 -3 0 3 6 9 12 15 18

3. Modifique o vetor acima de forma que se torne uma matriz. Trabalhe com ordens diferentes e faça comentários a respeito.

>> a34=reshape(a,3,4)

a34 =

-15 -6 3 12

-12 -3 6 15

-9 0 9 18


a43 =

-15 -3 9

-12 0 12

-9 3 15

-6 6 18



Prof Kesede R Julio

a26 =

-15 -9 -3 3 9 15

-12 -6 0 6 12 18

4. Mostre, como imagem, cada uma das matriz geradas. Caso cada valor apareça como um único pixel, utilize o parâmetro 'notruesize' na função imshow

7.1.2 Relatórios

1) Crie e mostre duas imagens listradas (branco e preto), com tamanho mínimo de 50x50. Na primeira imagem, crie listras verticais e na segunda horizontais. Faça comentários explicativos

2) Crie e mostre duas imagens xadrez (branco e preto), com tamanho mínimo de 50x50. Na primeira imagem, crie a primeira posição como preta e na segunda imagem como branca. Faça comentários explicativos

7.2 Quantização

Como foi citado anteriormente temos em cada pixel o valor da luminosidade. A variação dos valores deste atributo depende da profundidade de cor da imagem. No caso de uma imagem binária, teríamos uma profundidade de cor de 1 bit apenas. A tabela abaixo mostra a relação entre o número de cores e a quantidade de bits de profundidade de cor da imagem.

Profundidade(bits)

Nr de cores

1 2

2 4

3 8

4 16

5 32

6 64

7 128

8 256

Considerando que o espaço onde representamos a imagem é o plano (x, y), podemos dizer que a intensidade de cor varia no eixo z (f(x,y)). Quando


Prof Kesede R Julio

quantizamos uma imagem discretizamos sua profundidade de cor. Isto significa que uma imagem no espaço contínuo de cor pode ser representada no espaço discreto de 256 cores (8 bits), que pode ser representada no espaço de cor de 128 (7 bits), e assim por diante. A consequência disso, será a redução da representação das cores da imagem, pois teremos menos bits para representá-las, consequentemente, perda de detalhes.

Na prática, existem vários métodos de quantização de imagens, uns mais, outros menos eficientes, dependendo da distribuição das cores na imagem. Mostraremos uma dessas formas. Podemos fazer a relação do valor do pixel da imagem com o nr de cores que queremos, isto seria um processo de proporção. Assim:

valor do pixelatualnr decores atual

=valor do pixel quantizado

nr decores desejada

Através da função size() podemos identificar se estamos tratando com uma imagem RGB (3 camadas) ou nível de cinza (1 camada).

>> f=imread('lenina.ppm');

>> size(f)

ans =

256 256 3

Para saber algumas informações a respeito da imagem, inclusive profundidade de cor, podemos usar a função imfinfo() com o nome do arquivo da imagem como parâmetro.

>> imfinfo('lenina.ppm')

ans =

Filename: 'lenina.ppm'

FileModDate: '01-Nov-2005 12:22:16'

FileSize: 196646

Format: 'PPM'

FormatVersion: 'P6'

Width: 256


Prof Kesede R Julio

Height: 256

BitDepth: 24

ColorType: 'truecolor'

FormatSignature: 'P6'

Encoding: 'rawbits'

MaxValue: 255

ImageDataOffset: 38

Neste caso temos uma imagem de 3 camadas (frames) de 8 bits de profundidade cada uma.

Neste laboratório o arquivo de imagem é RGB, apenas é visualizado como nível de cinza. Logo, o valor do mesmo pixel em cada uma das camadas é o mesmo. Por isso, eliminamos as camadas 2 e 3 (f(:,:,1)) afim de otimizar o algoritmo.

7.2.1 Laboratório

Em matlab, seria:


>> imshow(f(:,:,1));

>> f64=floor(double(f(:,:,1))*64/256);

>> imshow(f64,[]);

>> f8=floor(double(f(:,:,1))*8/256);

>> imshow(f8,[]);

>> f2=floor(double(f(:,:,1))*2/256);

>> imshow(f2,[]);


Prof Kesede R Julio

imagem Original Imagem quantizada para 64 cores (6 bits)

Imagem quantizada para 8 cores (3 bits) Imagem quantizada para 2 cores (1 bit)

Note que na imagem de 6 bits não percebemos os níveis de quantização, na imagem de 3 bits os níveis são percebidos e na imagem de 1 bit a percepção das bordas de quantização é tão grande que perdemos a visualização da imagem. Ou seja, este método de quantização não é eficiente para níveis muito baixos de quantização.

Afim de minimizar o problema, foi proposto um método chamado Dithering (ou algoritmo de meio-tom). O método toma por base que a percepção de detalhes em uma imagem depende, basicamente, de 3 coisas: distância da imagem, densidade de resolução da imagem e abertura do olho.

A indústria gráfica se utiliza deste método para fabricação de jornais e revistas. O método consiste em aglomerar, ordenadamente ou não, os pixels de forma a gerar ilusões de meio-tom ao olho humano. Quanto mais aglomerado os pixels pretos, maior a ilusão de intensidade mais escura, e portanto quanto menor a densidade dos pontos, maior a ilusão de intensidade mais clara. Exemplo:


Prof Kesede R Julio

Vamos criar uma imagem binária da lenina usando dithering.

>> fd=dither(f(:,:,1));

>> imshow(fd);

Podemos notar que, apesar de termos apenas duas cores, ganhamos muito mais detalhes visuais na imagem. Compare esta imagem com a quantização de duas cores (imagem binária).

7.2.2 Relatórios

7.2.2.1 Faça os mesmos testes do laboratório anterior, agora com uma foto sua. Os testes devem contemplar todos os níveis de quantização de 8 a 1 bit, assim como a aplicação do dithering. Verifique em qual transição se dá a perceptividade dos níveis de quantização. Faça comentários explicativos.


Prof Kesede R Julio

7.3 Amostragem

Além do aumento ou diminuição dos níveis de cinza da imagem, a sua resolução, como já foi citado, passa pela amostragem, ou seja, quantidade de pontos que representam a imagem.Se temos uma imagem de 256x256 de 8 bits (256 níveis de cinza), nem percebemos os efeitos da amostragem, porém ao diminuirmos a quantidade de pontos para 128x128, ou 64x64, começamos a sentir falta de pontos que representem pixels intermediários entre dois pontos.

Dependendo da aplicação da visualização da imagem, isto pode ser conveniente, pois quanto menor a representação, menor o espaço ocupado e melhor performance dos algoritmos que serão executados sobre esta imagem. A função imresize(), permite-nos verificar este efeito de amostragem.

7.3.2 Laboratório

Leia a imagem original


Mostre a imagem

>> image(f);

Faça a amostragem da imagem original para 128x128

>> f128x128=imresize(f,[128 128]);

Mostre a imagem

>> image(f128x128);


>> f64x64=imresize(f,[64 64]);

Mostre a imagem

>> image(f64x64);


>> f32x32=imresize(f,[32 32]);

Mostre a imagem

>> image(f32x32);


Prof Kesede R Julio

Imagem Original (256x256) Imagem amostrada (128x128)

Imagem amostrada (64x64) Imagem amostrada (32x32)

Pronto! Perceba que nas imagens amostradas existem bordas amostrais evidentes.

7.3.2 Relatórios

7.3.2.1 Faça os mesmos testes do laboratório anterior, agora com uma foto sua. Os testes devem contemplar até 4 níveis do tamanho da imagem. Verifique em qual nível de amostragem se dá a perceptividade das bordas. Faça comentários explicativos


Prof Kesede R Julio

7.4.Histograma

Histograma é o gráfico das intensidades de uma imagem. Ou seja, através dele podemos verificar como se distribui a intensidade de cada pixel na imagem. Cada ponto deste gráfico representa a quantidade de pixels de uma determinada intensidade, portanto, o eixo x deste gráfico indica a variação de intensidade e o eixo y indica a quantidade de pixels. Através do histograma da imagem podemos decidir sobre várias operações a serem realizadas e como realizar estas operações. Um exemplo clássico é a melhora de contraste da imagem através da equalização do seu histograma. Equalizar um histograma significa distribuir todas as intensidades dos pixels da imagem entre os valores de intensidade máximo e mínimo da própria imagem. Assim, temos:

Imagem original Histograma da imagem original

Imagem equalizada Histograma da imagem equalizada


Prof Kesede R Julio

7.4.1 Laboratório

Leia e mostre a imagem original.


>> imshow(f);

Extraia o histograma da imagem e guarde em outra variável. Esta variável será um vetor unidimensional. Mostre este vetor afim de certificar-se disto.

>> figure, imhist(f(:,:,1))

Note que os valores de intensidade da imagem não estão distribuídos de maneira uniforme, ou seja, existem mais intensidades escuras que claras.

Agora, melhore o contraste desta imagem através da equalização de seu histograma.

>> fhe=histeq(f(:,:,1));

>> figure, imshow(fhe);

>> figure, imhist(fhe);

Note que agora as intensidades dos pixels estão melhores distribuídas no range de 0 a 255 e a imagem está mais clara, deixando os detalhes da imagem mais nítidos

7.4.2 Relatórios

Refaça o laboratório, agora utilizando sua foto. O que você pode concluir pelo histograma? A equalização melhora ou não a visualização de detalhes? Faça comentários explicativos.

7.5.Thresholding

O thresholding (limiarização) é a forma mais simples de segmentação de uma imagem. Claro que nem sempre é suficiente, porém é bastante utilizada quando queremos binarizar uma imagem, afim de separar uma determinada área de interesse do restante da imagem. Os valores de intensidade que estiverem acima do limiar tornam-se brancos e os que estiverem abaixo pretos. O valor de thresholding deve ser decidido de acordo com o nosso interesse, nem sempre a média, por exemplo, é um bom thresholding. Existem várias técnicas para decidir o seu valor, no entanto, faremos apenas alguns testes para entender o seu significado.


Prof Kesede R Julio

7.5.1 Laboratório

Leia e mostre a imagem

>>> f=imread('lenina.ppm');

>>> imshow(f)

Podemos converter a imagem de rgb para nível de cinza usando a função rgb2gray(), assim como extrair a média das intensidades através da função mean2(), que no caso da lenina é 61. Aplique o thresholding usando a média e mostre a imagem.

>> fg=rgb2gray(f);

>> mean2(fg)

>> f61=fg>61;

>> imshow(f61)

Agora, aplicamos um limiar de 30.

>>> f30=fg>30;

>>> imshow(f30)

E agora de 90.

>>> f90=fg>90;

>>> imshow(f90)

Imagem original Imagem c/ trhesholding de 30

Imagem c/ trhesholding de 61

(média)

Imagem c/ trhesholding de 90

Perceba que a imagem torna-se mais escura a medida que aumentamos o thresholding. O melhor caso, pelo menos em termos de resgate das


Prof Kesede R Julio

características originais da imagem, é o valor médio, porém as vezes desejamos destacar uma determinada particularidade, mais escura ou mais clara.

Podemos também usar vários valores de thresholding em uma única imagem, caso queiramos separar objetos de luminosidade diferentes. Nisto o histograma da imagem pode ser uma boa ferramenta de análise para sabermos como estão distribuídas as intensidades dos objetos na imagem.

7.5.2 Laboratório

Primeiramente lemos a imagem do disco, guardamos na variável f e visualizamos a imagem.

>> f=imread('keyb.pgm');

>> imshow(f)

Convertemos a imagem para nível de cinza.

>> f=rgb2gray(f);

Depois disto, extraímos o histograma da imagem.

>> figure,imhist(f);

podemos observar uma concentração de valores em torno dos intervalos 20-50 e 150-180 e também em torno do 255. Com isso, podemos entender que se passarmos thresholding por estes valores, partes significativas da imagem poderá ser destacada.

>> teclas=f>20 & f<50;

>> imshow(teclas)

claro que com alguns ajustes podemos melhorar aquilo que queremos destacar.

>> fundo=f>150 & f<180;

>> imshow(fundo)

até mesmo intuitivamente podemos perceber que os valores 255 são os números das teclas.

>> nr=f==255;

>> imshow(nr)


Prof Kesede R Julio

Imagem original Histograma Im. Orig

teclas fundo números

7.5.2 Relatório

Escolha uma imagem com, pelo menos, dois objetos (grãos de arroz e de milho, por exemplo) separáveis pelo método visto no laboratório 7.5.2. Refaça o procedimento do laboratório (usando o histograma para separar os objetos), agora considerando esta imagem. Faça comentários explicativos sobre cada operação.

5.6 Filtros

A idéia de filtro (máscara, template etc) é executar uma operação sobre uma imagem afim de modificá-la. Esta operação é realizada utilizando-se a vizinhança de cada pixel da imagem, assim como uma matriz (máscara, geralmente 3x3) com um pixel central determinado, o qual será a referência para a operação de cada pixel da imagem. Os valores desta matriz é que definirá a imagem resultante. A vizinhança de um pixel depende da abordagem da operação. Podemos ter vizinhança 8 ou 4. Estes números definem a quantidade de pixels que serão considerados na operação.

Exemplo:

Imagem

10 23 1 14

35 2 50 20

5 2 25 24

9 11 32 7

Filtro

1 2 -1

1 2 -1

1 2 -1


Prof Kesede R Julio

A regra para o cálculo do pixel central é sempre a divisão da quantidade de colunas por 2 e a divisão da quantidade de linhas por 2, arredondando para cima as casas decimais. Logo, em um filtro de 3x3 teremos a posição (2,2) como centro, em um de 4x4, continuamos com a posição (2,2) como centro, e assim por diante. O fato é que normalmente usamos uma matriz quadrada de ordem ímpar (3x3, 5x5, 7x7 etc) para usarmos como filtro. Uma vez que o pixel central do filtro deve ser posicionado sobre cada pixel da imagem, a imagem ganha um contorno de valor zero (zero-padding) para que os pixels da borda da imagem possam ser processados. Assim, a imagem processada será:

0 0 0 0 0 0

0 10 23 1 14 0

0 35 2 50 20 0

0 5 2 25 24 0

0 9 11 32 7 0

0 0 0 0 0 0

A área cinza representa o filtro com seu centro localizado no primeiro pixel da imagem. Dessa forma, a combinação linear a ser processada seria:

im(1,1)=1.0+2.0+(-1).0+1.0+2.10+(-1).23+1.0+2.35+(-1).2=65

Isto ocorrerá em cada posição da imagem, pois o filtro percorre seu centro sobre cada pixel.

Em uma imagem real, a imagem resultante pode ganhar um contorno indesejável que pode ser contornado através do parâmetro 'replicate' da função imfilter do MatLab. Este parâmetro gera o contorno através da replicação dos valores de borda da própria imagem.

10 10 23 1 14 14

10 10 23 1 14 14

35 35 2 50 20 20

5 5 2 25 24 24

9 9 11 32 7 7

9 9 11 32 7 7

Através dos filtros podemos suavizar a imagem, eliminar ruídos, melhorar contraste, detectar bordas ou mesmo realizar efeitos artísticos. Os filtros podem ser classificados em passa-alta, passa-baixa e passa-faixa.

Os filtros passa-alta permitem que altas frequências (mudança brusca em valores de pixels próximos) permaneçam na imagem, eliminado as baixas frequências.


Prof Kesede R Julio

Os filtros passa-baixa permitem que baixas frequências (pequena ou nenhuma mudança em valores de pixels próximos) permaneçam na imagem, eliminado as altas frequências.

Os filtros passa-faixa permitem que faixas de frequências permaneçam na imagem, eliminado as que estiverem fora da faixa. Este tipo de filtro tem seu uso bem específico.

Cada tipo de filtragem requer mudanças dos valores e tamanho dos filtros. Mostramos abaixo alguns destes filtros.

Filtro de Média (passa-baixa)

Este tipo de filtro é construído atribuindo-se 1 para todos os coeficientes da máscara e dividindo-se cada um deles pelo total de coeficientes. Quanto maior a máscara maior a redução do contraste e a perda da definição da imagem. Por exemplo, em uma máscara 3x3, seria:

h=19

.[1 1 11 1 11 1 1]

Filtro Gaussiano (passa-baixa)

Este filtro é uma aproximação digital da função gaussiana. É muito utilizado para reduzir ruídos na imagem, pois preserva mais os contornos que o filtro de média. Um exemplo de um filtro gaussiano seria:

h=1

273.[

1 4 7 4 14 16 26 16 47 26 41 26 74 16 26 16 41 4 7 4 1

]Filtro Sobel (passa-alta)

A aplicação deste filtro permite realçar as bordas da imagem através de 2 filtros, um horizontal, outro vertical. O objetivo disto é destacar altas frequências nos dois sentidos. Os dois filtros, são:

hh=[−1 −2 −10 0 01 2 1 ]


Prof Kesede R Julio

hv=[−1 0 1−2 0 2−1 0 1]

Além destes, diversos filtros poderiam ser construídos para aplicações diferentes. O Matlab, através da função fspecial(<filtro>), permite a construção de vários deles:

Filtro Descrição

'gaussian' Gaussiano

'sobel' Sobel com enfase horizontal

'prewitt' Prewitt com enfase horizontal

'laplacian' Laplaciano

'log' Laplaciano do filtro Gaussiano

'average' Média

'unsharp' Unsharp (aumento de contraste)

5.6.1 Laboratório

Vamos trabalhar primeiro com imagens pequenas para verificarmos melhor os efeitos do filtro nos valores da imagem.

A função “magic” cria uma matriz quadrada de números aleatorios. Usaremos esta função para simularmos nossa imagem.

>> im=magic(4)

Criamos agora um filtro h com valor negativo.

>> h=[-1 0 1]

Aplicamos o filtro a imagem.

>> imf=imfilter(im,h)

Para que você confira seu entendimento, faça os cálculos na mão de pelo menos um dos pixels e valide seus cálculos com o resultado do imfilter. Em uma imagem real o tipo dos valores são considerados de forma que os valores negativos se tornem zero e os valores acima do range do tipo seja truncado. Por exemplo, se a imagem é uint8 e os resultados forem fracionários, os valores decimais serão desconsiderados.

Leia a imagem do arquivo e mostre-a.

>> f=imread('cookies.pgm');

>> imshow(f)

Crie um filtro de média.


Prof Kesede R Julio

>> h=ones(3)/9

Aplique o filtro sobre a imagem

>>fh=imfilter(f,h)

Mostre as duas imagens em um mesmo figure.

>> subplot(1,2,1),imshow(f),title('Imagem Original'),...

subplot(1,2,2),imshow(fh),title('Imagem filtrada')

Im a g e m O r i g i n a l Im a g e m fi l t r a d a

Para processar imagens coloridas (rgb) basta usar a mesma metodologia. Neste caso, o filtro é passado em cada canal de cor.

5.6.2 Relatórios

1. Faça laboratório acima (filtro de média) com uma imagem nível de cinza (2D) e uma colorida (3D).

2. Escolha uma imagem com ruído e detecte suas bordas. Aplique o filtro Gaussiano e em seguida o filtro Sobel ou outro que melhor solucione seu problema.

5.7 Morfologia Matemática

A morfologia pode ser aplicada para realce de imagens, esqueletização, segmentação, filtragem etc. As operações morfológicas consistem na relação das imagens com formas menores e especificamente definidas chamadas elemento estruturante, através da teoria dos conjuntos. Temos duas operações morfológicas principais: dilatação e erosão. A dilatação (União) acrescenta uma área na imagem através de uma forma padrão (Elemento Estruturante). A erosão


Prof Kesede R Julio

(Intersecção) exclui da imagem formas que não atendam a um determinado padrão (Elemento Estruturante). Estas operações podem ser realizadas sobre imagens binárias, tons de cinza ou coloridas, porém em cada uma delas o significado será diferente. Veremos apenas operações morfológicas em imagens binárias e tons de cinza.

5.7.1 Dilatação

A dilatação sempre aumenta o tamanho da imagem, pois a operação realizada é de União. Abaixo será mostrado o processo de dilatação binária.

B = {(0,0), (1,0)}

A marcação do primeiro pixel na imagem denota a origem da imagem e a marcação do pixel no Elemento Estruturante denota o seu centro.

5.7.2 Erosão

A erosão sempre diminui o tamanho da imagem, pois a operação realizada é de intersecção. Abaixo será mostrado alguns exemplos de erosão.


Prof Kesede R Julio

O conjunto de pontos resultantes da erosão é a o conjunto de pontos que interceptam totalmente A e B.

5.7.3 Abertura

Uma Abertura Morfológica é uma erosão seguida imediatamente de uma dilatação com mesmo elemento estruturante. Ela tende a abrir pequenos espaços vazios entre objetos da imagem muito próximos. Também pode ser usada para eliminar ruídos na imagem. Veja o exemplo abaixo.

5.7.4 Fechamento

Um Fechamento Morfológico é uma dilatação seguida imediatamente de uma erosão com mesmo elemento estruturante. Ele tende a eliminar buracos na imagem, ou seja, fecha espaços vazios. Também pode ser usada para eliminar ruídos na imagem. Veja o exemplo abaixo.


Prof Kesede R Julio

5.7.5 Morfologia em Tons de Cinza

A idéia aqui se modifica um pouco devido aos valores da imagem. O que é União, passa a ser o valor máximo. O que é Intersecção passa a ser o valor mínimo. Abaixo estão algumas imagens nível de cinza onde foram aplicadas cada operação morfológica vista.

5.7.6 Laboratório

Vamos agora praticar o uso das ferramentas morfológicas.

Comecemos pela dilatação. Leia a imagem text.png.

>> textobw = imread('text.png');

Agora crie um EE de linha vertical (90º) de tamanho de 22 pixels.

>> ee = strel('line',11,90);

Use o EE criado para dilatar a imagem e mostre a imagem original e a dilatada.

>> textobw2 = imdilate(textobw,ee);>> imshow(textobw), title('Original')>> figure, imshow(textobw2), title('Dilatado')


Prof Kesede R Julio

Faça uma dilatação com a imagem cameraman.tif. Leia a imagem.

>> fotografo = imread('cameraman.tif');

Crie um EE de uma bola de raio 5.

>> ee = strel('ball',5,5);

Faça a dilatação da imagem usando o EE criado.

>> fotografo2 = imdilate(fotografo,ee);

Mostre as duas imagens (original e dilatada).

>> imshow(fotografo), title('Original')>> figure, imshow(fotografo2), title('Dilatada')

Perceba que a imagem ficou mais claro, pois cada pixel da imagem visitado pelo centro do elemento estruturante, assumiu o maior valor de sua vizinhança (considerada pela forma do EE).


O r i g i n a l D i l a t a d o

D i l a t a d aO r i g i n a l

Prof Kesede R Julio

Agora faremos uma erosão em uma imagem binária e depois em uma tom de cinza.

Leia a imagem binária circles.png e mostre-a.

>> circulosBW = imread('circles.png');

>> imview(circulosBW)

Perceba que os círculos estão sobrepostos. A função imview() é uma outra forma de mostrar imagens (experimente as ferramentas da janela).

Vamos agora construir o Elemento Estruturante através da função strel(). Neste caso, é construído um disco de 11 pixels de raio. (Acesse o help do Matlab para verificar as diversas possibilidades de construção do EE através do strel()). Você não precisa, necessariamente, usar o strel(). Você pode construir seu EE através de uma matriz qualquer.

ee = strel('disk',11);

Vamos agora, erodir a image e mostrá-las (original e erodida) para comparação.

circErodBW = imerode(circulosBW,ee);

imview(circulosBW), imview(circErodBW)

Perceba que agora temos os círculos separados, o que facilita muito uma eventual análise destes objetos.

Imagem (binária) original Imagem Erodida

Experimente agora erodir uma imagem nível de cinza utilizando o script abaixo:

fotografo= imread('cameraman.tif');

ee = strel('ball',5,5); % constrói uma bola de raio 5


Prof Kesede R Julio

fotografo2 = imerode(fotografo,ee);

imshow(fotografo), title('Original')

figure, imshow(fotografo2), title('Erodida')

Este script pode ser colocado dentro de arquivo .m e executado a partir do prompt do matlab. Faça isto.

Perceba que a imagem ficou mais escura, pois cada pixel da imagem visitado pelo centro do elemento estruturante, assumiu o menor valor de sua vizinhança (considerada pela forma do EE).

5.8 Estudo de Casos

Aqui estaremos listando algumas aplicações práticas de processamento de imagens. A idéia é que você possa utilizar as ferramentas aqui descritas para as suas próprias aplicações.

5.8.1 Análise de grãos de arroz

Primeiramente vamos ler a imagem do disco e mostrá-la em tela. Através do seu tamanho (size), podemos constatar ser uma imagem nível de cinza.

>> arroz=imread('rice.png');

>> imshow(arroz)

>> size(arroz)

Devido ao fundo da imagem ser irregular, podemos aplicar uma subtração do fundo afim de equalizá-lo. Primeiramente, criaremos uma imagem sem os grãos de arroz através de uma abertura morfológica.

>> fundo = imopen(arroz,strel('disk',15));

>> figure, imshow(fundo)


O r i g i n a l E r o d i d a

Prof Kesede R Julio

A função strel(), neste caso, cria uma imagem em forma de um disco de raio de 15 pixels. Este disco deve ser maior que os grãos, de tal forma que não consiga ser colocado totalmente dentro de nenhum deles. Desta forma removemos os grãos de arroz conforme mostra a imagem.

Agora podemos subtrair o fundo da imagem original, ficando assim os grãos de arroz sobre uma superfície totalmente preta.

>> arroz2 = imsubtract(arroz,fundo);

>> figure, imshow(arroz2)

Podemos então melhorar o contraste desta imagem, usando a função imadjust().

>> arroz3 = imadjust(arroz2);

>> figure, imshow(arroz3)

Apesar de estar bem destacado o que queremos (grãos de arroz), ainda temos uma imagem nível de cinza. Podemos agora binarizar esta imagem usando thresholding. A função graythresh() calcula um valor apropriado para fazer a conversão de nível de cinza para binário. A função im2bw() binariza uma imagem nível de cinza considerando o valor do limiar.

>> limiar = graythresh(arroz3);

>> arrozbw = im2bw(arroz3,limiar);

>> figure, imshow(arrozbw)

Na imagem binarizada podemos aplicar a função bwlabel() que contará quantos componentes existem na imagem (numObjects), além de rotular numericamente (arrozRot), cada um dos componentes. Estes resultados dependerão de alguns fatores, como: 1) tamanho dos componentes; 2) componentes que se tocam formando um único componente; 3) tipo de conectividade, neste caso, 4.

>> [arrozRot,numObjetos] = bwlabel(arrozbw,4);

>> numObjetos

numObjetos =

101

Isto mostra que temos 101 grãos de arroz na imagem. A imagem pode ser vista através da visualização de cores sintéticas para cada componente usando label2rgb().

>> pseudo_color = label2rgb(arrozRot, @spring, 'c', 'shuffle');

>> imshow(pseudo_color);


Prof Kesede R Julio

Abaixo podemos ver as imagens geradas pela função imshow() resultante de cada uma das operações vistas até aqui.

Imagem original (imread())

Remoção dos grãos de arroz (imopen())

Imagem com fundo regular (imsubtract())

Melhora de contraste (imadjust())

Imagem binarizada (imbw())

Imagem colorida sinteticamente (label2rgb())


Prof Kesede R Julio

Além de contar componentes, podemos também extrair algumas informações destes componentes, através da função regionprops(), que retornará em uma estrutura, a área (em pixels), o centro de massa e o retângulo que envolve (bounding box) cada um dos componentes.

>> arrozDados = regionprops(arrozRot,'basic')

arrozDados =

101x1 struct array with fields:

Area

Centroid

BoundingBox

Assim, para sabermos o valor da área do 10º componente da imagem, seu centroid e o retângulo que o envolve, usamos:

>>arrozDados(10).Area

ans =

176

>> arrozDados(10).BoundingBox

ans =

9.5000 86.5000 25.0000 17.0000

>> arrozDados(10).Centroid

ans =

21.3693 95.9716

Dado o valor da área de cada componente (arrozDados.Area), algumas questões estatísticos podem ser levantadas, como:


Prof Kesede R Julio

Qual o tamanho do maior grão?

>> max([arrozdados.Area])

ans =

404

Qual o grão de maior tamanho?

>> maiorgrao = find([graindata.Area]==404)

maiorgrao =

59

Qual a média dos tamanhos dos grãos?

>> mean([graindata.Area])

ans =

175.0396

5.9 Reconhecimento de Padrões

O reconhecimento de Padrões de imagem sugere a identificação de padrões ou objetos dentro de uma determinada imagem. As técnicas envolvidas permitem a classificação dos objetos determinando sua separabilidade.

Um sistema de RP deveria ser capaz de extrair informações a partir de um conjunto de informações irrelevantes, aprender por exemplos e generalizar o conhecimento para outros contextos, inferir informações a partir de informações incompletas. Sabemos que nossa inteligência tem esta capacidade, porém para um computador a tarefa fica mais difícil. Estas dificuldades acabam por gerar sistema super-especialistas.

Podemos dividir a tarefa de identificação em processamento de três níveis: baixo, médio e alto.

No nível baixo temos a captura da imagem (fotografia, escaneamento, imagem por satélite etc) através de um sensor e um pré-processamento na imagem (contraste, ruído, ajustes etc) para melhorar a performance do sistema.

No nível médio podemos aplicar processos de separação das áreas de interesse (segmentação), assim como determinar sua representação (vetor, árvore etc). Esta fase pode exigir alguma inteligência do sistema, como por exemplo, encontrar picos, texturas etc.

Já em alto nível temos efetivamente o processo de reconhecimento através de comparação com padrões pré-estabelecidos ou não (sistemas autômatos). Aqui


Prof Kesede R Julio

os resultados são interpretados e mostrados ao usuário que poderá aplicar uma validação para garantir a implantação ou não do sistema. A inteligência do sistema nesta fase é fortemente exigida, uma vez que quanto menos aplicada, menos automático será o reconhecimento.

A figura abaixo mostra uma estrutura básica de RP.


Pré-processamento

Captura da imagem

Segmentação Representação

Base de conhecimento Reconhecimento

Nível Baixo

Nível Médio

Nível Alto

Problema

Resultado

computação gráfica - 2011

Documents