Roger
Fredy Larico Chavez
Texturas Procedimentais
Computação Gráfica
UNICAMP
2004
Texturas Processuais ou Procedimentais
Introdução
As texturas
procedimentais são imagens que não são armazenadas no disco duro como, por
exemplo, os mapas de bits (BMP, JPG, EPS, PSD...), eles são armazenados em
procedimentos ou algoritmos (matemáticos) que são capazes de gera-los.
Uma textura procedimental é desde um simples tabuleiro de xadrez ate textura de nuvens e montanhas.
É uma função Rn è R2 (duas dimensões)
É uma função Rn è R3 (3D)...
Existem infinidades de maneiras de fazer texturas procedimentais, mas os algoritmos utilizados são matematicamente comprovados, dado que uma desvantagem é o custo computacional.
Nesta monografia serão apresentadas somente às texturas de Perlin Noise e Cellular. Por ser as mais usadas para geração de texturas de água, montanhas, nuvens e outros fenômenos da natureza presentes freqüentemente em cenas virtuais. Na natureza há uma infinidade de funções matemáticas capazes de criar texturas ou modelos de elementos da natureza. Existe, no entanto, um conjunto de funções, as quais se costuma chamar de funções básicas, que funcionam como primitivas para uma grande classe de funções mais complexas a serem criadas posteriormente. Estas funções devem obedecer a algumas propriedades, sendo uma das principais o fato de apresentarem resultados aleatórios. Inicialmente, pode-se tomar como uma função básica à função random(), que gera valores aleatórios independente de qualquer parâmetro de entrada. Um exemplo gráfico do resultado gerado por esta função é o chuvisco de uma TV, não sintonizada em canal algum. Contudo, esta função possui uma série de inconvenientes, principalmente devido ao fato de que não possui parâmetros de entrada, não havendo, portanto controle algum sobre o seu resultado. Assim, não é possível garantir algo a respeito de uma coerência temporal do resultado, o que é de extrema importância para funções que irão gerar texturas ou modelos [Clua 99].
Finalmente, se apresentara alguns algoritmos para um processo inicial de aprendizado de texturas procedimentais de Perlin Noise e Cellular.
Figura gerada com Perlin Noise
Propriedades
Algumas propriedades que são fundamentais para serem obedecidas ao projetar uma função procedimental, e que, portanto são necessárias para qualquer função básica a ser construída:
· Pseudo-randômico: Os valores gerados pela função podem ser randômicos, mas sempre, para um mesmo valor dos parâmetros de entrada, a função deve retornar o mesmo resultado;
· Não pode haver periodicidade de padrões;
· Estas funções devem ser estacionárias, não variantes com relação à translação, e isotrópicas, não variantes com relação à rotação.
Existem inúmeras abordagens diferentes na tentativa de implementar funções que
obedeçam estas propriedades. A função noise é sem dúvida a função que se tornou mais
popular e deve-se a Ken Perlin [Perlin 85].
Justificativa
Importância:
Para fazer cenas mais realistas possíveis, e com o avanço da tecnologia é necessário o apoio de ferramentas matemáticas e combinação com as atuais ferramentas e técnicas. Todo isto sempre tendo presente a poupança de recursos computacionais.
Vantagens
As principais vantagens das texturas processuais são:
Densidade, como um mapa de bits está definido de maneira discreta (sabemos que a cor do ponto [1,2]) as texturas processuais estão definidas para todo Rn, então, é possível obter a cor do ponto [1.1415.., 2.1232..]. Então é possível obter o valor dela, e não só isso, não perceberá os quadradinhos molestos. Alem disso, as texturas esta bem feitas, poderão observar novos detalhes em quanto mais nos aproximemos.
São Infinitas: estão definidas para todo o espaço, quer dizer, que podemos consultar sem problemas que cor tem o ponto [2e234,-5e324], aliás, a textura não se repete (só se precisaremos) como a texturas de um mapa de bits.
Ocupam pouco espaço: Uma imagem grande, em mapa de bits ocupa muito. Por exemplo, uma imagem de 256*256 pixels com cor de 24 bits são 1.5 Megas, Na melhor compressão pode baixar até 5%. No entanto, as texturas procedimentais são de poucas linhas de código. Alem disso, onde as texturas procedimentais são mais úteis que os mapas de bits (as texturas de maior tamanho, ou de muita resolução e as de 3D).
Figura 1: Textura Procedimental 3D
Figura 2: corte em 3D a um sólido com textura
Texturas 3D: Pelo geral as texturas sempre vão estar coladas às superfícies por tanto, bidimensionais, no entanto, em algumas ocasiões é útil que a textura esteja definida para todo o espaço, e o que vejamos seja um 'corte' desta textura que ocupa todo um volume. Por exemplo, todos sabemos que a madeira de um tronco tem uma textura de círculos concêntricos marrões, na realidade sabemos que esses círculos estão no centro do tronco, que são cilindros concêntricos marrões. Definindo a textura em 3D, poderemos talhar a arvore e observar em todo momento como vai ficando a madeira cortada. Um mapa de bits (bitmap) não pode fazer isto, geraria arquivos muito grandes. Por exemplo, um bitmap de 256*256*256 pixels a 24 bits ocuparia 402 Megas.
Desvantagens:
Não se desenham, inventam-se: As texturas processuais estão definidas por um algoritmo matemático capaz de cria-las, e alguém deve fazer este algoritmo. Não se podem pintar texturas processuais com o Photoshop. Pintam-se com o Visual C++, Renderman, Builder...
CPU: Todo o que se liberou no disco duro, agora o tem que fazer o CPU processando o algoritmo que gera a textura. Quer dizer, que uma vez que temos sintetizado uma textura, falta otimiza-la.
As texturas processuais nunca substituirão aos mapas de bits, mas poderão releva-las em algumas tarefas.
Mapas de Texturas
Pelo geral, as texturas processuais estão compostas de mapas. Os mapas são texturas simples, pelo geral o branco e preto, que se fusionam com outros produzindo texturas complexas, enchendo canais de cor, canais de brilho entre outros.
Tipos de mapas:
Mapas geométricos:
Repetisse, pois não tem aleatoriedade. Algumas texturas com este tipo de mapas:
Figura 3: Aplicação de Mapas Geométricos em sólidos
São (pelos na teoria) fáceis de sintetizar, fazem muito uso da função MOD ou de operadores binários.
Mapas aleatórios e fractais:
Fazem uso de funções aleatórias. Não podem predizer a baixa escala, mas conseguem seguir patrões regulares: Em um caminho de pedras sempre há pedras, mas não há duas pedras iguais. Algumas texturas com mapas aleatórios:
Figura 4: Aplicação de mapas aleatorios em solidos
Estas texturas são muito mais complicadas de sintetizar e também precisam mais ciclos de processo, no entanto existem alguns algoritmos 'chave' de muito interesse. Por exemplo, o algoritmo do mapa Cellular é usado na Figura 4. E as nuvens são geradas usando o mapa Perlin Noise.
Para estas texturas é interessante uma Função Matemática (para cada elemento devolve outro) de aparência aleatória.
Implementação de Texturas procedimentais
O exemplo principal é mais utilizado, é o fundo de uma piscina, o refletir da luz e da piscina (Sombra Cáustica), faz uso dos mapas básicos muito típicos: Perlin Noise, e Cellular.
Conselhos básicos para fazer uma textura procedimental:
void
dibujar_ajedrez(int tam_casillas){
//partiendo
de un fon7do blanco
for(int y=1;
y<8;y++){ //for vertical de casillas
for (int x< =0; x<8;x++){ //for
horizontal de casillas
if((x+y) mod 2 = 1){ //si la casilla es negra
for (int j=0;j< tam_casillas){ //for
vertical de píxeles de una casilla
for (int i=0;i< tam_casillas{ //for
horizontal de píxele es una casilla
Pintar(x*tam_casillas+i,y*tam_casillas+j)=RGB(0,0,0);
}}
}
}
}
-----------------------------------------------------
int
ajedrez(x,y,tam_casillas){
if((int(x/tam_casillas)+int(y/tam_casillas))mod 2 = 1)
{return 0;} //negro
else
{return = 255;} // blanco
void dibujar_ajedrez_bien(int
tam_casillas){
for(int y=1;
y< fin_y;y++){ //for vertical de todos los pixels
for (int x<=0; x< fin_x;x++){ //for
horizontal de todos los pixels
int color=ajedrez(x,y,tam_casillas);
Pintar(x,y)=RGB(color,color,color);
}}
Ambos produzem mais ou menos a mesma imagem (quadrados brancos e pretos alternativamente), no entanto as estratégias são diferentes, no primeiro caso, considerando incorreto, utiliza-se uma ordem conveniente à hora de pintar os pontos, no segundo caso, utiliza-se uma ordem estrita (de arriba para baixo, de esquerda para direita, no entanto poderia ser qualquer outro), e uma função que devolve a cor tão só sabendo de que ponto se trata, independentemente da ordem de petição. Para os que tenham conhecimentos de matemáticas, existem similitudes entre o primeiro exemplo e una curva, ou superfície paramétrica, e o segundo com uma curva ou superfície implícita.
O segundo exemplo é recomendável: na tela, em uma área retangular plana, podemos escolher a ordem de pintado, mas 'na realidade', quando utilizemos a textura em uma cena 3D, ou como uma capa de outra textura, provavelmente só temos interesse na cor de alguns pontos, e não de todos (as caras visíveis, ou os que apareçam em um reflexo com RayTracing...). Poderíamos calcula-los todos na ordem da nossa conveniência, armazenamos em uma matriz, e depois consultar os necessários, mas como as texturas processuais são (ou podem ser) infinitas, não saberíamos ate onde teríamos que pré-calcular a textura.
Os mapas de texturas serão FUNCOES de consulta de cores e não de PROCEDIMENTOS de pintado.
A Função IntNoise:
Usualmente a técnica consistia em, antes de desenhar a textura, chamar a um procedimento inicialization; que pré-calculara esses números aleatórios e os deixara, pelo geral, em uma matriz em uma ordem de conveniência. Não podemos calcular infinitos números aleatórios e depois usa-los. Tampouco podemos usar simplesmente uma função aleatória baseada no relógio do sistema, pois é obvio que a textura não pode, por exemplo, cambiar de um frame a outro:
- Matriz pré-calculada de números aleatórios: é estável, mas finita, não se podem calcular demasiados números aleatórios.
- Calculo de números aleatórios em tempo real com função Rnd: é infinito, mas incontrolável, no próximo frame a pedra de oito cm do caminho será de quatro cm, o de seis..., alem disso, devido a que as funções dos mapas são implícitas, seria complicado reunir um grupo de pontos num só valor aleatório.
- IntNoise: é infinita, e é função, o número aleatório IntNoise(5) é o mesmo que IntNoise(5) em outro momento. IntNoise(x)=IntNoise(x)=aleatório
- IntNoise, como boa função aleatória não é continua, (não poderia ser porque esta definida para números inteiros). IntNoise(x) não tem porque aparentar se em nada a IntNoise(x+1). Proba disso é que a textura 255*IntNoise(i+j*ancho) é um Noise, de aparência similar a o que aparece quando ligamos a televisão sem conectar à antena.
///
Algoritmo con y sin IntNoise de una textura de cuadrados en distintos grises
aleatorios.
// ******** Sem IntNoise *********
int Colors[QuadradosX][QuadradosY]
void
initialization(){
for(j=0,j< QuadradosY; j++){
for(i=0;i< CuadradosX; i++){
Colors[i][j]=int(Rnd*255); //Donde Rnd da valores entre [0..1] aleatorios
}
}
void Pintar(int
tam_celda){
initialization();
int color;
for(y=0,y< MaxY; y++){
for(x=0;x< MaxX; x++){
color=Colors[int(x/tam_celda)][int(y/tam_celda)];
Pintar[x,y]=RGB(color,color,color)
}}
//********* Com IntNoise********
void Pintar(int tam_celda){
int color;
for(y=0,y< MaxY; y++){
for(x=0;x< MaxX; x++){
color=int(255*IntNoise[int(x/tam_celda)*const+int(y/tam_celda)]);
Pintar[x,y]=RGB(color,color,color)
}}
Como podemos observar, com a função IntNoise, nós poupamos a função
‘initialization’ e agora temos um
algoritmo que pode desenhar quadradinhos de distintos grises, sem nenhuma limitação, e com a seguridade de que, quando
volvamos a consultar as cores da textura, seguirão sendo os mesmos.
A variável const que não está declarada, indica que ali há que pôr um número. Para poder indexar coordenadas dos integers num só integer: isto é, para fazer uma aplicação bijectiva entre R^2 e R. Isto é algo realmente complicado para um plano infinito (há métodos mas muito caros no cálculo e não vale a pena). Sabendo que a textura vai ter um ancho definido, e que vamos precisar N números aleatórios por cada fila, então N é o valor para a constante (qualquer numero maior também é valido), basta com pôr um numero suficientemente alto, 5253 por exemplo, que garanta que não será apreciável a repetição de os números aleatórios.
O núcleo deste programa está na linha:
IntNoise[int(x/tam_celda)*const+int(y/tam_celda)]. Se temos um grupo de pixels que hão de compartir um mesmo numero aleatório (a cor de uma pedra, ou a altura relativa de uma montanha...) temos que procurar que todos estes chamem a IntNoise com o mesmo argumento.
Sabendo que propriedades têm a nossa função (matemática) IntNoise, temos que procurar uma implementação. A implementação embaixo é para a função IntNoise com [0..1]
float
IntNoise(int x)
{
x = (x<<13)^x;
return (((x * (x * x * 15731 + 789221) +
1376312589) & 0x7fffffff) / 2147483648.0);
}
|
|
Este mapa é provavelmente o mais útil e famoso de todos os que existem. O mapa Perlin é interessante porque tem duas propriedades: - Completa aleatoriedade e, - Coerência (quer dizer, que não há muita variação entre dos pontos contínuos, como acontece em Noise). |
É muito útil pois há muitos efeitos naturais que são seu fiel reflexo (água, nuvens ou montanhas são o mais típico), outras são pequenas modificações, como a madeira, e também as sombras do fundo da piscina fazem uso dela.
|
|
A criação do efeito é relativamente simples, consiste em
fazer uma quadricula com quadros de N pixels de lado e, a cada vértice dos
quadrados, associa-lo com um número aleatório. Os pixels que não estejam
exatamente acima de um destes vértices (a maioria), no interior de algum
quadrado, tomarão o valor da interpolação dos números aleatórios dos vértices
deste. Com este algoritmo se conseguem imagens como as da esquerda (Noise). |
Há muitas fórmulas matemáticas para a interpolação de pontos, algumas são:
Interpolação Linear:
E rápida, mas produz visíveis picos nos vértices, quedando uma imagem de não boa qualidade. Faz uso de 2 Pontos em 1D, 4 em 2D, 8 em 3D.
Interpolação Cossenoidal:
Não produz picos nos vértices, mas todos eles tem derivada 0, depois se observa claramente onde se encontram. Usa 2 Pontos em 1D, 4 em 2D, 8 em 3D.
Interpolação Cúbica:
De boa qualidade, é devagar no seu calculo, pois o algoritmo é complexo e faz uso de muitos pontos: 4 em 1D, 16 em 2D, 64 em 3D. Alem disso, pode fazer interpolações de pontos num recorrido ([0...255] por exemplo) que saiam um pouco desse recorrido.
Exemplo
Neste exemplo se utiliza uma interpolação similar à cossenoidal mas é mais rápida. Baseada no polinômio 3x^2-2x^3.
Este polinômio tem f '(0)=f '(1)=0, f(0)=0 y f(1)=0. Alem disso, é o menor polinômio que cumpre estas características.
Este polinômio é usado porque é muito mais rápido de avaliar que o equivalente cossenoidal: 0.5-0.5*cos(x*pi) e tem uma forma muito similar. Este é o código: a e b são valores qualquer, e x é a proporção de cercania entre um e outro: 0 se esta em a, 1 se esta em b.
float InterPol(float a, float b, float x){ //a altura 1a
return a+(b-a)*x*x*(3-2*x); //b altura 2 a
} //c si = 0 entonces
a, si = 1 entonces b
