Rasterização, é a tarefa de converter uma imagem vetorial em uma imagem raster (pixels ou pontos) para a saída em vídeo ou impressora.
Configuração Inicial
Antes de começar o trabalho foi preciso instalar o OpenGL/Glut onde foi instalado o FreeGlut e FreeGlut-Dev em ambiente Linux.
Rasterização de Ponto
Para desenhar um pixel foi utilizado um ponteiro FBptr onde o mesmo aponta para o inicio da memória de vídeo, onde especificamente trata-se do pixel(0,0).
Todo pixel da tela é formado por quatro componentes (R,G,B,A), as quais em conjunto, ocupam um espaço em memória de 4 bytes, sendo 1 byte para cada componente. Podemos acessar qualquer pixel da tela.
Foi feito uma estrutura para organizar e armazenar os valores do pixel.
Em seguida temos a função PutPixel, onde recebe como parâmetros as coordenadas do pixel e a cor ao qual será exibido na tela.
Para testar a função foram feitas modificações na função MyGlDraw, como mostrado no trecho de código abaixo:
Após compilar o código e executá-lo, temos o seguinte resultado:
Rasterização de Retas
Para determinada tarefa utilizou-se a função DrawLine onde a mesma é responsável pela rasterização da reta. Ela receberá como parâmetros dois pontos e suas respectivas cores. A reta formada por esses dois pontos, partindo do ponto inicial com coordenadas (x0, y0) até chegar ao ponto final com coordenadas (x1, y1) . O algoritmo utilizado como base para a execução desta função será o algoritmo de Bresenham.
Algoritmo de Brasenham
O algoritmo de Bresenham é um algoritmo utilizado para criar retas, ele utiliza uma variável de decisão normalmente chamada “d”. A cada novo ponto desenhado numa determinada posição (x,y), o valor de d é recalculado para determinar onde será desenhado o próximo ponto. Se o novo valor for positivo, o próximo ponto será desenhado no pixel que se encontra nas coordenadas (x+1, y+1), caso contrário, o próximo ponto será desenhado nas coordenada (x+1, y).
void DrawLine(ponto p_inicial, ponto p_final, color cor){
int slope;
int dx, dy, incremento_E, incremento_NE, d, x, y;
//inverte a linha x1 > x2
if (p_inicial.x > p_final.x){
DrawLine(p_final, p_inicial, cor);
return;
}//if
dx = p_final.x - p_inicial.x;
dy = p_final.y - p_inicial.y;
if (dy < 0){ //Incremento decrescente
slope = -1;
dy = -dy;
}
else{//Incremento Crescente
slope = 1;
}
// Constante de Bresenham
incremento_E = 2 * dy;
incremento_NE = 2 * dy - 2 * dx;
d = 2 * dy - dx;
x = p_inicial.x;/**inicia x com o valor de p_inicial**/
y = p_inicial.y;
PutPixel(p_inicial.x, p_inicial.y, cor);
while(x != p_final.x){
if (d <= 0){
d += incremento_E;
x++;/**Adicionado incremento de x**/
}
else{
d += incremento_NE;
x++;/**Adicionado incremento de x**/
y += slope;
}
PutPixel(x, y, cor);
}
}//fim da DrawLine
Para testar este algoritmo, a modificação na função MyGlDraw é mostrada no trecho de código a seguir e posteriormente o resultado obtido:
Feito todos os processos anteriores, rasterizar triângulo passa a ser o mais fácil, onde é só chamar a função DrawLine 3 vezes. Para isso, foi criado a função DrawTriangle, onde ela recebe como parâmetros os 3 pontos do triângulo e suas cores, onde a partir daí será feito as retas que formaram o triângulo.
Por fim, temos o seguinte resultado:
Configuração Inicial
Antes de começar o trabalho foi preciso instalar o OpenGL/Glut onde foi instalado o FreeGlut e FreeGlut-Dev em ambiente Linux.
Rasterização de Ponto
Para desenhar um pixel foi utilizado um ponteiro FBptr onde o mesmo aponta para o inicio da memória de vídeo, onde especificamente trata-se do pixel(0,0).
Todo pixel da tela é formado por quatro componentes (R,G,B,A), as quais em conjunto, ocupam um espaço em memória de 4 bytes, sendo 1 byte para cada componente. Podemos acessar qualquer pixel da tela.
Foi feito uma estrutura para organizar e armazenar os valores do pixel.
Em seguida temos a função PutPixel, onde recebe como parâmetros as coordenadas do pixel e a cor ao qual será exibido na tela.
Para testar a função foram feitas modificações na função MyGlDraw, como mostrado no trecho de código abaixo:
Após compilar o código e executá-lo, temos o seguinte resultado:
Rasterização de Retas
Para determinada tarefa utilizou-se a função DrawLine onde a mesma é responsável pela rasterização da reta. Ela receberá como parâmetros dois pontos e suas respectivas cores. A reta formada por esses dois pontos, partindo do ponto inicial com coordenadas (x0, y0) até chegar ao ponto final com coordenadas (x1, y1) . O algoritmo utilizado como base para a execução desta função será o algoritmo de Bresenham.
Algoritmo de Brasenham
O algoritmo de Bresenham é um algoritmo utilizado para criar retas, ele utiliza uma variável de decisão normalmente chamada “d”. A cada novo ponto desenhado numa determinada posição (x,y), o valor de d é recalculado para determinar onde será desenhado o próximo ponto. Se o novo valor for positivo, o próximo ponto será desenhado no pixel que se encontra nas coordenadas (x+1, y+1), caso contrário, o próximo ponto será desenhado nas coordenada (x+1, y).
void DrawLine(ponto p_inicial, ponto p_final, color cor){
int slope;
int dx, dy, incremento_E, incremento_NE, d, x, y;
//inverte a linha x1 > x2
if (p_inicial.x > p_final.x){
DrawLine(p_final, p_inicial, cor);
return;
}//if
dx = p_final.x - p_inicial.x;
dy = p_final.y - p_inicial.y;
if (dy < 0){ //Incremento decrescente
slope = -1;
dy = -dy;
}
else{//Incremento Crescente
slope = 1;
}
// Constante de Bresenham
incremento_E = 2 * dy;
incremento_NE = 2 * dy - 2 * dx;
d = 2 * dy - dx;
x = p_inicial.x;/**inicia x com o valor de p_inicial**/
y = p_inicial.y;
PutPixel(p_inicial.x, p_inicial.y, cor);
while(x != p_final.x){
if (d <= 0){
d += incremento_E;
x++;/**Adicionado incremento de x**/
}
else{
d += incremento_NE;
x++;/**Adicionado incremento de x**/
y += slope;
}
PutPixel(x, y, cor);
}
}//fim da DrawLine
Para testar este algoritmo, a modificação na função MyGlDraw é mostrada no trecho de código a seguir e posteriormente o resultado obtido:
Interpolação Linear e Rasterização para todos os quadrantes.
O caso mais simples de resolver é quando x0 > x1. Sempre que este
caso ocorrer basta inverter os pontos inicial e final da reta, o
resultado será a mesma reta, só que agora com x0 < x1. Com isso é
garantido que x0 < x1 sempre irá ocorrer.
Para o caso de y0 > y1, um dos problemas é que dy terá sinal
negativo, a solução será inverter o sinal de dy para que ele volte a ser
positivo. O outro problema é que y agora deverá ser decrementado e não
somente incrementado, como o algoritmo faz. A solução
será criar uma variável que permita que as coordenadas y sejam
incrementadas ou decrementadas dependendo da situação.
Para o caso de dx < dy, o algoritmo é praticamente o mesmo, basta
apenas trocar todos valores de dx por dy e vice-versa, levando em
consideração que agora y também irá variar quando d<=0, e não x.
Feitas essas modificações e implementado a
interpolação linear, o código final da função DrawLine é mostrado
abaixo:
void DrawLine(ponto p_inicial, ponto p_final, color color0, color color1){
color cor;
int slope = 1; // Diz se o incremento de y é crescente ou decrescente
int dx, dy, incremento_E, incremento_NE, d, x, y;
int i = 0;
// Onde inverte a linha x1 > x2
if (p_inicial.x > p_final.x){
DrawLine(p_final, p_inicial, color0, color1);
return;
}//if
dx = p_final.x - p_inicial.x;
dy = p_final.y - p_inicial.y;
if(p_inicial.y > p_final.y){
dy = -dy;
slope = -1;
}else{
slope = 1;
}
/*if (dy < 0){ //Incremento decrescente
slope = -1;
dy = -dy;
}
else{//Incremento Crescente
slope = 1;
}*/
PutPixel(p_inicial.x, p_inicial.y, color0);
/*// Constante de Bresenham
incremento_E = 2 * dy;
incremento_NE = 2 * dy - 2 * dx;
d = 2 * dy - dx;
*/
x = p_inicial.x;
y = p_inicial.y;
//PutPixel(p_inicial.x, p_inicial.y, color);/**Antes não tinha essa linha**/
if(dx >= dy){
// Constante de Bresenham
incremento_E = 2 * dy;
incremento_NE = 2 * dy - 2 * dx;
d = 2 * dy - dx;
while(x != p_final.x){
if (d <= 0){
d += incremento_E;
x++;/**Adicionado incremento de x**/
}
else{
d += incremento_NE;
x++;/**Adicionado incremento de x**/
y += slope;
}
/* Interpolação Linear de cores*/
i++;
int R = color0.R - ((i)/(float)dx) * (color0.R - color1.R);
int G = color0.G - ((i)/(float)dx) * (color0.G - color1.G);
int B = color0.B - ((i)/(float)dx) * (color0.B - color1.B);
int A = color0.A - ((i)/(float)dx) * (color0.A - color1.A);
cor.R = R;
cor.G = G;
cor.B = B;
cor.A = A;
PutPixel(x, y, cor);
}//while
}else{
int d = 2 * dx - dy;
int incremento_E = 2 * dx;
int incremento_NE = 2 * dx - 2 * dy;
while (y != p_final.y){//Enquanto y for diferente de y1
if (d <= 0) {//se d <= 0
d += incremento_E;//d será somado ao valor de incr_e
y+=slope;
} else {//Senão,
d += incremento_NE;//d será somado ao valor de incr_ne
x++;
y+=slope;
}
/* Interpolação Linear de cores*/
i++;
int R = color0.R - ((i)/(float)dx) * (color0.R - color1.R);
int G = color0.G - ((i)/(float)dx) * (color0.G - color1.G);
int B = color0.B - ((i)/(float)dx) * (color0.B - color1.B);
int A = color0.A - ((i)/(float)dx) * (color0.A - color1.A);
cor.R = R;
cor.G = G;
cor.B = B;
cor.A = A;
PutPixel(x, y, cor);
}
}
}//fim da DrawLine
color cor;
int slope = 1; // Diz se o incremento de y é crescente ou decrescente
int dx, dy, incremento_E, incremento_NE, d, x, y;
int i = 0;
// Onde inverte a linha x1 > x2
if (p_inicial.x > p_final.x){
DrawLine(p_final, p_inicial, color0, color1);
return;
}//if
dx = p_final.x - p_inicial.x;
dy = p_final.y - p_inicial.y;
if(p_inicial.y > p_final.y){
dy = -dy;
slope = -1;
}else{
slope = 1;
}
/*if (dy < 0){ //Incremento decrescente
slope = -1;
dy = -dy;
}
else{//Incremento Crescente
slope = 1;
}*/
PutPixel(p_inicial.x, p_inicial.y, color0);
/*// Constante de Bresenham
incremento_E = 2 * dy;
incremento_NE = 2 * dy - 2 * dx;
d = 2 * dy - dx;
*/
x = p_inicial.x;
y = p_inicial.y;
//PutPixel(p_inicial.x, p_inicial.y, color);/**Antes não tinha essa linha**/
if(dx >= dy){
// Constante de Bresenham
incremento_E = 2 * dy;
incremento_NE = 2 * dy - 2 * dx;
d = 2 * dy - dx;
while(x != p_final.x){
if (d <= 0){
d += incremento_E;
x++;/**Adicionado incremento de x**/
}
else{
d += incremento_NE;
x++;/**Adicionado incremento de x**/
y += slope;
}
/* Interpolação Linear de cores*/
i++;
int R = color0.R - ((i)/(float)dx) * (color0.R - color1.R);
int G = color0.G - ((i)/(float)dx) * (color0.G - color1.G);
int B = color0.B - ((i)/(float)dx) * (color0.B - color1.B);
int A = color0.A - ((i)/(float)dx) * (color0.A - color1.A);
cor.R = R;
cor.G = G;
cor.B = B;
cor.A = A;
PutPixel(x, y, cor);
}//while
}else{
int d = 2 * dx - dy;
int incremento_E = 2 * dx;
int incremento_NE = 2 * dx - 2 * dy;
while (y != p_final.y){//Enquanto y for diferente de y1
if (d <= 0) {//se d <= 0
d += incremento_E;//d será somado ao valor de incr_e
y+=slope;
} else {//Senão,
d += incremento_NE;//d será somado ao valor de incr_ne
x++;
y+=slope;
}
/* Interpolação Linear de cores*/
i++;
int R = color0.R - ((i)/(float)dx) * (color0.R - color1.R);
int G = color0.G - ((i)/(float)dx) * (color0.G - color1.G);
int B = color0.B - ((i)/(float)dx) * (color0.B - color1.B);
int A = color0.A - ((i)/(float)dx) * (color0.A - color1.A);
cor.R = R;
cor.G = G;
cor.B = B;
cor.A = A;
PutPixel(x, y, cor);
}
}
}//fim da DrawLine
Ao compilar e executar temos o seguinte resultado:
Rasterização de Triângulos
Feito todos os processos anteriores, rasterizar triângulo passa a ser o mais fácil, onde é só chamar a função DrawLine 3 vezes. Para isso, foi criado a função DrawTriangle, onde ela recebe como parâmetros os 3 pontos do triângulo e suas cores, onde a partir daí será feito as retas que formaram o triângulo.
Por fim, temos o seguinte resultado:
Referências
RASTERIZAÇÃO. In: WIKIPÉDIA, a enciclopédia livre. Flórida: Wikimedia Foundation, 2015. Disponível em: http://pt.wikipedia.org/w/index.php?title=Rasteriza%C3%A7%C3%A3o&oldid=35151352. Acesso em: 01 maio 2015.
ALGORITMO DE BRESENHAM. In: WIKIPÉDIA, a enciclopédia livre. Flórida: Wikimedia Foundation, 2015. Disponível em: http://pt.wikipedia.org/w/index.php?title=Algoritmo_de_Bresenham&oldid=34646662. Acesso em: 02 maio 2015.
LUCIANA MONTERA. INTERPOLAÇÃO LINEAR. Disponível em: http://www.facom.ufms.br/~montera/Interpolacao_alunos.pdf. Acesso em: 02 maio 2015.