Capitulo 07

Computação Gráfica I
CRAb – Grupo de Computação

Gráfica
Departamento de Computação
UFC
Objetivos
•  Estudar
–  equipamentos, técnicas de programação e
conceitos matemáticos
•  Para
–  representação, manipulação e projeção de
objetos bi- e tridimensionais
–  aplicar a problemas específicos
2
Sumário do Curso
•  Sistemas Gráficos e Modelos

•  Programação Gráfica
•  Input e Interação
•  Objetos Geométricos e Transformações
•  Visualização
•  Pintura
•  Implementação de um Renderizador
•  Técnicas Discretas
3
Implementação de um
Renderizador
7. Estudo das primitivas
gráficas de saída
7.1 Introdução
7.2 Pontos
7.3 Segmentos de retas e polígonos
7.4 Círculos
7.5 Elipses
7.6 Arcos e setores
7.7 Retângulos
7.8 Preenchimento de regiões
5
7.1 Introdução
•  Construção básica de figuras

–  Ponto
–  Segmento de linha reta
–  Curvas
–  Áreas preenchidas
–  Texto
OBS: Assumir que dados geométricos são
especificados em coordenadas do
dispositivo
6
7.2 Ponto ...
•  Especificar
–  coordenadas (x, y)
–  intensidade
–  Obs: em sistemas preto e branco
especificar apenas (x,y)
–  setPixel(x,y)
•  Desenho de Ponto
–  GKS
•  set_marker_type (int type)
•  polymarker (int num_points, WCPT *pts)
7
... Ponto ...
–  Phigs:
•  set_polymarker_type (type)
–  Type = 1: single pixel
–  Type = 2: +
–  Type = 3: *
–  Type = 4: o
–  Type = 5: x
•  polymarker (int num, float x, float y)
8
... Ponto
–  OpenGL:
glBegin(GL_POINTS);
glVertex2i(int x, int y)
glEnd();
9
7.3 Segmentos de Reta e
Polígonos ...
•  Definir extremidades (x1, y1) e (x2, y2)
–  Inclinação de uma reta:
–  Para qualquer linha reta: Δy = m Δx
y2
Δy
y1
Δx
x1 x2
10
... Segmentos de Reta e
Polígonos ...
•  Algoritmo DDA (Digital Differential
Analyzer) ...
–  Atribui incrementos unitários a uma
coordenada
–  Calcula o valor da outra coordenada
Se |m| < 1 e x2 > x1 Se |1/m| < 1 e y2 > y1
xi+1 = xi + 1 xi+1 = xi + 1/m
yi+1 = yi + m yi+1 = yi + 1
Se |m| < 1 e x2 < x1 Se |1/m| < 1 e y2 < y1
xi+1 = xi – 1 xi+1 = xi – 1/m
yi+1 = yi – m yi+1 = yi – 1
11
Polígonos ...
< 45o
12
... Algoritmo DDA ...
procedure dda (x1, y1, x2, y2 : integer);
var
dx, dy, steps, k : integer;
x_increment, y_increment, x, y : real;
begin
dx := x2 - x1;
dy := y2 - y1;
if abs(dx) > abs(dy) then steps := abs(dx)
else steps := abs(dy);
x_increment := dx / steps;
y_increment := dy / steps; 13
x := x1; y := y1;
setPixel (round(x), round(y));
for k := 1 to steps do begin
x := x + x_increment;
y := y + y_increment;
setPixel (round(x), round(y));
end {for k}
end; {dda}
14
void dda (int x1, int y1, int x2, int y2)
{
int dx, dy, steps, k;
float x_increment, y_increment, x, y;
dx = x2 - x1;
dy = y2 - y1;
if (abs(dx) > abs(dy) ) steps = abs(dx);
else steps = abs(dy);
x_increment = dx / steps;
y_increment = dy / steps;
15
x = x1;
y = y1;
setPixel (floor(x+0.5), floor(y+0.5));
for (k = 0; k < steps; k++)
{ x += x_increment;
y += y_increment;
setPixel (floor(x+0.5), floor(y+0.5));
}
} // fim do dda
16
Polígonos ...
•  Sistema vetorial
–  Gerador analógico de vetores gera linha
•  Voltagem de deflexão horizontal proporcional a
Δx
•  Voltagem de deflexão vertical proporcional a Δy
•  Sistema raster
–  Algoritmo de Bresenham
•  Determina pontos da matriz próximos à linha
17
... Algoritmo de Bresenham
para Traçado de Linhas ...
•  Método bastante veloz
•  Utiliza somente aritmética inteira
•  Evita operações caras em ponto
flutuante
–  multiplicação
–  divisão
•  Evita operações de arredondamento
18
•  Considere inclinação 0 < m ≤ 1:
–  Considere pixel (xi , yi ) sobre a linha
–  Se m < 1, próximo pixel mais próximo à
linha será (xi + 1, yi ) ou (xi+1 , yi + 1)
y=mx+b
yi+1 Seção do Raster

yi
xi xi+1
19
•  Processo de decisão
se (d1 – d2) < 0 => selecionar yi
se (d1 – d2) ≥ 0 => selecionar yi+1≡ yi+1
onde
(d1 – d2) = (y - yi) - (yi + 1 - y)
yi+1 = 2y - 2 yi - 1
= 2 [ m (xi + 1) + b ] - 2yi - 1
y d2
= 2 [ (Δy/Δx) (xi + 1) + b ] - 2yi - 1
yi d1
xi+1
20
•  Parâmetro de decisão
pi = Δx (d1 – d2 ) < 0, selecionar yi
≥ 0, selecionar yi + 1
onde
pi = 2 Δy xi - 2 Δx yi + [ 2 Δy + Δx (2b - 1)]
p0 = 2 Δy x0 - 2 Δx [(Δy/Δx) x0+ b] +
[2Δy + Δx (2b - 1)]
p0 = 2 Δy - Δx
Reduzir operações, obtendo pi+1 a partir de pi
21
pi = 2 Δy xi - 2 Δx yi + [ 2 Δy + Δx (2b - 1)]
pi+1= 2 Δy xi+1 - 2 Δx yi+1 + [ 2 Δy + Δx (2b -
1)]
pi+1- pi= 2 Δy(xi+1- xi) - 2 Δx(yi+1- yi)
pi+1= pi + 2 Δy(xi+1- xi) - 2 Δx(yi+1- yi)
Como xi+1= xi+1:
pi+1= pi + 2 Δy - 2 Δx(yi+1- yi)
22
•  Parâmetro de decisão incremental
pi+1= pi + 2 Δy - 2 Δx(yi+1- yi)
Se pi < 0, selecionar yi ⇒ yi+1-yi = 0
yi+1
pi+1= pi + 2 Δy y d2
yi d1
xi+i
23
pi+1= pi + 2 Δy - 2 Δx(yi+1- yi)
Se pi ≥ 0, selecionar yi+1 ⇒ yi+1- yi = 1

yi+1
y d2
pi+1= pi + 2 (Δy - Δx) yi d1
xi+i
24
Resumo do Algoritmo de
Bresenham (0 < m ≤ 1)
P1: Entrar extremos (x1, y1) e (x2, y2)
P2: Carregar pixel (x1, y1) no raster
P3: Calcular Δx = x2 – x1, Δy = y2 – y1 e p0 = 2 Δy - Δx
P4: A cada passo sucessivo :
Se p i < 0, => próximo ponto é (xi + 1, yi )
=> pi+1 = p i + 2 Δy
senão (pi ≥ 0) => próximo ponto é (xi + 1 , yi + 1)
=> pi+1 = pi + 2 (Δy – Δx)
Repetir o passo P4 até que xi = x2
Método envolve adição dos inteiros 2Δy e 2(Δy – Δx)
25
•  Simetria generaliza o algoritmo para os
demais quadrantes
y→y+1
x→x–1 x→x+1
y→y–1
26
X = Xstart ; Y = Ystart
dX = Xend – Xstart; dY = Yend – Ystart
Se dX > 0 Então Se dY > 0 Então

Xincr = 1 Yincr = 1
Senão Senão
Xincr = – 1 Yincr = – 1
dX = abs(dX) dY = abs(dY)
Fim Se Fim Se
27
Se dX > dY // |m| < 1 (incrementa x, decide y)
Então
P = 2dY – dX
Para K = 0 até dX Faça
setPixel(X, Y)
Se P > 0 Então
Y = Y + Yincr
P = P – 2dX
Fim do Se
X = X + Xincr
P = P + 2dY
Fim do Para
Fim do Então 28
Senão // |m| ≥ 1 (incrementa y e decide x)
P = 2dX – dY
Para K = 0 até dY Faça
setPixel(X, Y)
Se P > 0 Então
X = X + Xincr
P = P – 2dY
Fim do Se
Y = Y + Yincr
P = P + 2dX
Fim do Para
Fim do Senão
29
Exemplo: Algoritmo de
Bresenham
Pstart =(25, 15), Pend =(30, 5), m = - 2, dx > 0, dy < 0
15
10
25 30 30
Traçado de Polígonos
•  Polígono com n vértices

–  Aplica-se um algoritmo de traçado de
linhas n-1 vezes para conectar os n pontos
–  Em cada chamada sucessiva, passa-se o
par de coordenadas necessário para traçar
a próxima linha
–  n fecha o polígono se o n-ésimo ponto for
igual ao primeiro
31
Armazenamento de
Intensidades de Pixels …
•  Armazenamento por linhas num
sistema preto e branco
ymax
0 x xmax
(0, 0) (1, 0) ... (x, y) ... (xmax, ymax)

32
… Armazenamento de
Intensidades de Pixels
•  Armazenamento por linhas
–  Sistema preto e branco
Addr(X, Y) = Addr(0, 0) + Y (Xmax + 1) + X
•  Posições sucessivas em uma linha
Addr(X + 1, Y) = Addr(X, Y) + 1
Addr(X + 1, Y + 1) = Addr(X, Y) + (Xmax + 2)
somente uma adição é necessária
•  Cálculos similares para linhas com m >
1 ou com inclinações negativas
33
Antialiasing de Linhas …
•  Ajusta intensidades de pixels ao longo

de uma reta
–  Compensa o efeito-degrau produzido pelo
processo de rasterização
ymax
0 x xmax 34
… Antialiasing de Linhas …
•  Considerar a linha como retângulo com

largura de 1 pixel
•  Pintar cada pixel com intensidade
proporcional à área encoberta
35
•  Alternativa mais barata

–  Aproximar percentual de área coberta pela
distância do centro do pixel parcialmente
coberto à linha central da área retangular
•  Aumenta tempo de cálculo do algoritmo
de geração de linhas mas produz um
resultado melhor
36
•  Linhas de comprimentos diferentes

podem ter o mesmo número de pixels
•  Ambas as linhas têm 5 pixels, mas a
linha diagonal é maior por um fator
•  Linhas diagonais aparentam mais
apagadas do que linhas horizontais e
verticais
37
•  Para compensar esse problema

–  Ajustar a intensidade de uma linha em
função de sua inclinação
–  Maior intensidade para |m| = 1
–  Menor intensidade para m = 0 e m = ∞
38
Comandos para traçado de
linhas…
•  GKS
polyline (n, x, y)
•  n = 1 -> Um único ponto
•  n -> n-1 segmentos de linha conectados
–  Implementação
•  Múltiplas chamadas ao algoritmo de traçado de
linhas
–  Permite exibir pontos, eixos coordenados,
figuras geométricas, etc. com uma única
declaração
–  Especifica os elementos dos vetores x e y
como coordenadas absolutas
39
… Comandos para traçado de
linha
•  PHIGS
polyline (n, x, y)
•  OpenGL
–  glBegin ( GL_LINE_STRIP) ;
•  glVertex2i (x1, y1) ;
–  glEnd( ) ;
40
7.4 Círculos …
•  Cálculo de pontos ao longo da curva
2 2 2 2 2
(x − xc) + ( y − yc) = r ou y = yc ± r − ( x − xc)
•  Aritmética de ponto flutuante
–  consome bastante tempo
€ –  provoca falhas na curva
•  Cálculos na forma paramétrica evitam falhas
x = xc + r cos θ
y = yc + r sen θ
•  Computação ainda em ponto flutuante
41
… Círculos
•  Simetria Circular
–  Calcular coordenadas de 1/8 da
circunferência
(-x, y) (x, y) y=x
–  Obter demais pontos
por simetria
(-y, x) (y, x)
(-y, -x) (y, -x)
(-x, -y) (x, -y) 42

… Tratamento da Simetria de
Curvas
•  Procedimento Básico
–  Centra-se o círculo na origem (0, 0)
–  Incremento unitário em x a partir de (0, r)
até x = y
–  Translação do ponto (x, y) → (x + xc , y + yc)
yc yc
xc xc
43
Algoritmo do Ponto Médio
para Círculos …
•  Parâmetro de decisão é f(x, y)
f(x, y) = x2 + y2 - r2
–  Se
f(x, y) = 0, (x, y) está sobre a circunferência
f(x, y) < 0, (x, y) é interior à circunferência
f(x, y) > 0, (x, y) é exterior à circunferência
yk
yk+1
xk xk+1 x2 + y2 = r2
44
… Algoritmo do Ponto Médio
para Círculos …
•  Posição do próximo pixel depende do sinal de
pk = f(xk + 1, yk - 1/2)
= (xk + 1)2 + (yk - 1/2)2 - r2
pk+1 = f(xk+1 + 1, yk+1 - 1/2), com
xk+1 = xk + 1
yk
yk+1
xk xk+1 x2 + y2 = r2
45
para Círculos
•  Dois casos possíveis:
1. Se pk < 0, yk+1 = yk {circunferência passa
entre ponto médio e pixel superior}
pk+1= (xk+ 1)2 + 2(xk+1)+1 + (yk - ½ )2 - r2
pk+1= pk + 2(xk + 1) + 1 = pk + 2 xk+1 + 1
2. Se pk ≥ 0, yk+1 = yk - 1
pk+1= (xk+ 1)2 + 2(xk+ 1)+1+ (yk - ½ )2
- 2(yk - ½ ) + 1 - r2
pk+1 = pk + 2 xk+1 - 2 yk+1 + 1
46
para Círculos
  1 
•  No ponto inicial (0,r ) = 0, floor r + 
  2 
2
p0 = f (1,r −1 2) = 1 + ( r −1 2) − r 2
2
2 2 1 2 2 5
= r −r −€ r + +1= r − r − r +
4 4
5 > 0, se r = 1
Quando r for inteiro : r = r → p0 = − r → 
4  < 0, se r > 1
47
… Resumo do Algoritmo
1. Desenhar o primeiro ponto: (x0, y0) = (0, r)
2. Calcular o valor do parâmetro inicial, p0
3. A cada passo sucessivo
Se pk < 0, próximo ponto = (xk + 1, yk )
pk+1 = pk + 2 xk+1 + 1
Senão, próximo ponto = (xk + 1, yk - 1)
pk+1 = pk + 2 xk+1 - 2 yk+1 + 1
4. Para círculos centrados em (xc, yc),
translada-se: x = x + xc e y = y + yc
5. Determinam-se pontos nos outros octantes
48
Exemplo: Algoritmo do Ponto
Médio para Círculos
r = 10, p0 =
pk+1 = pk + 2 xk+1 + 1 (-2 yk+1 se pk > 0)
10
0
0 5 10 49
Elipses …
•  Generalizar o algoritmo do círculo

(Círculo é um tipo especial de elipse
onde rx = ry = r)
2 2 ry
[ (x - xc) / rx ] + [ (y - yc) / ry ] = 1 y
c
rx
•  Elipse centrada na origem
y2 = (ry / rx)2 (rx2 - x2) xc
•  Modificar parâmetro de decisão no
algoritmo do círculo para incluir ry2 / rx2
50
para Elipses …
região 1
ry
Inclinação = -1
rx
região 2
•  Parâmetro de decisão:
f(x, y) = ry2 x2 + rx2 y2 - rx2ry2
•  Primeiro quadrante
–  Dois parâmetros de decisão
•  Região 1: (0, ry) até (x, y) | dy / dx ≥ -1
•  Região 2: (x, y) | dy / dx < -1 até (rx, 0)
51
para Elipses …
•  Região 1: incrementar em x de (0, ry)
até dy/dx = -1 ⇒ ry2 x = rx2 y
–  ponto corrente: (xk, yk)
–  ponto médio: (xk + 1, yk - 1/2)
–  próximo ponto:
região 1
(xk + 1, yk) ou (xk + 1 , yk - 1)
ry
rx
52
para Elipses …
•  Região 2: incrementar em y
do último ponto da região 1 até (rx, 0)
–  ponto corrente: (xk, yk)
–  ponto médio: (xk + 1/2, yk - 1)
–  próximo ponto:
(xk, yk- 1) ou (xk+ 1, yk- 1)
ry
rx
região 2
53
para Elipses
•  Algoritmos para arcos
–  derivados dos algoritmos para
•  círculo
•  elipse
–  dados
•  coordenadas das extremidades ou
•  ângulos
54
para curvas
•  O método pode ser aplicado a outras
funções da forma: f(x, y) = 0
–  Cônicas
Ax2 + By2 + Cxy + Dx + Ey + F = 0
–  Polinômios
(Σ ak x k) - y = 0, k=0, 1, ..., n
•  Aproximação paramétrica é geralmente
–  mais eficiente e
–  mais flexível
55
GKS : Primitivas Generalizadas
de Desenho…
•  Função geral para traçado de curvas
geralized_drawing_primitive (n, x, y, id, na, a)
n = número de pontos básicos na definição da
primitiva
x, y = arrays de coordenadas
id = identificação da primitiva
a = array de dados não coordenadas
na= número de elementos na matriz a
•  Disponibiliza a interface para
implementações em hardware de
primitivas
56
… GKS : Primitivas
Generalizadas de Desenho
•  Exemplo
geralized_drawing_primitive (n, x, y, id, na, a)
•  Traçado de círculos
–  n = 1
–  (x(1), y(1)) = (xc , yc)
–  a(1) = r
–  na = 1
•  Traçado de arcos circulares
–  n = 1
–  (x(1), y(1)) = (xc , yc)
–  a(1) = r, a(2) = ângulo inicial, a(3) = ângulo final
–  na = 3 57
Exibição de Caracteres…
•  Sistemas raster
– Caracteres
• Definido como uma grade retangular de
valores de intensidade (0 e 1 para
sistemas de dois níveis)
• Copiar a grade para o raster nas
posições especificadas
58
… Exibição de Caracteres
•  OpenGL
–  Define array de bytes com forma desejada
Glubyte <n_arr_bytes>[n_bytes] =
{byte1, byte2, ..., byte_n_bytes };
–  Canto inf. esquerdo da área de bits (w x h)
glRasterPos2i (x, y);
–  Copia array de bytes na posição (xb0, yb0)
da área de bits w x h
glBitmap(w, h, xb0, yb0, xbi, ybi,
n_arr_bytes);
59
… Estilos de Linha
•  OpenGL: funções de atribuição de estilo para
linhas
glEnable(GL_LINE_STIPPLE);
glLineStipple (factor, pattern);
–  pattern é uma série de 16 bits formando o padrão
da linha (Glushort)
–  factor é um de amplificação das seqüências de bits
(Glint)
glLineWidth(width);
–  width = largura em pixels (Glfloat)
•  implementação modifica algoritmos de
traçado
60
7.8 Métodos de
Preenchimento de Regiões
•  Preenchem regiões fechadas com cor
ou padrão
•  Dois métodos gerais
–  Método 1 identifica em cada scan-line os
pontos que estão no interior da região
–  Método 2 “Pinta”, a partir de um ponto
interior, seus pontos vizinhos até atingir as
bordas da região (inundação)
61
... Métodos de Preenchimento
de Regiões ...
•  Método 1 – Scan-line
v
a
r
r
e Scan-line
d
u
r
a
62
de Regiões ...
•  Método 1 – Scan-line
v
a
r
r
e Scan-line
d
u
r
a
63
de Regiões ...
•  Método 2 – Inundação
  A partir do
pixel
Semente
  Examinar os
pixels
vizinhos
64
Algoritmo de Scan-Line …
•  aplicado quando apenas as bordas da

região são especificadas
•  facilmente aplicável a polígonos
•  determina os pontos da scan-line
interiores à região
Linha Superior
Linha Inferior
65
… Algoritmo de Scan-line …
•  Scan-lines examinadas entre os limites

superior e inferior da região
•  Procedimento
–  determinar pontos de interseção com cada
lado do polígono
–  Ordenar pontos de interseção da esquerda
para a direita
–  Pintar pixels entre cada par de pontos de
interseção
66
Preenchimento de Retângulos
•  Região limitada por
–  duas linhas horizontais ymin e ymax
–  duas linhas verticais xmin e xmax
ymax
•  Algoritmo
para ymin < y < ymax faça
para xmin < x < xmax faça ymin
xmin xmax
EscrevaPixel (x, y, valor)
fim_para
fim_para
67
Preenchimento de Polígonos Gerais ...

•  Polígonos Convexos
•  Polígonos Côncavos
68
... Preenchimento de Polígonos Gerais
•  Desejável pintar pixels que estejam
estritamente dentro do polígono
•  Algoritmo de
traçado de linha não
conhece região
interior ou exterior
•  Polígono vizinho
pode ser invadido
com cor diferente
69
•  Encontrar interseções da scan line com

todas as arestas do polígono
•  Ordenar interseções (crescente em x)
•  Pintar pixels entre pares de interseções
i.  Como determinar qual pixel à esquerda ou à
direita de uma interseção é interior?
ii.  Como lidar com interseções exatamente
sobre um pixel?
iii.  Como lidar com interseções sobre vértices
compartilhados?
iv.  Como lidar com vértices de linhas
horizontais?
70
•  Caso i Como determinar qual pixel à

esquerda ou à direita de uma
interseção é interior?
Interseção no final do par Interseção no início do par
71
•  Caso ii Como lidar com interseções

exatamente sobre um pixel?
Interseção no início do par Interseção no final do par

considerar ponto interior considerar ponto exterior
72
•  Caso iii Interseções em vértices podem

causar problemas(vértices
compartilhados)
–  às vezes, número ímpar de interseções
1 ponto . . 1 ponto . .1 ponto = 5 pontos

2 pontos
  às vezes, número par de interseções
.
1 ponto .
2 pontos .1 ponto = 4 pontos
73
•  Caso iii Como lidar com interseções

sobre vértices compartilhados?
–  Apenas a extremidade inferior da aresta
conta como interseção
0 interseção
1 interseção 2 interseções Scan line
74
•  Caso iv Como lidar com vértices de

linhas horizontais?
–  Não considerar para efeito de contagem de
interseções
–  ymin = ymax
Scan line
75
1 2 3 4 6 7 8
1 2 3 4 5 6 7 8 76
•  Para processar eficientemente cada

scan-line, usar
–  Lista ordenada de lados
–  Propriedades de coerência
77
78
•  Scanline aponta
para lista das
arestas que se
tornam ativas
–  AB e BC tornam-se
ativas na scanline 1
–  Nenhuma aresta
torna-se ativa na
scanline 2
79
•  Para cada scanline uma Tabela (Lista) de
Arestas Ativas (AET) é construída
–  Aresta incluída se ymin igual yscanline
–  Aresta excluída se ymax igual yscanline
80
Métodos de Coerência
•  Pixels adjacentes têm propriedades similares
–  determinar propriedades de um pixel a partir de
pixels previamente processados (propriedades
coerentes)
•  Ao longo de uma scan-line, as intensidades
de pixels podem ser constantes, linearmente
variáveis, etc.
•  Métodos de coerência podem ser utilizados
para calcular interseções da próxima scan-
line com um lado do polígono a partir da
interseção do mesmo com a scan-line
anterior 81
(xk, yk)
Scan-line Corrente
Próxima Scan-line
(xk+1, yk+1)
•  Métodos de Coerência
Inclinação da aresta de um polígono
m = (yfin - yin) / (xfin - xin)
E o próximo ponto de interseção tem as
coordenadas:
yk+1 = yk - 1
xk+1 = xk - 1/m
Para se evitar acúmulo de erro de
arredondamento xk = x0 - k/m
82
Preenchimento com Padrões
Retangulares
•  Preencher com um padrão pré-
determinado através da superposição
da definição de um padrão retangular
em uma linha.
•  Partindo-se de um ponto selecionado
3
2
1
0
012 3
83
de Regiões ...
x= 7
x padrão = x%4 = 7%4 = 3 → coluna 4

v y padrão = y%4 = 9%4 = 1 → linha 2
a
r
€
r
y=9
e
d
u
r
a
84
Preenchimento de Áreas com
Antialiasing
•  Idéia similar àquela para linhas
–  Ajusta-se a intensidade dos pixels
próximos da borda de acordo com a
porcentagem de área coberta:
85
Preenchimento de Áreas com
Antialiasing
•  Áreas de Pixels Subdivididas
Equivalente a adicionar scan-lines
extras.
•  Ex.: scan-line virtual (centro da 1/2 superior)

scan-line real (centro do pixel)
scan-line virtual (centro da 1/2 inferior)
PIXEL
3 subdivisões estão no interior (3/4 da área do pixel)
intensidade do pixel é igual a 0,75 do máximo
86
Algoritmo de Pitteway-
Watkinson
•  Algoritmo do ponto médio para linhas
•  Considere o lado de um polígono com
inclinação
–  0 < m ≤ 1, passando pelo ponto ( xk, yk )
yk+1 y=mx+b
yk+1/2
yk
Em x = xk + 1 xk xk+1
pk = y - (yk+0.5) = m(xk+1) + b - (yk+0.5)
(< 0: selecionar yk; > 0: selecionar yk + 1)
87
… Algoritmo de Pitteway-
Watkinson …
Yk
Y=m(Xk-0.5) + b Y=m(Xk+0.5) + b
Xk-0.5 Xk+0.5
Xk
88
Watkinson …
•  Parâmetro de decisão:
Pk = y - (yk + 0.5) = m(xk + 1) + b - (yk + 0.5)
= [m xk + b - (yk - 0.5)] + (m -1)
= [área interna do pixel (xk, yk)] + (m - 1)
•  Definindo o parâmetro p’k no intervalo de 0 a
1 como
p’k= pk + (1 - m) = [área interna do pixel (xk,
yk)]
–  se pk < 0 ==> p’k < ( 1 - m ) : selecionar yk
–  se pk > 0 ==> p’k > ( 1 - m ) : selecionar yk+1
89
Watkinson …
•  Método incremental para cálculo de p’k
sucessivos:
–  Partindo-se do extremo (x0, y0):
–  p’o = [ m xo + b - (yo - 0.5 )] = yo - yo + 0.5 = 0.5
Temos:
–  p’k+1 = p’k + m - ( yk+1 - yk )
•  Para grandes inclinações, |m| > 1, a
porcentagem de cobertura do pixel em (xk,
yk) é calculada como:
•  pk = xk - ( yk / m ) + [ ( b / m ) + 0.5 ]
90
Watkinson
•  É um método preciso e rápido para o ajuste
da intensidade do pixel quando somente um
lado do polígono passa pela área de um pixel
•  Para polígonos “estreitos”, utilizar o método
da subdivisão :
91
Algoritmo de Scan-line
•  Pode ser aplicado a regiões com bordas

curvas
•  Necessita de equações de curvas para
calcular a interseção com as scan-lines
92
Algoritmo de Boundary-fill
•  Entrada:
–  Coordenada (x, y) de um ponto interior
–  Cor de preenchimento
–  Cor da fronteira
•  Processo:
–  A partir do ponto (x, y) verificar se os pixels
vizinhos têm cores diferentes da cor da fronteira
–  se a cor do pixel for diferente, pintar com cor de
preenchimento.
–  parar quando não conseguir mais pintar
•  Útil em programas de pintura e entrada
interativa
93
Áreas de Conexão-4
•  Bom para formas simples
(x, y)
•  Ruim para regiões com seções

diagonais estreitas (1 pixel de largura)
94
Áreas de Conexão-8
(x, y)
•  Ambos os métodos (conexões 4 e 8 )

envolvem grandes pilhas
•  Aumentar performance combinando o
método com o scan-line. A pilha somente
terá alguns pontos em cada linha a ser
examinada
95
Algoritmo Recursivo
procedure bound_fill(x, y,fill_col,bound_col: integer);
var curr_col : integer;
begin
curr_col := inquire_color ( x, y );
if (curr_col <> bound_col) and (curr_col <>
fill_col) then begin
set_pixel ( x, y, fill_col);
bound_fill ( x + 1, y , fill_col, bound_col);
bound_fill ( x - 1, y , fill_col, bound_col);
bound_fill ( x , y + 1, fill_col, bound_col);
bound_fill ( x , y - 1, fill_col, bound_col);
end { if curr_col }
end; {bound_fill }
96
Algoritmo de Flood-Fill
•  Variação do método de boundary-fill
•  Entrada
–  Coordenada (X, Y) de um ponto interior
–  Cor de preenchimento
–  Cor a ser substituída
•  Processo:
–  A partir do ponto (x, y) verificar se os pixels
vizinhos têm cores iguais à cor a ser substituída
–  se o teste for verdadeiro, pintar com cor de
preenchimento
–  parar quando não conseguir mais pintar
•  Útil em regiões que podem ter fronteiras
multicoloridas 97
20
20 x 20 grid
15 Seed (13, 12)
xmax=17
10 xmin= 11
1
1 5 10 15 20
98
20
Linha 13
15 Faixa [11,17]
Empilhar(16,13)
10
Linha 11
Faixa [11,17]
Empilhar(17,11)
5
1
1 5 10 15 20
99
Algoritmo Recursivo
procedure flood_fill ( x, y, fill_col, subst_col :
integer );
var curr_col : integer;
begin
curr_col := inquire_color ( x, y );
if (curr_col = subst_col) then begin
set_pixel ( x, y, fill_col);
flood_fill ( x + 1, y , fill_col, subst _col);
flood_fill ( x - 1, y , fill_col, subst _col);
flood_fill ( x , y + 1, fill_col, subst _col);
flood_fill ( x , y - 1, fill_col, subst _col);
end { if curr_col }
end; {bound_fill }
100
Funções para Preenchimento
de Áreas
•  Permite que uma área poligonal
fechada seja preenchida com uma
determinada cor ou padrão
•  A implementação desta função depende
do tipo de atributo de preenchimento
•  Preenchimento vazio ≡ polyline com o
último ponto conectado ao primeiro
ponto
101
Funções para Preenchimento
de Áreas
•  OpenGL
// Draw a filled polygon
glPolygonMode(GL_FRONT, GL_FILL);
glBegin(GL_POLYGON);
glVertex2i(10,10);
glVertex2i(20,10);
glVertex2i(25,20);
glVertex2i(10,20);
glEnd();
102
Funções de Preenchimento de
Áreas do OpenGL
•  Habilitar preenchimento com padrões
glEnable ( GL_POLYGON_STIPPLE )
•  Estabelecer um padrão
glPolygonStipple ( mask )
mask= ponteiro para um padrão de 32 x 32 bits
armazenado na memória
•  Modo de preenchimento
glPolygonMode( face, mode )
face = GL_FRONT, GL_BACK,GL_FRONT_AND_BACK
mode = GL_FILL
103
3.2 Transformações de
Visualização
•  Sistemas de Coordenadas
–  Coordenadas do mundo (world-coordinates)
•  utilizadas para definir a cena no mundo real
•  Geralmente utiliza números reais (ponto flutuante)
–  Coordenadas do dispositivo (device-
coordinates)
•  coordenadas próprias do dispositivo de saída onde a
cena será exposta
•  Utiliza números inteiros
•  Mapeamento da cena de WC para DC
104
Sistemas de Coordenadas
5.000 km
852
6.000 km 1.023
World-Coordinates Device-Coordinates
105
Janela, “Viewport” e “Aspect
Ratio”
•  Janela: sub-região da cena a ser
exibida y_wc P2
–  Retangular
P1 = ( xw_min, yw_min )
P2 = ( xw_max, yw_max ) P1
x_wc
–  Circular y_wc
C = ( x_c, y_c ) R
R = ( raio )
C
106
x_wc
Janela na cidade do Rio de
Janeiro
(5.300, 1.400) km
(5.200, 1.300) km 107

Ratio”
•  Viewport: sub-região do espaço de
coordenadas do dispositivo onde a
janela será mapeada
–  Retangular
y_dv
P’2
P’1 = ( xv_min, yv_min)
P’2 = ( xv_max, yv_max)
P’1
x_dv 108
Viewports
•  Partição da área de exibição do

dispositivo em três viewports
Disopositivo particionado em três viewports:

Superior esquerda mostra o mapa do Brasil;
Superior direita mostra a cidade do Rio de
Janeiro; inferior reservada para textos.
109
Ratio”
•  Mapeamento da Janela na Viewport
–  Escreva coordenadas de P na forma
paramétrica
x = xw_min + fx . (xw_max - xw_min)
y = yw_min + fy . (yw_max - yw_min)
–  Determine os parâmetros fx e fy
fx = (x - xw_min) / (xw_max - xw_min)
fy = (y - yw_min) / (yw_max - yw_min)
–  Coordenadas de P’ na forma paramétrica,
usando os parâmetros fx e fy calculados
x’ = xv_min + fx . (xv_max - xv_min)
y’ = yv_min + fy . (yv_max - yv_min)
110
Ratio”
•  Mapeamento da Janela na Viewport
(Matricial)
Coordenadas de P’
x'= xv _ min+
( x − xw _ min) ⋅ ( xv _ max− xv _ min)
( xw _ max− xw _ min)
y'= yv _ min+
( y − yw _ min)
⋅ ( yv _ max− yv _ min)
( yw _ max− yw _ min)
•  T = T(-xw_min, -yw_min).S(sx, sy) .
€
T(xv_min, yv_min)
111
Ratio”
112
Ratio”
•  Aspect Ratio: razão entre
–  dimensões x e y da janela
aw = (xw_max - xw_min)/(yw_max - yw_min)
–  dimensões x e y da viewport
av = (xv_max - xv_min)/(yv_max - yv_min)
–  Se aw = av → não ocorre distorção
–  Se aw ≠ av → ocorre distorção
113
Clipping e Shielding
•  Após definição das janelas e das viewports
–  operações necessárias à visualização
•  Clipping
•  Shielding
•  Transformações de coordenadas
•  Clipping:
–  Apaga todas as partes da cena que estejam fora
da janela
–  Executado antes ou depois da transformação de
coordenadas.
•  Shielding:
–  Apaga todas as partes da cena que estejam dentro
da janela
114
Clipping
•  Tipos de Clipping
–  Clipping de Janela
–  Clipping de Viewport
•  Clipping de Janela
–  Exclui primitivas externas à janela das
transformações de visualização (reduz a
transformação de coordenadas)
–  Requer operações de ponto flutuante para
localizar interseções com a janela
–  há clippers rápidos desenvolvidos em
hardware)
115
Clipping
•  Clipping de Viewport
–  Operações de clipping realizadas em
coordenadas de dispositivo (inteiras)
–  Reduz cálculos utilizando-se de
concatenação das matrizes de
transformação de visualização com
matrizes de transformação geométricas
–  Requer que os objetos externos à janela
sejam transformados para coordenadas
de dispositivo
116
Clipping
•  Algoritmos para clipping de

–  Pontos
–  Linhas Retas
–  Áreas Poligonais
–  Figuras Curvas
–  Textos
117
Clipping de Ponto
–  O ponto P = (x, y) será exibido se:
xw_min ≤ x ≤ xw_max
yw_min ≤ y ≤ yw_max
yw_max
yw_min
xw_min xw_max
118
Clipping de linha
•  Casos possíveis:
–  Linha completamente dentro da janela
–  Linha completamente fora da janela
–  Linha traspassa uma borda da janela
119
Clipping de linha
•  O algoritmo de clipping deve

–  Identificar e salvar as linhas internas
–  Identificar e descartar as linhas externas
–  Encontrar as intersecções de linhas e
bordas da janela e salvar os segmentos
internos
120
Clipping de Linha
•  Algoritmo de Cohen-Sutherland
–  Identifica rapidamente linhas internas e
externas
–  utiliza código de região com quatro bits
para os pontos extremos da linha.
códigos de região
1001 1000 1010 Superior

Inferior
0001 0000 0010
Direita
0101 0100 0110 Esquerda
121
Clipping de Linha (Cohen-
Sutherland)
•  Bit= 1 ponto pertence à região
•  Bit= 0 ponto não pertence à região
•  Regra de associação
3 2 1 0 Posição do Bit
acima abaixo direita esquerda Região do Bit
122
Sutherland)
•  código de região obtidos comparando-
se as coordenadas (x, y) do ponto com
as coordenadas das bordas da janela
yw_max
yw_min
xw_min xw_max
123
Clipping de Linha
–  bit 0 =1 se x < xwmin
–  bit 1 =1 se xwmax < x
–  bit 2 =1 se y < ywmin
–  bit 3 =1 se ywmax < y
•  Podemos calcular os valores dos bits como
–  bit 0 = sign bit de (x - xwmin)
–  bit 1 = sign bit de (xwmax - x )
–  bit 2 = sign bit de (y - ywmin)
–  bit 3 = sign bit de (ywmax - y )
124
Clipping de Linha
–  Definir códigos C1 e C2 para extremidades das
linhas
–  Se (C1 | C2) == 0000 → linha interna
(todos os bits em C1 e C2 são iguais a 0)
–  Se (C1 & C2) != 0000 → linha externa
(algum bit correspondente em C1 e C2 é igual a 1)
–  Qualquer outro caso → linha pode cortar a região
•  Exemplo:
–  0101 e 0110 → abaixo da janela (bit 2)
–  teste com o operador lógico AND (&)
–  (0101) & (0110) = 0100 ≠ 0000 ∴ fora
125
Sutherland)
Linha AB que não for aceita ou rejeitada
–  Verificar bits do código de A na seqüência
Esquerda → Direita → Inferior → Superior
–  O primeiro bit = 1 encontrado determina a
borda com a qual deve-se calcular o ponto
de interseção I
–  Descarta-se segmento AI e define-se
código para I
–  Repetir testes para segmento IB
126
Sutherland)
•  Processando uma linha externa

A (1000)
I (0010)
B (0010)
–  Partir do extremo A
–  Verificar o código de A da direita para a
esquerda
–  A está acima da janela
–  Calcular interseção com borda superior
127
Sutherland)
–  Descartar segmento AI acima da janela
I (0010)
B (0010)
≡
–  Teste (CI & CB) 0010 != 0000 → IB está
completamente à direita
–  Descartar IB
128
Sutherland)
•  Processando uma linha de intersecção:
A (1000)
B (0010)
129
Sutherland)
•  Iniciar em A (Código (1000)
•  Primeiro bit diferente de zero é o bit 3
•  Encontramos a intersecção com o topo
I1 (0000)
B (0010)
•  Teste (CI & CB) == 0000 → B está fora

da janela
130
Sutherland)
•  O segundo extremo B (0010), Bit 1 ≠ 0, está
à direita
•  encontramos interseção de IB com a borda
direita
I1 (0000)
I2 (0000)
•  Teste (CI1 | CI2) == 0000

–  Segmento de reta (I1 I2) é armazenado para a
transformação janela-porta de visualização
131
Clipping de Linha
Cálculo da interseção
•  coordenadas são calculadas a partir
dos valores das coordenadas do
extremo e da inclinação da linha
yw_max
P2
(x, y)
yw_min P1
xw_min xw_max
132
Clipping de Linha
•  Interseção com borda esquerda ou

direita
x = (xwmin ou xwmax)
y = y1 + m (x - x1)
•  Interseção com borda superior ou
inferior
y = (ywmin ou ywmax)
x = x1 + (y - y1) / m
133
Clipping de Linha
Algoritmo de subdivisão do ponto médio

•  métodos de busca binária para determinar
os pontos de interseção com a janela
•  Em caso de clipping contra a viewport
–  Usar códigos da região para identificar linhas
internas e eliminar linhas externas
–  Transformar demais linhas para coordenadas
de dispositivo
–  Fazer clip contra a viewport usando aritmética
inteira
134
Clipping de Linha
•  Ponto médio calculado sucessivamente
135
Clipping de Linha
Ex: Um ponto de Interseção

•  P1 à esquerda e P2 dentro da Viewport
•  Procurar interseção à esquerda
– calcular Pm ≡ (xm, ym)
– verificar se xm > xvmin ( Pm interno ? )
• sim → ponto médio de P1Pm P2
• não → ponto médio de PmP2 P1
Pm=(xm,ym)
–  repetir até que xm = xvmin
xvmin
136
Clipping de Linha
P2
Ex: Duas interseções P1
Pm= (xm,ym)
xvmin xvmax
•  P1 à esquerda e P2 à direita da Viewport
•  Procurar interseção à esquerda e à direita
–  calcular Pm ≡ (xm, ym)
–  verificar se Pm interno (xvmax > xm > xvmin)
sim → calcular meio de P1Pm e de PmP2
não
→ calcular interseção de P1Pm se Pm > xvmax
→ calcular interseção de PmP2 se Pm < xvmin
137
P1 Pm=( xm, ym )
Clipping de Linha
P2
EX: Sem interseções

xvmin xvmax
•  P1 acima e P2 à direita da Viewport
•  calcular Pm ≡ (xm, ym)
–  se ym > yvmax → descarta P1Pm e
calcula P’m (Pm, P2)
–  se xm > xvmax → descarta PmP2 e
calcula P’m (P1, Pm)
–  se ym > yvmax e xm > xvmax →
descarta P1P2
138
Clipping de Linhas

•  Seleção preliminar com códigos de
regiões
•  Para cada linha não descartada ou
aceita
–  Pesquisa binária localiza 0, 1 ou 2
interseções com as bordas da região
139
Clipping de Linhas
•  Linha com n pixels que intercepta bordas da
viewport precisa de no máximo
b = log2n cálculos de Pm
Exemplo: n = 512 pixels
‒  → 1 pixel = 512 / ( 2 b )
‒  → 2 b = 512
‒  → b = log2 512 = 9
•  Trade off:
–  Requer mais cálculos, porém
–  elimina multiplicação e divisão de ponto flutuante
–  Obs: As divisões por 2 são simples shifts de bits
140
Clipping de Linhas
Algoritmo de Liang-Barsky ...
•  Reduz os cálculos de clipping utilizando
equações paramétricas de retas:
x = x1 + u · Δx
y = y1 + u · Δy y2
0 ≤ u ≤ 1 (x,y)
y1
Δx = x2 - x1
x1 x2
Δy = y2 - y1
•  Cálculo de interseções utiliza o parâmetro u
141
Clipping de Linhas
•  Para cada ponto interior (x,y) (x2,y2)
xw min ≤ x1 + Δx ⋅ u ≤ xw max ywmax (x,y)

yw min ≤ y1 + Δy ⋅ u ≤ yw max ywmin
(x1,y1)
•  Quatro inequações xwmin xwmax
−Δx ⋅ u ≤ x1 − xw min Δx ⋅ u ≤ xw max − x1
−Δy ⋅ u ≤ y1 − yw min Δy ⋅ u ≤ yw max − y1
142
Clipping de Linhas
•  Os parâmetros pk e qk abaixo são usados
para clipping
pk · u ≤ qk, k = 1, 2, 3, 4
•  Os valores de k são relacionados às bordas da
janela:
k = 1: esquerda; p1 = - Δx ; q1 = x1 - xwmin
k = 2: direita; p2 = + Δx ; q2 = xwmax - x1
k = 3: abaixo; p3 = - Δy ; q3 = y1 - ywmin
k = 4: acima; p4 = + Δy ; q4 = ywmax - y1
143
Clipping de Linhas
•  Possibilidades de pk
(1) pk = 0
→ reta horizontal ( Δy = 0 )
→ reta vertical ( Δx = 0 )
Se qk < 0 → linha fora da janela (eliminar)
Se qk ≥ 0 → linha dentro da janela
144
Clipping de Linhas
Ex 1:[p1= - Δx = 0; q1 = x1 - xwmin < 0]
Reta à esquerda da janela
xwmin
Ex 2:[p2= Δx = 0; q2 = xwmax – x1 < 0]
Reta à direita da janela
xwmax 145
Clipping de Linhas
Ex 3: [ p3= - Δy = 0; q3 = y1 - ywmin < 0 ]
Reta abaixo da janela
Ex 4: [ p4= Δy = 0; q4 = xwmax - y1 < 0 ]

Reta acima da janela
ywmax
ywmin
146
Clipping de Linhas
(2) pk < 0
•  k = 1: esquerda; p1 = - Δx < 0 → Δx > 0
•  k = 2: direita; p2 = + Δx < 0 → Δx < 0
•  k = 3: abaixo; p3 = - Δy < 0 → Δy > 0
•  k = 4: acima; p4 = + Δy < 0 → Δy < 0
x2 x1
x1 x2
147
Clipping de Linhas
(2) pk < 0
•  k = 1: esquerda; p1 = - Δx < 0 → Δx > 0
•  k = 2: direita; p2 = + Δx < 0 → Δx < 0
•  k = 3: abaixo; p3 = - Δy < 0 → Δy > 0
•  k = 4: acima; p4 = + Δy < 0 → Δy < 0
p1 < 0 p2 < 0 p3 < 0 p4 < 0
148
Clipping de Linhas
(3) pk > 0
•  k = 1: esquerda; p1 = - Δx > 0 → Δx <0
•  k = 2: direita; p2 = + Δx > 0 → Δx >0
•  k = 3: abaixo; p3 = - Δy > 0 → Δy <0
•  k = 4: acima; p4 = + Δy > 0 → Δy >0
x1 x2
x2 x1
149
Clipping de Linhas
(3) pk > 0
•  k = 1: esquerda; p1 = - Δx > 0 → Δx <0
•  k = 2: direita; p2 = + Δx > 0 → Δx >0
•  k = 3: abaixo; p3 = - Δy > 0 → Δy <0
•  k = 4: acima; p4 = + Δy > 0 → Δy >0
p1 > 0 p2 > 0 p3 > 0 p4 > 0
150
Clipping de Linhas
pk ≠ 0: interseção linha com bordas da região
u1 = q1 / p1 = ( x1 - xwmin ) / ( - (x2 - x1 ) )
u2 = q2 / p2 = ( xwmax - x1 ) / ( +(x2 - x1 ) )
u3 = q3 / p3 = ( y1 - ywmin ) / ( - (y2 - y1 ) )
u4 = q4 / p4 = ( ywmax - y1 ) / ( +(y2 - y1 ) )
Ex: Interseção com o u1 = q1/p1

limite esquerdo (x2,y2)
(x1,y1)
xwmin 151
Clipping de Linhas
Procedimento básico:
Calcular parâmetros de entrada na região da janela
uα = max ( 0, uk ) para pk < 0
faces atravessadas ao aproximar-se da região
Calcular parâmetros de saída da região da janela
uβ = min (1, uk ) para pk > 0
faces atravessadas ao afastar-se da região
Se uα > uβ reta completamente fora da janela
Se uα < uβ pontos finais da reta são
P1 = ( x(uα), y(uα) ) e P2 = ( x(uβ), y(uβ) )
152
Clipping de Linhas
Δx > 0 e Δy > 0
uα = max ( 0, u1, u3 ) = u1; p1, p3 < 0

uβ = min ( 1, u2, u4 ) = u4; p2, p4 > 0
(x2,y2)
k = 1: esquerda
uβ k = 2: direita
(x1,y1) k = 3: abaixo
uα
k = 4: acima
153
Clipping de Linhas
Δx > 0 e Δy > 0
uα = max ( 0, u1, u3 ) = u1; p1, p3 < 0

uβ = min ( 1, u2, u4 ) = u4; p2, p4 > 0
u=1 u2>1
k = 1: esquerda
uuβ 4<1
(u <1)=uβ k = 2: direita
u=0
uα=u1>0 k = 3: abaixo
k = 4: acima
u3<0
154
Algoritmo de Liang-Barsky
Inicialize ua = 0,ub = 1; se ( pk > 0 ) então

para [cada borda] k= 1 até 4 se ( qk/pk < ub ) então
faça ub = qk/pk
calcule pk e qk; se ( ua > ub ) clipe linha
se (pk = 0 e qk < 0) clip linha; fim então
se (pk < 0) então fim então
fim para
se (qk/pk > ua ) então
calcule interseções
ua = qk/pk
// [ua <= ub ]
se (ua > ub) clip linha // (x(ua), y(ua)) e
fim então // (x(ub), y(ub))
fim então
155
Clipping de Área
•  Modificar procedimentos de clipping de

retas para produzir área fechada
•  Cortar arestas de um polígono
individualmente leva a regiões abertas
156
Clipping de Área
•  Clipping de Polígonos: Processa os

vértices em ordem ao longo das bordas
da região de recorte
•  Polígono recortado é definido como
uma nova1 seqüência de vértices
6’ 1’ 6’ 1’
2’
2’
2
3’ 3’
5’ 4’ 5’ 4’
3
157
Clipping de Área
Algoritmo Sutherland-Hodgman
•  Recorta o polígono em relação a cada uma
das bordas da janela separadamente
•  Para cada borda da janela
–  Processa-se todos os vértices do polígono
–  Gerando-se novo conjunto de vértices para o
processamento da próxima borda
Esquerdo Direito Abaixo Acima
158
Clipping de Área
•  Quatro casos possíveis no processamento de
polígono em relação a uma borda
1’ 1’ 1
1 2 2
3 3
4 4’ 4
Fora →Dentro Dentro → Dentro Dentro → Fora Fora → Fora

Guarda 1’,2 Guarda 3 Guarda 4’ Guarda nada
•  Passa pontos 1’, 2, 3, 4’ para a próxima rotina

•  Identifica posições dos vértices com os
códigos das regiões (Cohen-Sutherland) 159
Clipping de Área
•  Processo de corte pode ser feito em

paralelo (multiprocessamento)
–  Clipar cada aresta contra todas as bordas
(não gera array intermediário de vértices)
•  Exemplo:
I2 3
I4
2 I3
I1
1 160
Clipping de Área
Algoritmo de Sutherland-Hodgman
•  Gera somente uma lista de vértices de saída
•  Polígonos convexos: Recortados corretamente
•  Polígonos côncavos: Recorte pode apresentar
–  linhas estranhas
–  múltiplas sub-regiões disjuntas
•  Exemplo: lista final de vértices
1’ → 2 → 3 → 4’ → 5’ → 5 → 6’ → 1’
1’ 1’ 2
1 2
4’
4 4’ 3 3
5’ 5’
5 6’ 5
6 6’
161
Clipping de Área
•  Correção para polígonos côncavos

•  Verificar lista de vértices final em cada
borda da janela
–  Mais de dois pontos na borda?
- quebrar área simples em duas ou mais
áreas separadas
- conectar pontos ao longo desta linha em
pares (como em preenchimento scanline)
•  Alternativa:Dividir o polígono côncavo em
um conjunto de polígonos convexos
162
Clipping de Polígonos
Algoritmo de Weiler-Atherton
•  Altera processamento de vértices para tratar
corretamente polígonos côncavos
•  Processar vértices no sentido horário
–  Após cálculo de todas as interseções com a borda
–  Siga aresta do polígono, se entrando na janela
–  Siga borda da janela (no sentido horário) se
saindo da janela
163
início 1’ 2 Gera duas 2
1’
1 áreas de
fim 4’ polígonos 3
3 4’
4 separadas
5’ 5’
6 6’ 5 6’ 5
•  Usado para clipping de polígonos arbitrários
contra outros (incluindo buracos: processa
no sentido anti-horário) Cap. 19, Foley et al.
•  Usado para remoção de superfícies
escondidas (hidden-surface)
164
Algoritmo de Liang-Barsky
•  Usa equações paramétricas no cálculo das
interseções com a janela
•  Analisa relacionamentos entre

–  lados do polígono e
–  bordas da janela
•  Menos cálculos de clipping do que
Sutherland-Hodgman
165
Clipping de Outros Objetos
•  Círculos, Elipses, etc.

•  Usa equação de definição do objeto
•  Mais cálculos são envolvidos
166
Clipping de Textos
•  Cadeia de caracteres a ser recortada

STRING
Método 1: Recorta tudo-ou-nada na cadeia
Método 2: Recorta tudo-ou-nada no caracter
TRING
Método 3: Recorta caracteres individuais

STRING
167
Limpeza (Blanking or Shielding)
•  Oposto do clipping
–  Apaga partes da figura dentro da janela
•  Utilizada para
–  Inserções (ex.: mapas, esquemas)
–  Rótulos
Observe que os rios e

Brasil cidades foram
recortados no interior
do retângulo verde
168

Capitulo 07

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Capitulo 07

Transféré par

Droits d'auteur :

Formats disponibles

Computação Gráfica I

CRAb – Grupo de Computação

• Sistemas Gráficos e Modelos

• Construção básica de figuras

– Inclinação de uma reta:

– Para qualquer linha reta: Δy = m Δx

yi+1 Seção do Raster

Como xi+1= xi+1:

pi+1= pi + 2 Δy - 2 Δx(yi+1- yi)

Se pi < 0, selecionar yi ⇒ yi+1-yi = 0

Se pi ≥ 0, selecionar yi+1 ⇒ yi+1- yi = 1

Se dX > 0 Então Se dY > 0 Então

• Polígono com n vértices

(0, 0) (1, 0) ... (x, y) ... (xmax, ymax)

• Ajusta intensidades de pixels ao longo

• Considerar a linha como retângulo com

• Alternativa mais barata

• Linhas de comprimentos diferentes

• Para compensar esse problema

(-y, -x) (y, -x)

(-x, -y) (x, -y) 42

• Generalizar o algoritmo do círculo

• aplicado quando apenas as bordas da

• Scan-lines examinadas entre os limites

Preenchimento de Polígonos Gerais ...

• Encontrar interseções da scan line com

• Caso i Como determinar qual pixel à

Interseção no final do par Interseção no início do par

• Caso ii Como lidar com interseções

Interseção no início do par Interseção no final do par

• Caso iii Interseções em vértices podem

1 ponto . . 1 ponto . .1 ponto = 5 pontos

• Caso iii Como lidar com interseções

1 interseção 2 interseções Scan line

• Caso iv Como lidar com vértices de

• Para processar eficientemente cada

x padrão = x%4 = 7%4 = 3 → coluna 4

• Ex.: scan-line virtual (centro da 1/2 superior)

• Pode ser aplicado a regiões com bordas

• Bom para formas simples

• Ruim para regiões com seções

• Ambos os métodos (conexões 4 e 8 )

(5.200, 1.300) km 107

• Partição da área de exibição do

Disopositivo particionado em três viewports:

aw = (xw_max - xw_min)/(yw_max - yw_min)

av = (xv_max - xv_min)/(yv_max - yv_min)

– Se aw = av → não ocorre distorção

• Algoritmos para clipping de

• O algoritmo de clipping deve

1001 1000 1010 Superior

acima abaixo direita esquerda Região do Bit

• Processando uma linha externa

• Teste (CI & CB) == 0000 → B está fora

• Teste (CI1 | CI2) == 0000

• Interseção com borda esquerda ou

Algoritmo de subdivisão do ponto médio

• Ponto médio calculado sucessivamente

Ex: Um ponto de Interseção

EX: Sem interseções

Algoritmo de subdivisão do ponto médio

• Para cada ponto interior (x,y) (x2,y2)

xw min ≤ x1 + Δx ⋅ u ≤ xw max ywmax (x,y)

•  Sistemas Gráficos e Modelos

•  Construção básica de figuras

–  Inclinação de uma reta:

–  Para qualquer linha reta: Δy = m Δx

•  Polígono com n vértices

•  Ajusta intensidades de pixels ao longo

•  Considerar a linha como retângulo com

•  Alternativa mais barata

•  Linhas de comprimentos diferentes

•  Para compensar esse problema

•  Generalizar o algoritmo do círculo

•  aplicado quando apenas as bordas da

•  Scan-lines examinadas entre os limites

•  Encontrar interseções da scan line com

•  Caso i Como determinar qual pixel à

•  Caso ii Como lidar com interseções

•  Caso iii Interseções em vértices podem

•  Caso iii Como lidar com interseções

•  Caso iv Como lidar com vértices de

•  Para processar eficientemente cada

•  Ex.: scan-line virtual (centro da 1/2 superior)

•  Pode ser aplicado a regiões com bordas

•  Bom para formas simples

•  Ruim para regiões com seções

•  Ambos os métodos (conexões 4 e 8 )

•  Partição da área de exibição do

–  Se aw = av → não ocorre distorção

•  Algoritmos para clipping de

•  O algoritmo de clipping deve

•  Processando uma linha externa

•  Teste (CI & CB) == 0000 → B está fora

•  Teste (CI1 | CI2) == 0000

•  Interseção com borda esquerda ou

•  Ponto médio calculado sucessivamente

•  Para cada ponto interior (x,y) (x2,y2)

•  Modificar procedimentos de clipping de

•  Clipping de Polígonos: Processa os

•  Passa pontos 1’, 2, 3, 4’ para a próxima rotina

•  Processo de corte pode ser feito em

•  Correção para polígonos côncavos

•  Analisa relacionamentos entre

•  Círculos, Elipses, etc.

•  Cadeia de caracteres a ser recortada