Introduzione
Quando si rappresentano modelli di oggetti 3D
costituiti da facce poligonali secondo delle
proiezioni alcune delle facce non sono visibili.
Bisogna mostrare sul piano di proiezione
solamente le facce visibili.
Esistono diverse strategie per:
 determinare quali facce sono visibili
 rimuovere le superfici nascoste
Corso di Informatica grafica
1
Back face culling
Molti oggetti sono tali che il loro volume è
racchiuso da superfici (es. cubo).
Quando guardiamo questi oggetti possiamo vedere
solo le facce che stanno di fronte a noi, ma non
quelle dietro.
Quando i poliedri sono convessi è possibile
applicare la tecnica di back face culling per
determinare le superfici visibili. Nel caso di poliedri
concavi viene comunque impiegata, anche se non
elimina completamente tutte le facce nascoste.
Corso di Informatica grafica
2
Back face culling (2)
Questa tecnica utilizza il concetto di vettore
normale alla superficie.
Un poligono è visibile se la normale alla superficie
rispetto al vettore che va dall’osservatore al punto
del piano è inferiore a 90°.
 90
Osservatore
 90
Corso di Informatica grafica
3
Back face culling (3)
Per calcolare la normale alla superficie basta
considerare due lati consecutivi del poligono, in
ordine antiorario (per convenzione), e calcolarne il
prodotto vettoriale:
n  (V1  V0 )  (V2  V1 )
V2
(V2  V1 )
V0
Corso di Informatica grafica
(V1  V0 )
V1
4
Back face culling (4)
Occorre quindi effettuare il prodotto scalare tra
questa
normale
ed
il
vettore
che
va
dall’osservatore al punto della faccia. Se il
prodotto scalare è negativo la faccia è visibile.
Assumendo di aver già compiuto la proiezione
prospettica il prodotto scalare si riduce a
selezionare il poligono facendo semplicemente un
test sulla coordinata z della normale alla
superficie: se è negativa la faccia è visibile.
Corso di Informatica grafica
5
Back face culling (5)
Solitamente questa tecnica viene applicata prima
di compiere eventuali clipping, in modo da ridurre
il numero di poligoni da clippare.
I vettori normali possono essere pre-computati per
tutte le direzioni possibili della faccia (per tutte le
rotazioni e scaling non uniformi 3D). Si noti che i
vettori normali vengono utilizzati anche per
l’illuminazione della superficie.
Corso di Informatica grafica
6
Back to front sorting
Il back face culling non è in grado di eliminare
tutte le superfici nascoste se il poliedro è
concavo:
infatti,
non
individua
eventuali
sovrapposizioni tra poligoni.
Lo stesso problema si verifica se il mondo
contiene 2 o più poliedri (anche se convessi).
Corso di Informatica grafica
7
Back to front sorting (2)
Una tecnica per risolvere questo problema
consiste nello sfruttare le architetture frame buffer
degli hardware grafici (matrice di memoria in cui si
rappresenta il grafico).
Ogni volta che un poligono nella scena può
oscurare un altro poligono, è possibile
rappresentare correttamente la scena disegnando
(rasterizzando) le primitive in ordine inverso dalla
più distante alla più vicina all’osservatore, in modo
da sovrascrivere gli oggetti più distanti.
Questa tecnica è nota anche come algoritmo del
pittore.
Corso di Informatica grafica
8
Back to front sorting (3)
Per ottenere un algoritmo back-to-front basta
applicare un algoritmo di sorting utilizzando un
particolare criterio di comparazione.
Il criterio più semplice effettua l’ordinamento
rispetto alla massima coordinata z.
Algoritmi di sorting:
 Bubble-sort (complessità O(n2))
 Quick-sort (complessità O(n log n))
 Radix-sort (complessità O(n) lineare!! - richiede
però più memoria!)
Corso di Informatica grafica
9
Ripasso algoritmi
ORDINAMENTO PER SCAMBIO
void ordinamentoScambio(int vett[], int dim)
{
int ordinato; int temp; ordinato = FALSO;
while (!ordinato)
{
ordinato = VERO;
for(int j = 0; j < dim-1; j++)
if (vett[j] > vett[j+1])
{
temp = vett[j]; vett[j] = vett[j+1]; vett[j+1] =
temp;
ordinato = FALSO;
43512 34512 34512 34152 34125
}
34125 34125 31425 31245
}
}
etc .
Corso di Informatica grafica
10
Ripasso algoritmi
ORDINAMENTO PER INSERIMENTO
void ordinamentoInserimento(int vett[], int dim)
{
int curr;
for(int i = 1; i < dim; i++)
{
curr = vett[i];
int j = i;
while ((j > 0) && (curr < vett[j-1]))
{
vett[j] = vett[j-1];
j--;
}
vett[j] = curr;
}
}
Corso di Informatica grafica
11
Ripasso algoritmi
ORDINAMENTO PER SELEZIONE
void ordinamentoSelezione(int vett[], int dim)
{
int temp, posmin;
for(int i = 0; i < dim-1; i++)
{
posmin = i;
for(int j = i + 1; j < dim; j++)
if (vett[j] < vett[posmin])
posmin = j;
temp = vett[i];
vett[i] = vett[posmin];
vett[posmin] = temp;
}
}
Corso di Informatica grafica
12
Ripasso algoritmi
Quick sort:
void quicksort (int left, int right, int array []) {
int i = 0, j = 0, pivot = 0;
i = left; j = right;
pivot = array[(left + right) / 2];
do {
735124
while (array[i] < pivot) i++;
312457
while (pivot < array[j]) j--;
if (i <= j) {
312
57
swap (array[i], array[j]);
i++;
etc.
j--;
}
}
while (!(i > j));
if (left < j) quicksort(left, j, array);
if (i < right) quicksort(i, right, array);
}
Corso di Informatica grafica
13
Back to front sorting (4)
Radix-sort
Sfrutta il fatto che è molto facile ordinare un array
di numeri che appartengono ad un range limitato
di valori.
Dec Hex
4 0100
3 0011
5 0101
1 0001
2 0010
Dec Hex
4 0100
5 0101
1 0001
2 0010
3 0011
Sorting sui due bit
meno significativi
Corso di Informatica grafica
Dec Hex
4 0100
5 0101
1 0001
2 0010
3 0011
Dec
1
2
3
4
5
Hex
0001
0010
0011
0100
0101
Sorting sui due bit
più significativi
14
Back to front sorting (5)
Con questo algoritmo vengono ordinate le radici
(es. unità, decine, centinaia etc. in base 10), dalle
meno significative (unità in base 10) alle più
significative.
Al primo passo si ordinano i numeri rispetto alla
prima radice (ad es. le unità).
Al secondo passo si ordinano i numeri ordinati al
passo precedente rispetto alla seconda radice (ad
es. le decine). E così via.
Ad ogni passo occorre preservare l’ordine dei
passi precedenti.
Numero di iterazioni necessarie: numero dei dati x
numero delle radici (costante per un insieme dato
di numeri) --> complessità lineare
Corso di Informatica grafica
15
Back to front sorting (6)
Quest’algoritmo funziona molto bene per numeri in
base 2 (il test può essere compiuto con un AND).
Codice:
// consideriamo numeri da 8 bit
short data[];
short oneArray[numData], zeroArray[numData];
int numOnes, numZeros;
int mask=1; //per calcolare l’AND
for (radix=0; radix<8; radix++){
numZeros=0;
numOnes=0;
Corso di Informatica grafica
16
Back to front sorting (7)
for (i=0; i<numData; i++){
if(data[i]&mask){
oneArray[numOnes]=data[i];
numOnes++;
}
else {
zeroArray[numZeros]=data[i];
numZeros++;
}
}
memcpy(data,oneArray,numOnes);
memcpy(data+(numOnes),zeroArray,
numZeros);
mask<<=1;
}
Corso di Informatica grafica
17
Back to front sorting (8)
Nota: memcpy(s,ct,n) copia n caratteri di ct in s e
restituisce s
Il criterio di scegliere la z massima non è corretto in
generale:
max Z A
max Z B
A
B
Corso di Informatica grafica
18
Back to front sorting (9)
L’ordinamento basato sulla massima z oppure sulla
z media è ammissibile quando i poligoni hanno la
stessa dimensione, altrimenti è necessario
applicare metodi di sorting più complessi.
Ad es. nel seguente grafico o nel grafico
precedente si può applicare la z media.
max Z A
A
min Z A
max Z B
B
Corso di Informatica grafica
min Z B
19
Back to front sorting (10)
In quest’esempio però non funziona neppure la z
media:
A
L’algoritmo
applicato.
Corso di Informatica grafica
del
B
pittore,
C
può
essere
ancora
20
Back to front sorting (11)
Se invece si ha mutua sovrapposizione di poligoni
l’algoritmo del pittore non si può più applicare. Non
è possibile ordinare in nessun modo i poligoni.
C
B
A
Corso di Informatica grafica
21