Na TV e no cinema, essa tecnologia é utilizada para gerar cenas que seriam impossíveis de serem montadas

Filmes como Titanic, com efeitos fantásticos que foram desenvolvidos com ferramentas Linux, sempre despertam a atenção de especialistas e curiosos. Sabe-se apenas por cima, pelos comentários na mídia impressa, que foram usadas técnicas de processamento paralelo para acelerar a produção de seqüências renderizadas.

Para falar sobre Rendering escrevi este artigo, levando ao leitor o conhecimento básico de uma poderosa técnica de geração de ../imagens sintéticas em computador. Ela é usada em jogos para criar cenários, personagens e efeitos especiais, como nevoeiro, e outros. Na TV e no cinema, ela é utilizada para gerar cenas que seriam impossíveis de serem montadas em cenários reais. Hoje em dia, todas as áreas da ciência a utilizam para possibilitar a análise de dados complexos, como imagens de ressonância magnética, ultra-som, análise da aerodinâmica de túneis de vento, e muitos outros eventos.

O que está por trás de programas consagrados como o POV Ray (Persistence of Vison Raytracer), são algoritmos bastante espertos que produzem ../imagens tridimensionais com alta qualidade e requinte de detalhes. O POV Ray é um freeware para várias plataformas, que é usado em aplicações profissionais de altíssima qualidade. Para baixá-lo ou obter mais informações vá até www.povray.org. Lá você poderá conferir a complexidade das imagens geradas nas galerias do site ou em seus links. Eu uso apenas Linux e ferramentas como gcc, debugger e de custo zero, mas desenvolvo modelos matemáticos. Seu interesse talvez seja diferente do meu, e você queira apenas conhecer um pouco da tecnologia contida em programas de CAD-CAM, os modeladores 3D e renderizadores. Antes de começar, vamos definir alguns termos para facilitar nossas discussões e comentários. Uma imagem apresentada na tela do computador é uma representação sintética de uma cena. Esta cena é composta de objetos. Cada objeto é definido por pontos que descrevem sua posição no espaço, e por ligações entre os pontos que definirão seu formato ou geometria. Os pontos são conjuntos de quatro números que são as coordenadas do ponto (x,y,z), e um quarto número que representa um valor escalar relacionado com este ponto no espaço.

Este valor pode ser uma cor, caso o objeto seja um objeto real, ou uma velocidade, caso o objeto descreva pontos dentro do volume de água de um rio, ou ainda uma temperatura, caso os dados representem pontos dentro de uma barra de ferro sendo esquentada. Ou seja, os objetos podem representar uma infinidade de coisas diferentes, mas para o nosso entendimento, a grandeza representada por essa quarta coordenada não importa. Ela será vista na tela do computador como cor. E toda mudança de cor de um ponto para outro corresponde a uma mudança equivalente na grandeza que representa.

Técnicas de Rendering

São duas as principais técnicas de geração de ../imagens no computador: Ray Casting (emissão de raios) consiste em uma emissão "imaginária" de um raio através de cada pixel na tela do computador, e para cada objeto da cena atingido pelo raio, nós calculamos a contribuição de cor e de intensidade obtida para esse pixel. Para usarmos essa técnica, é necessário que tenhamos informação a respeito da conectividade entre os pontos. Conforme avançarmos no artigo, os termos serão explicados e exemplificados, tornando clara a idéia geral. Essa técnica é demorada, mas resulta em imagens precisas.

O Splating, por outro lado, projeta cada ponto do objeto na tela. Não é necessário que se tenha informação alguma a respeito das conexões entre os pontos. Cada ponto é projetado como uma esfera, alterando a cor e a intensidade de vários pixels da tela. Apesar de mais rápida do que o Ray Casting, em geral a imagem gerada por Splating é um pouco borrada. Comentarei aqui apenas o Ray Casting, reservando para outra edição um artigo sobre Splating.

Qual é a velocidade ideal?

Suponha que seu computador deverá gerar ../imagens e mostrar para você, como acontece num jogo eletrônico. Para que o nosso cérebro perceba uma movimentação suave, sem quebras de quadros, é preciso que o computador mostre trinta imagens por segundo. Para que o computador possa mostrar essas trinta imagens por segundo, cada imagem tem que ser gerada em menos do que 1/30 segundos, considerando também o tempo para a exibição delas. Em máquinas de poucos recursos, como os PCs, não conseguiremos essas taxas de amostragem, por diversos fatores técnicos.

Ray Casting

Para entendermos o conceito do ray casting, vamos imaginar que desejamos visualizar uma parede. As dimensões da parede são 3m de largura, 2.5m de altura e 0.2m de espessura.

Estou usando ponto nos decimais para evitar problemas na notação de pontos coordenados, em que a vírgula separa as coordenadas. Mas nós precisamos pensar num modo de representar essa parede no computador. Existem muitas formas de fazer isso. Escolho um modo bem simples que é o de declarar todos os pontos, e qual ponto se liga a qual. Considerando que o canto inferior esquerdo seja zero, nós teríamos:

Então para ficar mais simples, nós escrevemos os pontos:

E depois as conectividades:

p0 p1 p2 p3 # face dianteira

p4 p5 p6 p7 # face traseira

p0 p1 p5 p4 # face inferior

p0 p4 p7 p3 # face esquerda

p1 p5 p6 p2 # face direita

p2 p6 p7 p3 # face superior

Com esse conjunto de pontos e a conexão entre eles, nós já somos capazes de passar para a próxima etapa.

Qual é a relação entre as dimensões da parede e a tela do computador?

Transformação do objeto para o espaço da tela

A tela de um PC pode ter as seguintes resoluções: 640x480, 800x600, 1024x768, 1280x1024 e 1600x1200.

Essas são as resoluções mais comuns para uma SVGA. Vamos supor que abrimos uma janela de 200x200 em qualquer dessas resoluções, assim não precisamos nos preocupar com detalhes. Queremos utilizar toda a janela para gerar a imagem da parede. Lançamos mão da regra de três simples para fazer a conversão entre as dimensões da parede e os pixels da tela. Lembre-se de que os pixels vão de 0 a 199.

Largura:

Percorremos todos os pontos e pegamos os maiores e menores valores de cada coordenada. Obtemos então:

0 ² X ² 3

0 ² Y ² 2.5

0 ² Z ² .2

O X da parede vai de 0 a 3 metros, podendo assumir qualquer valor intermediário. Mas se dividirmos esses valores pelos seus máximos, então temos:

X’ = X/3 : Y’ = Y/2.5 : Z’= Z/.2

0 ² X’ ² 1

0 ² Y’ ² 1

0 ² Z’ ² 1

Enquanto isso, na tela, temos as seguintes relações entre suas coordenadas (x,y):

0 ² Px ² 199

0 ² Py ² 199

Ou:

Px’ = Px/199 : Py’ = Py/199

0 ² Px’ ² 1

0 ² Py’ ² 1

Então, se quisermos saber o ponto da parede que será tocado pelo raio que lançaremos pelo pixel (20,50) é só fazer a seguinte transformação:

X = Px’*3 = Px * 3 / 199

Y = Py’*2.5 = Py * 2.5 /199

Substituindo (20,50) nas fórmulas acima obtemos:

X = 0.30

Y = 0.63

Sabemos agora o ponto da parede que será tocado e podemos usar esses valores para calcularmos a interpolação dos valores escalares desse ponto. Existem várias formas de interpolação. Usaremos a linear que é a mais rápida possível, apesar de que em determinadas situações esse tipo de interpolação pode resultar em ../imagens de má

qualidade. Mas para o nosso exemplo é mais do que razoável.

Interpolação entre dois pontos. Considere os pontos (0,0,0) com valor 5 e o ponto (3,0,0) com valor 2.

Como obtivemos acima, X varia

de 0 a 1, ou seja, temos que calcular

a cor do ponto X como:

Cor(X’) = (1-X’)*5 + X’*2

O que isso significa é que quando:

X’ = 0 Æ Cor(0) = 5

X’ = 1 Æ Cor(1) = 2

Veja então que precisamos fazer uma interpolação equivalente para a borda superior, e então interpolar os novos valores entre as bordas inferior e superior.

Borda Inferior:

CorInf(X’) = (1-X’)*5 + X’*2

Borda Superior:

CorSup(X’) = (1-X’)*15 + X’*12

Cor desejada:

Cor(X’,Y’) = (1-Y’)*CorInf(X’) + Y’*CorSup(X’)

Cor(X’,Y’) = (1-Y’)*[(1-X’)*5+X’*2] + Y’*[(1-X’)*15 + X’*12]

Para se gerar a imagem completa, teríamos que percorrer toda a imagem. Apresentamos ao lado a título de ilustração um código não testado em C++.

Lembre-se de que tudo isso é apenas uma introdução à técnica de ray casting. Perceba no programa em C++ que eu escrevi os valores das cores dos cantos, mas eu deveria ter percorrido todos os pontos para extrair essas informações diretamente. Isso faria com que esse programa funcionasse para quaisquer outros valores.

Neste artigo não abordei tópicos como movimentar e girar o cenário, ou gerar cenas com objetos transparentes, mas o intuito foi mostrar a modelagem matemática nos algoritmos e técnicas de renderização.

float pontos[8][4] = {
{ 0, 0,   0,     5 },
{ 3, 0,   0,     2 },
{ 3, 2.5, 0,    12 },
{ 0, 2.5, 0,    15 },
{ 0, 0,   0.2,   8 },
{ 3, 0,   0.2,   3 },
{ 3, 2.5, 0.2,   1 },
{ 0, 2.5, 0.2,   6 }
};

int faces[6][4] = {
{ 0, 1, 2, 3 },
{ 4, 5, 6, 7 },
{ 0, 1, 5, 4 },
{ 0, 4, 7, 3 },
{ 1, 5, 6, 2 },
{ 2, 6, 7, 3 }
};

int Cor[200][200];

void main( void ) {
  for( int y = 0 ; y < 200 ; y ++ ) {
    float YLin = y * 2.5 / 199;
    for( int x = 0 ; x < 200 ; x++ ) {
      float XLin = x * 3 / 199;
      float CorXInf = ( 1 - XLin )*5  + XLin*2;
      float CorXSup = ( 1 - Xlin )*15 + XLin*12;
      float Cor[x][y] = ( 1 - YLin ) CorXInf + YLin*CorXSup;
    }
  }
}