corso di informatica grafica 1 introduzione quando si rappresentano modelli di oggetti 3d costituiti...

1Corso di Informatica grafica

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


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.


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

90

Osservatore



Per calcolare la normale alla superficie basta considerare due lati consecutivi del poligono, in ordine antiorario (per convenzione), e calcolarne il prodotto vettoriale:

V 0

V 2

V 1( )V V1 0( )V V2 1

n V V V V ( ) ( )1 0 2 1



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.



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.


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).


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.



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!)


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; } }}

4 3 5 1 2 3 4 5 1 2 3 4 5 1 2 3 4 1 5 2 3 4 1 2 5

3 4 1 2 5 3 4 1 2 5 3 1 4 2 5 3 1 2 4 5

etc .


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; }}


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; }}


Ripasso algoritmiQuick 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 { while (array[i] < pivot) i++; while (pivot < array[j]) j--; if (i <= j) { swap (array[i], array[j]); i++; j--; } } while (!(i > j)); if (left < j) quicksort(left, j, array); if (i < right) quicksort(i, right, array); }

7 3 5 1 2 4 3 1 2 4 5 7

3 1 2 5 7 etc.



Radix-sort

Sfrutta il fatto che è molto facile ordinare un array di numeri che appartengono ad un range limitato di valori.

Dec Hex Dec Hex Dec Hex Dec Hex 4 0100 4 0100 4 0100 1 0001 3 0011 5 0101 5 0101 2 0010 5 0101 1 0001 1 0001 3 0011 1 0001 2 0010 2 0010 4 0100 2 0010 3 0011 3 0011 5 0101

Sorting sui due bitmeno significativi

Sorting sui due bitpiù significativi



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



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;



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;

}



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:

A

B

m a x Z A

m a x Z B



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.

A

B

m i n Z A

m a x Z B

m i n Z B

AZmax



In quest’esempio però non funziona neppure la z media:

L’algoritmo del pittore, può essere ancora applicato.

BA C



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.

A

B

C

corso di informatica grafica 1 introduzione quando si rappresentano modelli di oggetti 3d costituiti...

Documents