Computação gráfica

Prof Kesede R Julio
Prof Kesede R Julio
kesedejulio@gmail.com
Apostila de
Computação Gráfica
e
Processamento de Imagem
Campinas – SP - Brasil
Computação Gráfica e Processamento de Imagem 1

Prof Kesede R Julio
Índice
Capítulo 1.Introdução..............................................................................................................3
1.1.Breve Histórico 3
1.2.Contextualização 7
1.3Aplicações 7
1.4Dispositivos Gráficos 8
1.5Resolução Gráfica 9
1.6Sistemas de Coordenadas 10
1.1Exercícios 11
Capítulo 2.Conversão Matricial de Curvas...........................................................................13
2.1.Objetivo 13
2.2Primitivas de Saída Gráfica 13
2.3.Algoritmo de Ponto Médio (Bresenham)24
2.1. Exercícios 30
Capítulo 3.Transformações Geométricas..............................................................................31
3.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 45
4.3 Varredura 46
4.4 Decomposição 46
4.5 GSC – Geometria Sólida Construtiva 47
4.6 Fronteira 48
Capítulo 5 Curvas e Superfícies..........................................................................................50
Capítulo 5 .1 Curvas.............................................................................................................50
Capítulo 6.Fundamentos de Cor............................................................................................55
6.1 Conceitos Básicos 55
6.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 66
7.4.Histograma 68
7.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: 1961
Instituto: MIT
Gênero: Arcade (?)
Gráfico: Duas cores
Som: Nenhum
Comportamento: 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: 1972
Empresa: Atari
Gênero: Arcade
Gráfico: Duas cores
Som: 1 bit
Comportamento: 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)).
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.

Prof Kesede R Julio
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.
Realidade Virtual. O modelo de uma rua
da cidade de Nova York.
1.2.Contextualização
Modelagem
Geomé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
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
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çáveis 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

Prof Kesede R Julio
buffer (memória de vídeo), 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.
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

Prof Kesede R Julio
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
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

Prof Kesede R Julio
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
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)

Prof Kesede R Julio
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
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
Nestas condições o segmento corta um maior numero de verticais que horizontais
Exemplos de resultados pelo critério 3

Prof Kesede R Julio
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);
}
void traca( float x1, float y1, float x2, float y2){

Prof Kesede R Julio
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<<"nn";
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
// especifica o uso de buffer e modo de cores
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
// especifica as dimensoes da janela
glutInitWindowSize (256, 256);
// especifica aonde a janela aparece na tela
glutInitWindowPosition (100, 100);
glutCreateWindow ("Desenhando uma linha"); // cria a janela
init();
// funcao que sera redesenhada pelo GLUT

Prof Kesede R Julio
glutDisplayFunc(display);
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
// define os eixos do modo de projecao ortogonal
glOrtho (0, 256, 0, 256, -1 ,1);
}
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;
}
}
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

Prof Kesede R Julio
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);
printf("Entre com o valor de yc: ");
scanf("%f",&yc);
printf("Entre com o valor do raio: ");
scanf("%f",&raio);
circ(xc,yc,raio);

Prof Kesede R Julio
}
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;
glClear(GL_COLOR_BUFFER_BIT); // apaga tela
// define ponto central e raio
xc=80;
yc=80;
r=50;

Prof Kesede R Julio
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 Θ
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>

Prof Kesede R Julio
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();
ang_rad=(ang*3.14)/180;
x = xc + (r1 * cos (ang_rad));
y = yc + (r2 * sin (ang_rad));

Prof Kesede R Julio
}
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 xi 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.
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
NE
P=(xp
,yp
) E
M
I
xp
+1xp
yp
yp
+1

Prof Kesede R Julio
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=axb ,
sendo a=
dy
dx
e dy=y2−y1
e dx=x2−x1
Substituindo na equação temos:
y=
dy
dx
xb
Agora podemos igualar esta equação a zero, assim:
y=
dy
dx
x+ b
y=
dy⋅x
dx
+ b (multiplicaçãoda fração por x/1)
y=
dy⋅x+ b⋅dx
dx
(divide pelo denominador e multiplica pelo numerador)
dx⋅y=dy⋅x+ b⋅dx (transportao 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 função de sua inclinação, conseguimos os termos
da equação implícita, assim:
Logo,
Fx , y=axbyc=0
F (x , y)=dy⋅x−dx⋅y+b⋅dx=0
a=dy
b=−dx
c=b⋅dx

Prof Kesede R Julio
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,
dnovo=F xp2, y p
1
2
=axp2b yp
1
2
c
e
danterior=axp1b yp
1
2
c
Subtraindo danterior de dnovo obtemos a diferença incremental ΔE.
axp2abyp
1
2
bc
−
axp aby p
1
2
bc
=
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,
dnovo=F xp2, y p
3
2
=axp2b yp
3
2
c
e

Prof Kesede R Julio
danterior=axp1b yp
1
2
c
Subtraindo danterior de dnovo obtemos a diferença incremental ΔNE.
axp2abyp
3
2
bc
−
axp aby p
1
2
bc
=
ab
Δ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).
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 =dinicial=axp1by p
1
2
c=
=axpabyp
b
2
c=
=axpbypca
b
2
=
= Fxp , ypa
b
2
=
=a
b
2
Também afim de eliminar a fração multiplicamos por 2, e portanto,
dinicial =2ab=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=x
2
y
2
−R
2

Prof Kesede R Julio
Trataremos do traçado da circunferência apenas para o segundo octante (
0≤x≤R⋅ 2e R≥y≤R 2 ), todos os demais pontos poderão ser traçados por
simetria.
Neste caso, dado um ponto Pxp , yp , 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−
1
2
 . Substituindo este ponto da equação, temos:
F1, R−
1
2
=1R
2
−R
1
4
−R
2
=
5
4
−R
2
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:
danterior=F xp1, yp−
1
2
=xp1
2
 yp−
1
2

2
−R
2
dnovo=F xp2, y p−
1
2
=xp2
2
 yp−
1
2

2
−R
2
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:
SE
E
M
P=(xp
,yp
)
xp xp
+1
yp
yp
-1

Prof Kesede R Julio
danterior=xp1
2
− = xp
2
2xp 11
2
− = xp
2
2xp1−
dnovo =xp2
2
− = xp
2
2xp 22
2
− = xp
2
4xp4−
ΔE=2xp3
Caso SE seja escolhido, temos:
dnovo=F xp2, y p−
3
2
=xp22
 yp−
3
2

2
−R2
Desta forma, fazendo a subtração com o danterior , 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:
danterior=xp1
2
 yp−
1
2

2
−=
xp1
2
 yp
2
−2⋅y p⋅
1
2

1
2

2
− =
x p1
2
 yp
2
− yp
1
4
−
dnovo = x p2
2
y p−
3
2

2
− =
xp2
2
 yp
2
−2⋅yp⋅
3
2

3
2

2
− =
x p2
2
 yp
2
−3yp
9
4
−
ΔE=2xp3−2y p2=2xp−2yp5
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 =
[x
y]
P'=
[x'
y' ]
T =
[tx
ty]
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]⋅
[x
y]
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
(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 ]⋅[x
y]
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
x
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 =
[
tx
ty
tz]

Prof Kesede R Julio
Escala:
S=
[
sx 0 0
0 sy 0
0 0 sz]
Rotação:
R=
[
cos −sen 0
sen 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 0
0 0 1]
Sobre o eixo x (no plano yz):
R=
[
1 0 0
0 cos −sen
0 sen cos ]
Sobre o eixo y (no plano xz):
R=
[
cos 0 −sen
0 1 0
sen 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 tx
0 1 ty
0 0 1 ]⋅
[
x
y
1]
Escala: P’ = S * P
P'=S⋅P
[
x'
y'
1 ]=
[
sx 0 0
0 sy 0
0 0 1]⋅
[
x
y
1]
Rotação: P’ = R * P
P'=R⋅P
[
x'
y '
1 ]=
[
cos −sen 0
0 0 1]⋅
[
x
y
1]

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:
Pt =∑
i=0
n
Bi J n, it 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, it=
n
i
t
i
1−t
n−i

Prof Kesede R Julio
Onde: n é o grau dos polinômios e

n
i
=
n!
i !n−i!
i=0,1,...n
são os coeficientes binomiais. Estas funções devem satisfazer as condições:
J n, it≥0 para todo i entre 0 e 1, isto é, 0≤i≤1
e
∑
i=0
n
J n, it=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:
Pt =B0 J 2,0t B1 J 2,1t B2 J 2,2t
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−2tt
2
J 2,1=
2!
1! 1!
t1
1−t 1
=2t1−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:
Pt =1−t
2
B02t1−t B1t
2
B2
Matricialmente, teremos:
Pt =[1−t
2
 2t1−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
Pt =[t2
t 1]
[
1 −2 1
−2 2 0
1 0 0][
B0
B1
B2
]
Resumindo, poderíamos ter a seguinte representação:
Pt =T MB 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:
valordo pixelatual
nr 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=
1
9
.
[
1 1 1
1 1 1
1 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 1
4 16 26 16 4
7 26 41 26 7
4 16 26 16 4
1 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 −1
0 0 0
1 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 rig in a l Im a g e m filt ra 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 ig in a l D ila t a d o
D ila t a d aO r ig in 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 ig in a l E r o d id 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

Mais conteúdo relacionado

Mais procurados

Semelhante a Computação gráfica

Computação gráfica