TRASFORMAZIONI GEOMETRICHE prima versione: equazioni di trasformazione

Introduzione alla Grafica Digitale Visualizzazione e trasformazioni geometriche: la "catena di montaggio" dell'immagine o "viewing pipeline" : costruzn. scena in coordinate-mondo (modelingtransf.) trasforma coordin. mondo in coordin. vista (viewing) trasf. coord.vista in coord.normalizz. window->viewport trasforma coordin. normalizzate in coor. schermo (device) l'oggetto (con piu'parti, ciascuna trasformata opportunamente con traslazione,rotazione,scalaggio) e' definito in coordinate modello (modelling space), poi inserito in un mondo - coordin. problema (world coordinate system), in unita' di misura utente (km, mm, micron,anni luce, secondi, tonnelate); interessa vedere solo una parte di questo mondo, parte che e' ritagliata (clipping) dalla finestra di visualizzazione (viewing window) seguito dalla trasformazione in coordinate schermo ( spesso c'e' in mezzo un passaggio coord.window in coord. normalizz. in una finestra unitaria (min=zero, max=uno) 2

due osservazioni: molto spesso una scena e' fatta con piu' oggetti molto simili, ad es. una scena di traffico presenta molti oggetti "automobile", che possono essere pensati come repliche di un unico oggetto base (piu' istanze di un ogetto base); un mazzo di fiori puo' essere pensato come un insieme di istanze dell'oggetto fiore ecc;

un'altra caratteristica presente in molte scene e' l'appartenenza di un oggetto come parte di un sistema composto, ad es. le dita di una mano hanno una posizione relativa al braccio P1, e questo a sua volta una posizione relativa al corpo P2, e infine il corpo ha una posizione relativa alla scena (al mondo) P3; la posizione del dito e' data dalla composizione delle tre posizioni relative P1, P2 e P3; ancora: posizione di un "satellite" di un "pianeta" di un "sistema solare" di una "galassia" ecc; -> "composizione e ereditarieta' delle posizioni" : "pianeta" "satellite" "sistema solare"

le trasformazioni geometriche sono usate sempre per la visualizzazione di oggetti:

a) Translation (2 parameters) b) Scale (2 parameters + P) c) Rotation (1 parameter +P) d) Shear (2 parameters) le trasformazioni affini conservano il parallelismo

Trasformazioni geometriche Le trasformazioni geometriche permettono di istanziare una stessa geometria con attributi diversi (posizione, orientamento, fattori di scala) .

Trasformazioni geometriche Entità geometriche Punto - entità geometrica caratterizzata da un solo attributo: la posizione rispetto ad un sistema di riferimento (x,y) in 2D, (x,y,z) in 3D Vettore - entità geometrica caratterizzata da due attributi: lunghezza e direzione (l,x,y) in 2D Lunghezze, angoli, etc. sono espresse mediante scalari.

Trasformazioni geometriche Spazio vettoriale Due entità: Scalari (a, b, c, … ) Vettori (T, U, V, … ). Operazioni: Somma e moltiplicazione di scalari; Somma vettore + vettore; Moltiplicazione scalare * vettore.

Trasformazioni geometriche Spazio affine Tre entità: Scalari (a, b, c, … ) Vettori (T, U, V, … ) Punti (P, Q, R, … ) Operazioni: Le operazioni di uno spazio vettoriale, Somma punto + vettore (restituisce un punto), Sottrazione punto - punto (restituisce un vettore).

Trasformazioni geometriche Le trasformazioni geometriche sono lo strumento che consente di manipolare punti e vettori all’interno del mondo dell’applicazione grafica; Le trasformazioni geometriche sono funzioni che mappano un punto (vettore) in un altro punto (vettore); La trasformazione di una primitiva geometrica si riduce alla trasformazione dei punti caratteristici (vertici) che la identificano nel rispetto della connettività originale. Questo grazie al fatto che trattiamo di trasformazioni affini; il resto della primitiva grafica, ridisegnato sulla base dei punti caratteristici nuovi, sara' disegnato trasformato di conseguenza (es. per un'ellisse o un cerchio: si trasla il centro e si ridisegna con lo stesso raggio)

Trasformazioni geometriche Le trasformazioni geometriche affini sono trasformazioni lineari Esse preservano: collinearità (I punti di una linea giacciono ancora su di una linea dopo la trasformazione); rapporto tra le distanze (Il punto medio di un segmento rimane il punto medio di un segmento anche dopo la trasformazione).

Trasformazioni geometriche operazioni base usate nel processo di visualizzazione sono: trasformazioni geometriche nel piano 2D, un primo elenco: traslazione (translation) rotazione (rotation) scalatura (scaling) inclinazione (shear) (= scalatura e cambio angolo degli assi x,y) 13

Trasformazioni geometriche operazioni base usate nel processo di visualizzazione sono: trasformazioni geometriche nel piano 2D, un primo elenco: traslazione (translation): x1 = x+tx; y1 = y+ty; rotazione (rotation) x1= x*cos(a)-y*sin(a); y1= x*sin(a)+y*cos(a); scalatura (scaling) x1 = x*sx; y1 = y*sy; inclinazione (shear) (= scalatura e cambio angolo degli assi x,y) x1 = x+shx*y; y1 = y+x*shy; (dove shx oppure shy e' zero) 14

Trasformazioni geometriche operazioni base usate nel processo di visualizzazione sono: trasformazioni geometriche nel piano 2D, un primo elenco: traslazione (translation) rotazione (rotation) scalatura (scaling) inclinazione (shear) inoltre nel passaggio da scena utente a immagine su schermo: eliminazione parti fuori scena (clipping) riempimento parti a colore pieno (filling) mascheramento (masking) di parti coperte da altri oggetti sullo schermo (es. menu', altre finestre ecc) ==>> vediamo in dettaglio queste trasformazioni 15

Trasformazioni geometriche - traslazione trasformazioni geometriche nel piano: traslazione (translation): x1=x+tx; y1=y+ty; in notazione vettoriale: rappresento con vettore colonna P = P' = T = da cui : P' = P + T la traslazione trasforma un oggetto grafico (geometrico) senza deformazione, ogni punto dell'oggetto e' traslato per la stessa quantita'; la traslazione dell'oggetto avviene traslando tutti i punti dell'oggetto e poi ridisegnando l'oggetto | x | | x' | | tx | | y | | y' | | ty | 16

Trasformazioni geometriche- traslazione traslazione (translation): x2 = x1 + tx; y2 = y1 + ty; P2 = P1 + T P1 = P2 = T = | x1 | | x2 | | tx | | y1 | | y2 | | ty |

Trasformazioni geometriche- traslazione traslazione (translation): x1=x+tx; y1=y+ty; in notazione vettoriale: P' = P + T con P = P' = T = la traslazione trasforma senza deformazione, tutti i punti dell'oggetto sono traslati e poi ridisegnati ... ma: per un'ellisse o un cerchio: si trasla il centro e si ridisegna; curve a tratti di cubiche (spline): si traslano i punti pivot e poi si ridisegna; c'e' una funzione per traslare (tutti gli oggetti) OGL: glTranslatef( dx,dy, dz ); (con dz==0.0 nel piano) effetto (significato): tutti gli oggetti disegnati dopo la chiamata glTranslatef (punti o vertex) sono visualizzati traslati; | X1 | | X' 1 | | tx | | X2 | | X' 2 | | ty | 18

Trasformazioni geometriche- traslazione un frammento di programma con esempio di uso della glTranslatef(...): ... glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(dX,dY,0.0); // trasla == prepara ... // la matrice ... myDrawLines(); // disegna glutSwapBuffers(); // mostra la funzione glTranslate modifica la matrice di trasformazione (qui sopra specificata con glMatrixMode(GL_MODELVIEW);) e quindi nella catena di visualizzazione sara' traslata la parte del disegno seguente alla glTranslate ( myDrawLines(); ) !

Trasformazioni geometriche- traslazione ancora qualche osservazione: la traslazione cambia nello stesso modo tutti i punti del piano, ==>> non c'e' un punto fisso (pivot) come c'e' nella rotazione o nello scalaggio (vedremo); composizione di piu' traslazioni: posso applicare piu' traslazioni con ordine arbitrario, se x' = x + Tx e se x'' = x' + T'x allora x'' = x' + T'x = x + Tx + T'x = x + T'x + Tx

Trasformazioni geometriche - rotazione trasformazioni geometriche nel piano: 2) rotazione (rotation) attorno l'origine: x1=x*cos(a)-y*sin(a); y1=x*sin(a)+y*cos(a); queste equazioni si ottengono ricordando le coordinate polari: x = r*cos(a) y = r*sin(a) rotazione: cambio angolo a, ovvero: a' = a+da da cui: x' = r*cos(a+da) = r*cos(a) * cos(da) - r*sin(a) * sin(da) y' = r*sin (a+da) = r*cos(a) * sin (da) + r*sin(a) * cos(da) quindi x' = x * cos(da) - y * sin (da) y' = x * sin (da) + y * cos(da) r y a x 21

Trasformazioni geometriche - rotazione la rotazione (nel piano x,y) e' sempre attorno ad un punto, qui, l' origine: in OGL si specifica l'angolo e l'asse attorno cui si ruota: glRotatef ( alfa, 0.,0.,1. ); P1 P da nota: la rotazione in generale si riferisce ad un asse di rotazione (che puo' essere diverso dagli assi x, y e z) - la rotazione nel piano x,y e' una rotazione attorno l'asse z !

Trasformazioni geometriche - rotazione rotazione di un angolo a attorno all'origine : essendo x = r*cos(a) y = r*sin(a), e dato che una rotazione cambia angolo a, ovvero: a' = a+da, si ottiene: x2 = x1 * cos(da) - y1 * sin (da) y2 = x1 * sin (da) + y1 * cos(da) notazione vettoriale: la rotazione e' data dalla moltiplicazione del punto (vett.colonna) per la matrice di rotazione : P2 = R * P1 con R = 23 | cos(da) -sin(da) | | sin(da) cos(da) |

Trasformazioni geometriche - rotazione se applico di seguito due rotazioni con angolo da1 e da2 (sempre attorno all'origine) ho a2 = a + da1 + da2 e vale la formula riportata prima, (l' ordine non importa!) : x1 = x * cos(da1) - y * sin (da1) y1 = x * sin (da1) + y * cos(da1) P1 = R1 * P (notazione vettor.) x2 = x1 * cos(da2) - y1 * sin (da2) y2 = x1 * sin (da2) + y1 * cos(da2) P2 = R2 * P1 P2 = R2*R1*P = R21 * P con R21 = R2*R1 P1'' P1' P1 da2 da1

abbiamo visto la rotazione attorno all'origine; vediamo ora una rotazione attorno un punto generico Q (xcr, ycr) detto centro di rotazione ? P1' P1 da y-ycr x=xcr + (x-xcr) y=ycr + (y-ycr) e quindi: x-xcr Q ycr x' = xcr + (x-xcr ) * cos(da) - (y-ycr ) * sin(da) y' = ycr + (x-xcr ) * sin(da) + (y-ycr ) * cos(da) xcr

rotazione attorno a un punto generico(xcr , ycr) x' = xcr + (x-xcr ) * cos(da) - (y-ycr ) * sin(da) y' = ycr + (x-xcr ) * sin(da) + (y-ycr ) * cos(da) ottengo la stessa cosa con lo schema seguente: 1) trasla in modo che il punto va nell'origine 2) ruota quanto richiesto attorno l'origine, poi 3) trasla indietro il punto dall'origine al suo posto in OpenGL: ... glTranslatef( MyCenterX, MyCenterY, 0.0 ); glRotatef ( alfa, 0.0, 0.0, 1.0 ); glTranslatef( -MyCenterX, -MyCenterY, 0.0 );

nota: le operazioni di traslazione e di rotazione NON sono commutative ! due trasformazioni dello stesso tipo sono commutative, ad es. traslazioni: T2 ( T1 ( P )) == T1 ( T2 ( P)) oppure rotazioni: R1 ( R2 ( P )) == R1 ( R2 ( P)) scalatura: S2 ( S1 ( P )) == S1 ( S2 ( P)) ma non in generale: T2 ( R1 ( P ) ) != R1 ( T2 ( P ) ) esempio..

traslazione e rotazione non sono commutative - trasla poi ruota centro di rotazione 3 2 1 ruota poi trasla centro di rotazione 2 3 1 traslazione e rotazione non sono commutative - l'ordine delle trasformazioni e' importante !

e puo' essere invertita con una "anti-trasformazione" : nota: in generale una trasformazione affine che trasforma un oggetto di punti in un nuovo oggetto (fatta da zero o piu' traslazioni, rotazioni e scalature) e' reversibile, e puo' essere invertita con una "anti-trasformazione" : ad esempio la sequenza trasla1-ruota2-trasla3-scala4 seguita da una sequenza anscala4-antrasla3-anruota2-antrasla1 (dove "antrasla" sta per l' antitrasformata della trasla ecc) che riporta l'oggetto alla situazione iniziale (attenzione all'ordine) unica eccezione: la scalatura per fattore zero non e' reversibile: un fattore di scala zero distrugge l'immagine!

rotazione x1=x*cos(a)-y*sin(a); y1=x*sin(a)+y*cos(a); vediamo ora trasformazioni geometriche nel piano: abbiamo visto la traslazione x1=x+tx; y1=y+ty; e la rotazione x1=x*cos(a)-y*sin(a); y1=x*sin(a)+y*cos(a); vediamo ora scalatura (scaling) x1=x*sx; y1=y*sy; i fattori di scala sx e sy sono numeri positivi sx>1 ingrandisce, sx<1 rimpiccolisce nota che sx in genere e' diverso da sy ! notazione vettoriale: P' = S * P dove P e P' sono due punti, S = e S e' una matrice 2x2 30 | sx 0 | | 0 sy |

la trasformazione di scala (vista) si intende rispetto l' origine l'origine == punto (0,0) NON cambia posizione tutti gli altri punti in generale si' (ma nella figura in basso tutti i punti sull'asse y non cambiano posizione) ---------->> x' = x * 2.0; y' = y * 2.0; 1 1 ---------->> x' = x * 2.0; y' = y; 1 1

la trasformaz.e di scala vista ora si intende rispetto l' origine l'origine == punto (0,0) NON cambia posizione anche la trasformazione di scala (come la rotazione) ha un centro di trasformazione ! nota: un fattore di scala <1 avvicina gli oggetti all'origine (oltre che rimpiccolirli), un fattore di scala > 1 allontana gli oggetti dall'origine. per l'operazione di scalatura attorno un punto generico "centro scalatura" si procede come per la rotazione: 1) trasla fino a portare il punto fisso nell' origine: P' = P - CS 2) scala P'' = S * P' (quindi x'' = sx*x' = sx*( x-x0 ) .. 3) trasla indietro: P''' = P''+CS (x'''=x''+x0= sx*( x-x0 )+x0 ..) l'effetto complessivo e' la trasformazione di scala attorno il punto fisso: x = Sx * (x - x0) + x0; y = Sy * (y - y0) + y0;

---------->> x' = 2 * (x - 1) + 1; y' = 2 * (y - 1) + 1; 3 1 2

abbiamo visto le trasformazioni geometriche nel piano: traslazione (translation): x'=x+tx; y'=y+ty; rotazione (rotation) x'=x*cos(a)-y*sin(a); y'=x*sin(a)+y*cos(a); scalatura (scaling) x'=x*sx; y'=y*sy; vediamo la trasformazione di scorrimento rispetto un asse: o deformazione (scorrimento o inclinazione ) rispetto un'asse, in inglese shear: shear x'=x+shx*y; y'=y; es: 34

shear | sh i(ə)r| |ʃɪ(ə)r| |ʃɪə| verb ( past part. shorn | sh ôrn| |ʃɔrn| |ʃɔːn|or sheared |ʃɪ(ə)rd|)1 [ trans. ] cut the wool off (a sheep or other animal).･ ...| [ trans. ] the left wing had been almost completely sheared off. noun a strain in the structure of a substance produced by pressure, when its layers are laterally shifted in relation to each other. See also wind shear . ORIGIN Old English sceran (originally in the sense [cut through with a weapon] ), of Germanic origin; related to Dutch and German scheren, from a base meaning ﾔdivide, shear, shave.ﾕ

in generale si puo' avere uno scorrimento rispetto una retta la trasformazione shear x'=x+shx*y; y'=y; in generale si puo' avere uno scorrimento rispetto una retta generica, ad es: x'=x + shx * ( y - yrif ); y'=y; 36 qui x' = x + 0.4 * (y - yref ); y' = y; con yref = -2 analogamente per scorrimento in direzione dell'asse y

abbiamo visto le trasformaz.i geometriche nel piano: traslazione (translation): x1=x+tx; y1=y+ty; rotazione (rotation) x1=x*cos(a)-y*sin(a); y1=x*sin(a)+y*cos(a); scalaggio (scaling) x1=x*sx; y1=y*sy; shear (deformaz. di scorrimento lungo asse x o y ) x1=x+shx*y; y1=y+x*shy; dove o shx oppure shy e' zero rimangono da vedere (piu' in la') : 37

abbiamo visto le trasformaz.i geometriche nel piano: traslazione (translation): x1=x+tx; y1=y+ty; rotazione (rotation) x1=x*cos(a)-y*sin(a); y1=x*sin(a)+y*cos(a) scalaggio (scaling) x1=x*sx; y1=y*sy; shear (inclinazione/deformaz. di scorrimento lungo asse x o y ) x1=x+shx*y; y1=y+x*shy; dove o shx oppure shy e' zero rimangono da vedere (ma lo vedremo piu' in la') : riflessione attorno una retta o attorno ad un punto, eliminazione parti fuori scena (clipping) riempimento parti a colore pieno (filling) mascheramento (masking) di parti coperte da altri oggetti sullo schermo (es. menu', altre finestre ecc) 38

MATRICI E COORDINATE OMOGENEE una trasformazione affine nel piano si puo' scrivere nella forma matriciale: P1 = M1 * P + M2 con P1, P punti del piano e con M1 matrice 2x2, M2 matrice colonna di 2 elementi (usata per la traslazione)

traslazione: x1=x+tx;y1=y+ty; in notazione vettoriale: trasformazione affine nel piano in forma matriciale: P1 = M1 * P + M2 dove P1, P sono punti del piano, M1 matrice 2x2, M2 matrice colonna di 2 elementi (traslaz.) traslazione: x1=x+tx;y1=y+ty; in notazione vettoriale: P = (x,y), P' = (x',y'), T =(tx,ty), da cui : P' = P + T rotazione: x'= x*cos(da)-y*sin(da), y'= x*sin(da)+y*cos(da) in notazione vettoriale: P1 = R * P con la matrice R = scalatura: x1=x*sx; y1=y*sy; in notazione vettoriale: P2 = S * P | cos(da) -sin(da) | | sin(da) cos(da) |

traslazione: in notazione vettoriale: P = (x,y), P' = (x',y'), T =(tx,ty), da cui : P' = P + T rotazione: in notazione vettoriale: P1 = R * P con la matrice R = scalatura: in notazione vettoriale: P3 = S * P2 rotazione e scalatura possono essere concatenate: P3 = S * P2 = S * ( R * P1 ) = (S * R ) * P1 = M * P1, M matrice 2x2, P punto del piano; ma attenzione: la traslazione non puo' essere concatenata e inglobata in un'unica matrice (non e' un prodotto, e' una somma); | cos(da) -sin(da) | | sin(da) cos(da) |

si passa alle coordinate omogenee: trasformazione generica: P2 = M3 * ( M1 * P1 + M2 ) per ridurre la trasformazione nella forma P2 = Mx * P1 cioe' per evitare la M2 sopra cioe' per ottenere una trasformazione generica nel piano con una unica operazione di prodotto di matrice si passa alle coordinate omogenee: invece di rappresentare un punto P con (x,y) si rappresenta un punto del piano con una terna (xh, yh, h) dove h e' un fattore moltiplicativo non nullo, si ottiene la coppia di coordinate x,y dividendo per h: (xh/h, yh/h, 1) i punti (xh,yh,h) sono tutti i punti della retta verticale con z=h, retta che interseca il nostro piano (x,y) in h=1;

in coordinate omogenee: un punto del piano (x,y) e' rappresentato da una terna (xh, yh, h) dove h e' un fattore moltiplicativo non nullo, si ri-ottiene la coppia di coordinate x,y dividendo per h: (xh/h, yh/h, 1) -->> con questa notazione si puo' esprimere anche la traslazione con un prodotto di matrici: traslazione: P' = MT * P con P' = , MT = e P= punto nuovo = matrice per punto vecchio, in notazione con coordinate omogenee anche la traslazione e' un prodotto di matrice per vettore. ricorda che era x1=x+tx; y1=y+ty; con notazione vettoriale: P = (x,y), P' = (x',y'), T =(tx,ty), da cui : P' = P + T in notazione vettoriale traslazione = somma di due vettori, x' 1 0 tx x y' 0 1 ty y 1 0 0 1 1

in coordinate omogenee: (xh, yh, h) traslazione: P' = MT * P con P' = , MT = e P = rotazione: P' = MR * P dove x' cos a -sin a 0 x P' = y' MR = sin a cos a 0 P = y 1 0 0 1 1 scalatura: x1=x*sx; y1=y*sy; ovvero P' = S * P che in coordinate omogenee diventa: x' sx 0 0 x P' = y' MS = 0 sy 0 P = y 1 0 0 1 1 x' 1 0 tx x y' 0 1 ty y 1 0 0 1 1

trasformazioni inverse: spesso si ha necessita' di eseguire la trasformazione inversa, ovvero di dover ritornare al sistema di coordinate precedente; tutte le trasformazioni viste hanno l'inversa: trasf.diretta trasf.inversa 1 0 tx 1 0 -tx traslazione 0 1 ty 0 1 -ty 0 0 1 0 0 1 cos(a) -sin(a) 0 cos(a) sin(a) 0 rotazione sin(a) cos(a) 0 -sin(a) cos(a) 0 0 0 1 0 0 1 sx 0 0 1/sx 0 0 scalatura 0 sy 0 0 1/sy 0 0 0 1 0 0 1

trasformazioni composte: posso applicare in catena piu' trasformazioni, ad es due traslazioni M" e M' P" = M" * P' = M" * ( M' * P ) = (M" * M') * P traslazioni: vale la proprieta' associativa (anche commutativa) e la matrice di trasformazione e' la somma delle due matrici; per le rotazioni: M" = M(b) (angolo b), M'=M(a) (angolo a) P" = M(b) * P' = M(b) * ( M(a) * P ) = (M(b) * M(a)) * P la matrice risultante e' M(b+a) come intuitivo (somma delle due rotazioni attorno l'origine): anche per le rotazioni valgono le proprieta' associativa e commutativa; per scalatura: M"(sx",sy"), M'(sx',sy') si puo' verificare che la matrice risultante M = M" * M' = M(sx'*sx", sy'*sy") e' data dai fattori di scala che sono il prodotto dei singoli fattori ricordiamo che un fattore zero non e' invertibile ;-) anche per la scalatura valgono le proprieta' associativa e commutativa

trasformazioni composte: posso applicare in catena piu' trasformazioni: per trasformazioni dello stesso tipo valgono le proprieta' associativa P2 = M1 * M2 * M3 * P1 = ( M1 * (M2 * M3) ) * P1 = (((M1 * M2) * M3 ) * P1 e anche commutativa: = M2 * M1 * M3 * P1 = M3 * M1 * M2 * P1 ecc ma attenzione: in generale per trasformazioni diverse (rotazioni e/o traslazioni e/o scalature ) NON vale la proprieta' commutativa, l'ordine con cui si applicano le trasformazioni e' importante

nota: nel caso della vusualizzazione di scene complesse ogni pezzo (ogni punto, poligono ecc) e' soggetto in generale a una catena di trasformazioni (anche diverse decine) che si traducono sempre in una unica matrice di trasformazione ! ==>> questo e' importante per la velocita' con cui sono trasformati i sigoli punti (o i singoli triangoli) per passare dalle coordinate del modello attraverso le coordinate mondo ecc fino alle coordinate schermo

trasformazioni composte: rotazione attorno un punto pivot generico (diverso da 0,0) la matrice di trasformazione si ottiene applicando tre trasformazioni: trasla per portare il pivot nell'origine ruota attorno origine trasla indietro per riportare il pivot al suo posto: prodotto delle tre matrici T(xp,yp), R(a), T(-xp,-yp) 1 0 xp cos(a) -sin(a) 0 1 0 -xp 0 1 yp sin(a) cos(a) 0 0 1 -yp 0 0 1 0 0 1 0 0 1 ottengo: M = T(xp,yp) * R(a) * T(-xp,-yp) cos(a) -sin(a) xp(1-cos(a)) + yp sin(a) sin(a) cos(a) yp(1-cos(a)) - xp sin(a) 0 0 1

trasformazioni composte: scala attorno un punto pivot generico SG (scala generica) diverso dall'origine 0,0 : il procedimento e' lo stesso: trasla + scala + traslaindietro: quindi prodotto delle tre matrici: 1 0 xp sx 0 0 1 0 -xp 0 1 yp 0 sy 0 0 1 -yp 0 0 1 0 0 1 0 0 1 = sx 0 xp(1-sx) 0 sy yp(1-sy) 0 0 1 T(xp,yp)*S(sx,sy)*T(-xp,-yp) = SG(xp,yp,sx,sy)

ricorda: il prodotto di matrici e' associativo, ovvero: M4 = M3 * M2 * M1 = (M3 * M2) * M1 = M3 * (M2 * M1) quindi posso ottenere la M4 sia moltiplicando da sinistra a destra (pre-moltiplica) sia da destra a sinistra (post-molt); il OpenGL richiede che le trasformazioni siano attivate nell'ordine in cui devono essere applicate; nel caso sopra, prima la M1, poi la M2, poi la M3 ancora: se devo traslare un oggetto e poi ruotarlo, allora applico prima la glTranslatef(xx,yy,zz) e poi la glRotatef(a,b,g,1)

trasformazioni composte: l'OpenGL prevede delle procedure per posizionare le matrici di trasformazione specificando non tutta la matrice ma solo i parametri essenziali (libreria gl.h) : glTranslatef(dX,dY, dZ); // trasla floating glRotatef(rEta,x,y,z); // ruota float glScalef(sx, sy, sz); // fattore di scala float sono le proc generali in 3D, per il caso 2D basta mettere a zero dZ,z, e a uno sz ancora ricordiamo che il fattore di scala zero NON e' reversibile !!

Introduzione alla Grafica Digitale - riassumendo: trasformazioni geometriche nel piano: traslazione (translation): x1=x+tx; y1=y+ty; rotazione (rotation) x1=x*cos(a)-y*sin(a); y1=x*sin(a)+y*cos(a); scalatura (scaling) x1=x*sx; y1=y*sy; vedremo piu' avanti alcuni cenni su : eliminazione parti fuori scena (clipping) riempimento parti a colore pieno (filling) 53