1

Smoothing

Daniele Marini

2

Calcoli sui vettori

• Vettore normale• equazione del piano: ax+by+cz+d=0; si può anche scrivere come luogo:

e p è un qualunque punto nel piano; il vettore n è dato da:

n.(p−p0) =0

n=

a

b

c

⎡

⎣

⎢ ⎢ ⎢

⎤

⎦

⎥ ⎥ ⎥ e in coordinate omogenee: n=

a

b

c

0

⎡

⎣

⎢ ⎢ ⎢ ⎢ ⎢

⎤

⎦

⎥ ⎥ ⎥ ⎥ ⎥

3

In generale possiamo partire da tre punti non allineati: p0, p1, p2 con i quali determiniamo il piano (superfici approssimate con poliedri triangolarizzati).

Le differenze p2 - p0 e p1 - p0 sono coplanari e il loro prodotto dà la normale:

n = (p2 - p0) x (p1 - p0)

L’ordine è rilevanteL’ordine è rilevante

4

Per il calcolo di normali di superfici curve dipende da come la superficie è rappresentata, ma in generale si stima un gradiente. Es. sfera - equazione

f(x,y,z): x2 + y2 + z2 -1=0In forma vettoriale:

f(p): p.p -1 = 0Il vettore gradiente è dato da:

n=

∂f∂x∂f∂y∂f∂z

⎡

⎣

⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢

⎤

⎦

⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥

=

2x

2y

2z

⎡

⎣

⎢ ⎢ ⎢

⎤

⎦

⎥ ⎥ ⎥

=2p

5

Se la sfera è rappresentata in forma parametrica il metodo di calcolo cambia:

x=x(u,v) =cos(u)sin(v)

y=y(u,v)=cos(u)sin(v)

z=z(u,v) =sin(u)

con −π2

<u,v<π2

La normale si può ricavare dal piano tangente in p:

6

∂p∂u

=

∂x∂u∂y∂u∂z∂u

⎡

⎣

⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢

⎤

⎦

⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥

, ∂p∂v

=

∂x∂v∂y∂v∂z∂v

⎡

⎣

⎢ ⎢ ⎢ ⎢ ⎢ ⎢ ⎢

⎤

⎦

⎥ ⎥ ⎥ ⎥ ⎥ ⎥ ⎥

n=∂p∂u

×∂p∂v

n=cos(u)

cos(u)sin(v)

cos(u)cos(v)

sin(u)

⎡

⎣

⎢ ⎢ ⎢

⎤

⎦

⎥ ⎥ ⎥

=cos(u)p

Individuano due vettoritangenti il cui prodotto vettore individua la normale - poiché ci interessa solo la direzione si può dividere per cos(u) ottenendo un vettore unitario

7

Quando calcolare le normali?

• L’architettura a pipe line dei sistemi di rendering prevede che la normale di una faccia sia nota a priori (viene elaborato un vertice per volta e non tutta l’informazione è disponibile)• in generale è compito del programma applicativo calcolare la normale. OpenGL permette di associare a ogni vertice una normale (che dobbiamo calcolare noi nell’applicativo):

glNormal3f(nx,ny,nz);glNormal3fv(pointer_to_normal);

8

La luce trasmessa - rifrazione

Legge di Snell:

Per trovare il vettore trasmesso t: conosciamo cos(ul) da n ed l (se normalizzati basta il loro prodotto scalare), calcoliamo cos(ut):

sin(ul )sin(ut)

=ηt

ηl

€

cos(ut ) = 1−1

η 2(1− cos2(ul )

⎛

⎝ ⎜

⎞

⎠ ⎟

1/ 2

dove η =η t

η l

t=αn+βl

t=−1ηl− cos(ut) −

1η

cos(ul)⎛

⎝ ⎜ ⎜

⎞

⎠ ⎟ ⎟ n

Poiché i tre vettori sonocoplanari, si possono scrivere come combinazione lineare (uno si ricava come somma degli altri due), e imponendo lunghezza unitaria si trova t:

9

Angolo critico

cos(ut)= 1−1η2 (1−cos2(ul)

⎛

⎝ ⎜ ⎜

⎞

⎠ ⎟ ⎟

1/ 2

ovvero:

sin(ul )=η

Il valore di ul che rende nulla la:

Si chiama angolo critico, ovvero: l’angolo trasmesso è parallelo alla superfici, e per valori maggiori si ha riflessione e non trasmissione

10

Shading di poligoni(flat shading)

• N, V ed L variano su ogni poligono• se si assume osservatore “distante” e

sorgente di luce distante (in OGL si setta a falso il flag

near_viewer) V e L sono costanti• anche N è quindi costante sull’intero

poligono• Il calcolo di shading viene fatto per l’intero

poligono una sola volta

11

OGL e flat shading

glShadeModel(GL_FLAT);

La normale che OGL utilizza è quella associata al primo vertice del poligono

Per i triangle strip OGL usa la normale del terzo vertice per il primo triangolo, la normale del quarto per il secondo e così viaPer altre primitive valgono regole simili (vedi manuali)

12

Triangle strip

13

Effetti di flat shading

Bande di mach

14

Smooth shading (interpolato)

• Interpolazione di GouraudglShadeModel(GL_SMOOTH)

• Interpolazione di Phong

15

Gouraud

Le normali ai vertici di un poliedro vengono interpolate:

n=n1 +n2 +n3 +n4

n1 +n2 +n3 +n4

Gouraud usa interpolazione bilineare per calcolare il colore dei pixel lungo i singoli poligoni, quindi:-prima calcola colore ai vertici-poi interpola colore

16

Interpolazione bilineare

descriviamo i latiin forma parametrica, è il parametro

C4(α) =(1−α)C0 +αC1

C5(α)=(1−α)C2 +αC3

C45(α) =(1−α)C4 +αC5

interpoliamo lungo unalinea di scansione

17

Dipende dall’orientamento

18

Phong Smoothing• Basato sull’interpolazione

delle normali• il colore si calcola alla fine sul

singolo pixel

nα =(1−α)nC +αnBn(α,β) =(1−β)nC +βnD

19

Gouraud vs. Phong shading

• hardware• veloce• continuo fino al I

ordine• effetti lucentezza

limitati (migliorano se si aumenta la triangolazione)

• software• lento• continuo fino al II

ordine• si può applicare

modello di Phong per lucentezza

20

Sorgenti di luce in OGL

glLightfv(source, parameter, pointer_to_array)glLightf(source, parameter, value)

I parametri sono:Posizione (direzione) della sorgenteLivelli di

AmbienteDiffusaSpeculare

Associati alla sorgente

21

GLFloat light0_pos[]={1.0, 2.0, 3.0, 1.0}

Se si pone quarta componente a 0 la sorgente è all’infinito e definita come “direzione”

GLFloat light0_dir[]={1.0, 2.0, 3.0, 0.0}

GLFloat diffuse0[]={1.0, 0.0, 0.0, 1.0}

GLFloat ambient0[]={1.0, 0.0, 0.0, 1.0}

GLFloat specular0[]={1.0, 0.0, 0.0, 1.0}

Sorgente bianca con componenti di tutti e tre i tipi:

22

glEnable{GL_LIGHTING};glEnable{GL_LIGHT0};

glLightfv(GL_LIGHT0, GL_POSITION, light0_pos);glLightfv(GL_LIGHT0, GL_AMBIENT, ambient0);glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse0);glLightfv(GL_LIGHT0, GL_SPECULAR, specular0);

Se vogliamo comunque un contributo ambiente indipendente:

GLFloat global_ambient[]={0.1, 0.1, 0.1, 1.0};

glLightModelfv(GL_LIGHT_MODEL_AMBIENT, global_ambient);

23

Se vogliamo inserire un termine di attenuazione

f (d) =1

a+bd+cd2

glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, a);

Si può convertire la sorgente da puntiforme a spot, specificando: direzione GL_SPOT_DIRECTIONesponente GL_SPOT_EXPONENTangolo di soglia GL_SPOT_CUTOFF

Si usa sempre la glLightf o glLightfv

24

• OGL assume sempre l’osservatore a distanza infinita, in modo da considerare costante la direzione del viewer da ogni punto della scena

• Per forzare l’osservatore a condizioni di distanza non infinita si usa la:

glLightModel(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE)

25

• OGL non si preoccupa di fare shading delle facce nascoste; se si desidera vedere facce nascoste si può forzare con:

glLightModel(GL_LIGHT_MODEL_TWO_SIDED,GL_TRUE)

26

OGL e i materiali

GLFloat diffuse1[]={1.0, 0.8, 0.0, 1.0}

GLFloat ambient1[]={0.2, 0.2, 0.2, 1.0}

GLFloat specular1[]={1.0, 1.0, 1.0, 1.0}

glMaterialf(face, value)glMaterialfv(face, type, pointer_to_array)

glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient1);

glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse1);

glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular1);

27

Con GL_FRONT e GL_BACK si specificano proprietà differente per le facce frontali e nascoste

L’esponente nella componente speculare si specifica con:

GL_SHININESS

OGL permette di definire oggetti con componente emissiva:

GLFloat emission[]={0.0, 0.3, 0.3, 1.0};glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION,

emission)