Insieme di n vettori asse (qui: x,y,z )

Ripasso:

base vettoriale



Insieme di n vettori asse (qui: x,y,z )



Ogni vettore v esprimibile univoc.

come combinaz dei vettori asse



I pesi della combinaz sono le coord di v

y

x

z

Chiralità di un frame



Un sistema di riferimento ortogonale può essere sinistrorso o destrorso

sinistrorso destrorso

z y x  

Ricordiamoci di usare la STESSA MANO per immaginare il prodotto cross

z

y

x

 

Ripasso: sistema di

riferimento (geometric frame)



n vettori asse +

1 punto origine



Ogni vettore v

comb lineare degli n assi



Ogni punto p origine

+ comb. lin. assi

y

x

z o

(base vettoriale)

Trasformazioni spaziali

Punto

originale Punto

trasformato

f

Vettore

originale Vettore

trasformato

f

Trasformazioni spaziali



Funzioni



input: un punto (oppure un vettore)



output: un punto (oppure un vettore)



punti e vettori:

 rappresentati da coordinate



trasformazioni:

 “cambiano le coordinate”

 nuove coords = funz( vecchie coords ) p

f f f

q

q = (p) v = (u)

f f

Trasformazioni spaziali:

intro

Concetto molto generale…



Parte di molte strutture dati:



nello scene graph (trasf. di modellazione)



nelle animazioni cinematiche



nelle animazioni rigged (skeleton based)



Vengono usate in molti processi



nel rendering, dalla GPU (vertex shader!)



trasformazione di mollezione, di vista, di proiezione



trasformano geometria e normali delle mesh renderizzate



nella modellazione, interattivamente, dall’artista



per riposizionare, scalare, ruotare un oggetto, etc

f

Es 1: trasformazione spaziale di modellazione

Spazio Oggetto

Spazio Mondo

p

f f f

q

z

Object Coordinates



Diamo ad ogni oggetto il suo sistema di coordiante privato: il suo Object Space;

y

y

y

y x

x

x

x

z

z

z

z

y

x

Es: scene graph

Mondo

T1 T2 T3 T4

Es 2: trasformazioni nel rendering

Spazio Oggetto

Spazio Mondo

Spazio Schermo Spazio

Vista

Trasforamzione di Modellazione

Trasforamzione di Vista

Trasforamzione di Proiezione e Viewport

Object Space (spazio oggetto)



spazio oggetto

1

spazio oggetto (“spazio macchina”)

origineodello spazio oggetto

x y

2 3

-1 -2

-3

assixe ydello spazio oggetto

1 2 3

-1 -2 -3

Object Coordinates

1.5

2.3 p = (1.5, 2.3)

coordinate di p in spazio oggetto

x y

spazio oggetto

(“spazio macchina”)

Object Coordinates

1.5 2.3

p = (1.5, 2.3)

spazio oggetto (“spazio macchina”)

coordinate di p in spazio oggetto

x y

x y

spazio mondo

= (12.5, 8.1) 8.1

12.5

coordinate di p in spazio mondo

1 1

Object Coordinates

p = (1.5, 2.3)

spazio oggetto:

(“spazio macchina A”)

coordinate in spazio oggetto

x y

= (9.7, 4.2) 7.4

22.5

spazio oggetto:

(“spazio macchina B”) coordinate in spazio mondo

p = (1.5, 2.3)

= (22.5, 7.4)

9.7 1

1 4.2

spazio mondo

Classi utili

di trasformazioni spaziali



Isometrie (rototraslazioni)



“Mantengono le distanze”



Rotaz + Traslaz



Similitudini (trasformaz. conformali)



“Mantengono gli angoli”



Rotaz + Traslaz + Scaling uniforme



Lineari (trasformaz. affini)

) ( )

( )

( v

v

f v

f v

f       

Nota:

sono chiuse rispetto a combinazione

tr. affini similit.

isom.

Classi utili

di trasformazioni spaziali



Isometrie (rototraslazioni)



“Mantengono le distanze”



Rotaz + Traslaz



Similitudini (trasformaz. conformali)



“Mantengono gli angoli”



Rotaz + Traslaz + Scaling uniforme



Lineari (trasformaz. affini)







   

Come rappresento le trasformazioni



Per esempio, con una matr 4x4:

class Transform { // fields:

Mat4x4 m;

// methods:

Vec4 apply( Vec4 p ); // p in coord omogenee Vec3 applyToPoint( Vec3 p ); // p in coord cartes.

Vec3 applyToVector( Vec3 v ); // p in coord cartes.

… }

Come rappresento le trasformazioni



Oppure, per es, con matr3x3 + vett traslazione:

class Transform { // fields:

Mat3x3 m; // rotaz, skew, scale Vec3 t; // translaz

// methods:

Vec3 applyToPoint( Vec3 p ){

return m * p + t;

}

Vec3 applyToVector( Vec3 v ){

return m * p;

}

… }

Come rappresento le trasformazioni



Esempio…



(ipotizzando di avere una classe per rotazioni…)

class Transform { // fields:

float s; // scalatura, cioè dimensione Rotation r; // rotazione, cioè orientamento Vecor3 t; // translazione, cioè posizione // methods:

Vector3 applyToPoint( Vector3 p ){

return s * r.applyTo( p ) + t;

}

Vector3 applyToVector( Vector3 v ){

return s * r.applyTo( p ); // no traslazione!

}

… }

Reppresentazioni possibili per trasformazioni: criteri



Buone (o meno) per:



compattezza

 quanto sono prolisse in memoria?



facilità di applicazione

 quanto è oneroso applicare ad uno (o ventimila) punti / vettori?



interpolabilità

 è possibile/facile trovare un’inerpolazione fra N trasformaz date?

 quanto è “buono” il risultato



combinabilità

 è facile trovare la risultante di N trasformaz date, eseguite in successione?



invertibilità

 è facile trovare la trasformaz inversa?



intuitività

quanto è difficile spiegarla ai modellatori / editori di scene / etc

Perché è utile interpolare trasformaz:

esempio: animazioni

tempo 100

tempo 200 tempo 150

T ₁

T ₂ T _i

?

Perché è utile cumulare trasformaz:

esempio: scenegraph

spazio mondo (globale) spazio oggetto ruota 1 spazio oggetto automobile

Perché è utile cumulare trasformaz:

esempio: scenegraph

T c

T

T

T

T

T

T

T

“

T⁰

”

NOTA:

cumulazione di trasf.

NONcommuta!!!

Perché è utile invertire trasformaz:

switch between spaces

T T

-1

spazio mondo spazio oggetto A

Come rappresento le trasformazioni



Quindi servono metodi come:

class Transform { // fields:

…

// methods:

Vec3 applyToPoint( Vec3 p );

Vec3 applyToVector( Vec3 v );

Transform cumulateWith( Transform& t );

Transform inverse();

Transform interpolateWith( Transform& t , float k );

}

Sinonimi comuni al posto di interpolate:

blend, mix, lerp

Classi utili

di trasformazioni spaziali



Isometrie (rototraslazioni)



“Mantengono le distanze”



Rotaz + Traslaz



Similitudini (trasformaz. conformali)



“Mantengono gli angoli”



Rotaz + Traslaz + Scaling uniforme



Lineari (trasformaz. affini)

) ( )

( )

( v

v

f v

f v

f       

Un’altra classe di trasf (senza nome)

spesso usata nei Game Engines



Le trasformazioni ottenibili combinando:



Rotazioni



Traslazioni



Scalature… ma anche NON uniformi



(un altro sottoinsieme delle trasformazioni affini)



Utile in pratica



facile da specificare, abb. flessibile e intuitiva



Bruttina in teoria



non e’ chiusa rispetto a combinazione :-O :-(



(e non mantiene angoli)

Come rappresento le trasf.

isometriche / conformali



Sotto problema: come rappresento le rotazioni

class Transform { // fields:

Rotation r;

float s; // scale Vec3 t; // translation class Rotation {

// fields:

Mat3x3 m;

// methods: … }

Non

necessariamente cosi’!

stiamo per vedere valide alternative

Osservazione



se la mia trasformazione è rappresentata da



rotazione



+ traslazione



+ (eventualmente) scalatura



allora la posso agevolmente



applicare



cumulare



invertire



interpolare



a patto di saperlo fare con le rotazioni !

Osservazione

 Esempio: applicazione a punti e vettori

class Transform { // fields:

Rotation r;

Vec3 t; // translation

Transform applyToPoint( Vec3 p ){

return r.apply( p ) + t ; }

Transform applyToVector( Vec3 v ){

return r.apply( v ) ; }

}

nb: usata “a scatola chiusa”

Osservazione

 Esempio: interpolare transf

class Transform { // fields:

Rotation r;

Vec3 t; // translation

Transform mixWith( Transform b , float k ){

Transform result;

result.r = this.r.mixWith( b.r , k );

result.t = this.t * k + b.t * (1-k);

return result;

} }

Osservazione

 Esempio: inversione

class Transform { // fields:

Rotation r;

Vec3 t; // translation Transform inverse(){

Transform result;

result.r = this.r.inverse();

result.t = result.r.apply( -this.t );

return result;

} }

NB!

(perchè?)

Osservazione

 Esempio: cumulare trassf

class Transform { // fields:

Rotation r;

Vec3 t; // translation

Transform cumulateWith( Transform b ){

Transform result;

result.r = this.r.cumulateWith( b.r );

result.t = b.r.apply( this.t ) + b.t;

return result;

} }

NB!

(perchè?)