3 D. grafica in tre dimensioni : visualizzazione su schermo (2D) di un "mondo" ovvero una...

3 D

grafica in tre dimensioni :

visualizzazione su schermo (2D)

di un "mondo" ovvero una "scena" di

un insieme di oggetti a 3 dimensioni

in questa parte sono presentati cenni su :

orientamento del sistema degli assi in 3 D

trasformazioni geometriche in 3 D

passaggio da 3 D a 2 D : le proiezioni

cenni di storia della prospettiva

cenno sulla struttura dell' OpenGL (gl,glu,glut),

tipi di prospettive (parallele, prospettiche)

3 D - geometria, prospettive, OpenGL 3D

mondo oggetto,coordinate xw,yw,zw(world coord)

mondo del centro vista,coordinate xv,yv,zv(viewing pnt)

il passaggio dal piano 2D (visto finora) al 3D presenta subito un'ambiguita' che comporta una scelta di orientamento:in 2D, l'orientamento degli assi ( coordinate x,y) e' sempre (*) * asse delle ascisse x orientato a destra, e * asse delle ordinate y orientato verso l'alto,nel caso dello spazio 3D sono usato due sistemi di riferimentoin entrambi gli assi x e y sono orientati come usuale (colleghiamo l'asse x con il pollice e l'asse y con l'indice),per l'asse z abbiamo: * sistema destrorso abbiamo l'asse z orientato verso fuori (mano destra: asse x=pollice, asse y= indice, asse z=medio) (verso l'osservatore) * sistema sinistrorso: l'asse z e' orientato verso dentro (mano sinistra : asse x=pollice, asse y=indice, asse z=medio) (via dall'osservatore)graficamente...(*) o quasi

x

z

y

x

z

y

sistema destrorso - regola della mano destra: x=pollice, y=indice, z=medio (esce dallo schermo) -

in grafica e' il piu' usato,l' OGL usa questo

sistema sinistrorso - regola della mano sinistra:

x=pollice, y=indice, z=medio (entra nello schermo)

meno usato

ricorda le trasformazioni geometriche in 2D: coordinate (x,y),

trasformazioni:

scalatura: fattore di scala: Sx, Sy rotazione: angolo: Θ traslazione: posizione: x, y

inclinazione o scorrimento dei piani (shear),

e altro,riflessione ecc

trasformazioni geometriche

trasformazioni geometriche in 2D: coordinate (x,y), il OpenGL usa coordinate omogenee (x,y,h)trasformazioni: scalatura: fattore di scala: 2 parametri Sx, Sy rotazione: angolo: 1 parametro Θ traslazione: posizione: 2 parametri x, y

la rotazione si intende sempre attorno l'asse z perpendicolare al piano x,y

L'OpenGL prevede apposite funzioni per posizionare le matrici di trasformazione - dati i parametri essenziali riportati sopra

trasformazioni geometriche

// ricordiamo la trafila per trasformazione in 2D // per disegnare una parte in posizione voluta: glMatrixMode(GL_MODELVIEW); // seleziona quale matriceglPushMatrix(); glLoadIdentity(); // azzera; segue:

glTranslatef(xt, yt, 0.0); //rotaz attorno punto(x,y): 1)trasl 2)rotaz 3)traslIndiet glTranslatef(MyBariX, MyBariY, 0.0); glRotatef(MyAlfa, 0.0, 0.0, 1.0); glTranslatef(-MyBariX,-MyBariY,0.0); //scala attorno punto(x,y): 1)trasl 2)scala 3)traslIndiet glTranslatef(MyBariX,MyBariY,0.0); glScalef( MyScala, MyScala, 1.0); glTranslatef(-MyBariX,-MyBariY,0.0);

MyRect( 0.5, 0.5, 0.5 ); // disegna qualcosa

glPopMatrix(); //elimina trasformaz.da ultima push// fine trasforma e disegna una parte

trasformazioni in 2D: coordinate omogenee (x,y,h)

1 0 0 dx

0 1 0 dy

0 0 1 dz

0 0 0 1

sx 0 0 00 sy 0 00 0 sz 00 0 0 1

3 D - geometria:

anche in 3D per le trasformazioni geometriche conviene passare dalle coordinate cartesiane (x,y,z) alle coordinate omogenee (x,y,z,h), e le trasformazioni di traslazione (posizione) e scalasono espresse dalle matrici di trasformazione:

trasformazioni in 3D: coordinate omogenee (x,y,h)

la scala ha 3 parametri: Sx, Sy, Sz

glScalef( MyScala, MyScala, 1.0);

trasla o riposiziona ha 3 parametri: dx, dy, dz

glTranslatef (dx,dy,dz);

3 D - geometria:

anche in 3D per le trasformazioni geometriche conviene passare dalle coordinate cartesiane (x,y,z) alle coordinate omogenee (x,y,z,h),

la trasformazione di rotazione ha 4 parametri glRotatef(MyAlfa, dirx, diry, dirz);

( oppure si puo' definire con tre rotazioni attorno i tre assi x, y, z, di angoli ... Θ, Φ, Ψ )

ma .. richiede delle precisazioni ...

trasformazioni in 3D: coordinate omogenee (x,y,h)

per specificare una rotazione nello spazio dobbiamo specificare un asse di rotazione V, e in relazione all' asse di rotazione definiremo l' angolo di rotazione

OpenGL prevede la procedura di rotaz.generica :

glRotatef(ang,Vx,Vy,Vz); (*)

xz

y

trasformazioni in 3D: coordinate omogenee (x,y,h)

rotazione attorno asse z, sistema destro

(*) MA nota: Vx,Vy,Vz e' una direzione,il punto di riferimento dell' asse e' l' origine !!e una rotazione generica ??

OpenGL prevede la procedura di rotazione

glRotatef(ang,Vx,Vy,Vz); (*)

V - asse di rotazione,

ang = angolo di rotazione

Verso rotazione: una rotazione attorno un asse V si intende positiva se e' in verso antiorario quando si guardi l'origine dell'asse V da una posizione generica del semiasse positivo:

se mi metto su asse z (sist. destrorso, asse z in fuori) sul punto (0,0,1) del semiasse z positivo, allora una rotazione positiva ruotera' il piano x,y in verso antiorario

xz

y

trasformazioni in 3D: coordinate omogenee (x,y,h)

rotazione positi-va antioraria attorno asse z, sistema destro

accanto alle trasformazioni di posizione e scala , che abbiamo visto c'e' la trasformazione di rotazione attorno un asse ad es. attorno l'asse z glRotatef(a, 0,0,1);

che equivale alla matrice a sinistra:

cos(a) -sin(a) 0 0sin(a) cos(a) 0 00 0 1 00 0 0 1

accanto alle trasformazioni di posizione e scala , che abbiamo visto, c'e' la trasformazione di rotazione attorno un asse ad es. attorno l'asse z : glRotatef(a, 0,0,1); che equivale alla matrice:cos(a) -sin(a) 0 0sin(a) cos(a) 0 00 0 1 00 0 0 1 Una rotazione attorno asse x e':

1 0 0 00 cos(a) -sin(a) 00 sin(a) cos(a) 00 0 0 1

ed e' data per esempio dalla

glRotatef(a, 1,0,0);

0) rotazione generica di angolo a attorno ad un vettore v e un punto p (generici) , la trasformazione sara' composta come segue:1) traslazione del punto generico p nell'origine, affinche' l' asse di rotazpassi per l'origine;2) rotazione di v attorno asse y finche' l'asse di rotaz v giace in piano y,z, 3) rotaz1 attorno asse x finche' l'asse di rotaz v coincide con l'asse z; 4) rotaz2 attorno z (cheora coincide con v) dell' angolo voluto a,

x

y

z

a

v

p

x

y

z

v

p

x

y

z

a

v

p x

y

az=v

p=(0,0,0)

1) 2)

3) 4)

trasformazioni in 3D: rotazione generica:

e una rotazione generica di un oggetto (qui " ")

di un angolo a

attorno ad un vettore v

asse che passa per un punto p (generico)

?

nota: a,vx,vy,vz,px,py,pz7 parametri ...

x

y

z

a

v

p

1)

trasformazioni in 3D: rotazione generica:

rotazione generica attorno ad vettore v e punto p generici: la trasformazione sara' composta (come gia' visto per il 2D, ma qui i passi sono di piu' !!) come segue (ripeto i primi passi):

1) traslazione del punto generico p nell'origine, per fare in modo che l' asse di rotazione passi per l'origine;2) rotazione di v attorno all'asse y finche' l'asse di rotazione v non giace nel piano y,z, e poi 3) attorno all'asse x fino a far coincidere l'asse di rotazione v con l'asse z; ora siamo in una situazione nota:

4) infine si ruota attorno l'asse z dell' angolo voluto a,

e poi si rifanno i passi 1,2,3 a ritroso,5) rotazione inversa di 3): il vettore v torna nel piano yz6) rotazione inversa di 2): il vettore v torna com'era, ma in orig7) traslazione inversa di 1): il vettore v torna al punto p... e siamo a posto ;-) (7 trasformazioni!!)

proiezione 3D -> 2D

il passaggio

dal mondo 3D della scena composta da diversi oggetti

al mondo 2D dello schermo dove si visualizza la scena

implica vari sistemi di riferimento di coordinate

nel caso 2D abbiamo tre sistemi di coordinate nel mondo degli oggetti -

1) coordinate oggetto per il riferimento dei singoli elementi costitutivi dell' oggetto [ad es una mano rispetto il corpo]

2) coordinate riferimento dell' oggetto nel mondo della scena(trasformazione da coordinate della parte (dell'oggetto) alle coordinate della scena (mondo "utente") [ad es il corpo rispetto il centro stanza]

3) coordinate del dispositivo di visualizzazione (trasformazione window -> viewport->schermo )

trasformazioni in 2D: tre sistemi di riferimento

nel caso 3D per il passaggio dal mondo oggetti al mondo del dispositivo di visualizzazione dobbiamo considerare piu' passaggi:

coordinate mondo oggetti

coordinate punto di vista

** proiezione (da 3D a 2D) coordinate piano di proiezione 2D

passaggio finestra utente -> viewport

coordinate dispositivo di visualizzazione

trasformazioni in 3D: sei sistemi di riferimento

la proiezione di un oggetto 3D su un piano di proiezione 2D e' definita da un insieme di rette di proiezione ("proiettori") che hanno tutte un' origine comune nel punto "centro di proiezione" e congiungono il centro di proiezione con tutti i punti dell' oggetto; il centro di proiezione = punto di vista, dove immagino l'occhio dell'osservatore); e da un piano di proiezione

raggi proiettori

centro di proiezione

piano di proiezione

oggettoda rap-presen-tare

la proiezione di un oggetto 3D su un piano di proiezione 2D e' data dall' intersezione dei proiettori con il piano di proiezione; i proiettori = un insieme di rette di proiezione che hanno tutte un' origine comune nel punto "centro di proiezione"(punto di vista, dove possiamo immaginare l'occhio dell'osservatore) e passano per tutti i punti dell' oggetto;

Si noti che in generale una proiezione puo' essere definita da "proiettori curve" (non rette) che passano tutte per il centro di proiezione e intersecano una superficie di proiezione (non piana) [altre applicazioni, in particolare, cartografia]

proiettori

centro di proiezione

piano di proiezione

oggettoda rap-presen-tare

3 D - geometria, prospettive, OpenGL 3D

Pv

Pw

P0

oggetto piano di proiezione punto di vista

un'osservazione banale:

ben noto (oggi): oggetti a distanza diversa dal punto di vista appaiono di grandezza diversa sul piano di proiezione, e questo e' uno degli effetti visivi di lontananza (spesso usato)

prima della prospettiva ?

prima della prospettiva il disegnatore non si poneva il problema della rappresentazione realistica di una scena:

la scena "raccontava" una storia, con finalita' e tecniche molto diverse di oggi ...

la prospettiva appare solo 550 anni fa ...

vediamo in circa 10 slide l' evoluzione del disegno PRIMA della prospettiva

dalle figure rupestri di 20000 anni fa (paleolitico)

agli affreschi Egiziani (4000 anni fa)

alle immagini murali e dei vasi greci (2500 anni fa) (le immagini migliori su legno sono tutte andate perse), agli affreschi delle tombe greche (il tuffatore),

alle iconografie bizantine (Ravenna) e romaniche (1200 anni fa)e gotiche (800 anni fa)

fino a Giotto compreso (700 anni fa) ...

Pitture rupestri grotte di Lascaux (Pirenei, Francia) e dintorni

Pitture risalenti al paleolitico 30.000 - 15.000 anni fa;

dopo piu' di 10.000 anni

(quante generazioni a 10-15 anni per generazione?)

Nefertari Merytmut circa 1290-1255 BC,

prima moglie di Ramses nell' atto di

preghiera (circa il periodo in cui i

fenici svilupparono l'alfabeto, ripreso vari secoli dopo dai greci)

Immagine dal " Libro delle preghiere dei morti " della tomba di Hunefer, circa 2000 b.c.

dopo circa 1500 anni

(quante generazioni a 10-15 anni per generazione?)

alcune immagini greche di circa 500 anni prima di Cristo:

tavoletta votiva con scena di sacificio alla grazia/nimfa Carithes, 530 b.c., pittura su legno, trovata in una grotta a Pitsa, Corinto

due scene murali dalla tomba di Paestum (vicino Eboli), cultura greca, 480 b.c. sopra: "symposium" o convivio,sotto: "il tuffatore"

Mosaico Bizantino 900 d.c. chiesa di Hagia Sophia Costantinopoli

circa 1400 anni dopo ...

sopra: discussione tra i dotti Rabanus, Alcuinus (Ealhwine) e Otgar, corte di Carlomagno, circa 820 d.c.

a destra: illustrazione da libro di epoca Carolingia circa 820 d.c.

Giotto di Bondone (circa 1300)La strage degli innocenti,Capella degli Scrovegni, Padova

Mappa della citta' di Costantinopoli, 1422, disegno di cartografo fiorentino(32 anni prima della conquista da parte dei Turchi)

nell'ambiente ricco dell' inizio rinascimento (anche se la richezza era limitata a pochi) dell' Italia, Olanda, Germania di fine medio evo

nascono esigenze nuove, e nascono risposte nuove...

la visualizzazione prospettica risale al rinascimento, il pittore tedesco Duerer l'ha imparato nei suoi viaggi in Italia (Venezia)

Duerer, 1525 : lezione di prospettiva: disegno di un liuto !

Donato Bramante, attorno al 1500, a Roma

nota il palazzo a destra, disegnato in prospettiva a un punto di fuga situato circa in mezzo alla scena

Pf

Donato Bramante : Donato di Angelo di Pascuccio, detto il Bramante (Monte Adrualdo 1444 - Roma 1514) famoso pittore e architetto italiano.Nato a Monte Adrualdo (Urbino), si formò artisticamente nella sua città natale ma iniziò ben presto a viaggiare e a lavorare a Mantova, Milano e Roma.Fu influenzato (prospettiva, classicità) da Leon Battista Alberti, Andrea Mantegna e Melozzo da Forlì. L'influsso di quest'ultimo si manifesta in particolare nelle opere milanesi. Lo studio di Vitruvio, degli antichi edifici classici e le discussioni con Leonardo, lo indirizzarono verso l'impiego di forme architet-toniche possenti e classiche - esempio la sua Prospettiva di città ideale, un manifesto della nuova architettura milanese rinascimentale. Bramante è riuscito a ricreare un edificio che abbia tutte le caratteristiche classiche.Di Donato Bramante era anche affermato pittore “illusionista”, ossia creatore di prospettive e d’architetture fittizie, segue es.:

abside della chiesa diSanta Maria presso San Satiro a Milano,illusione pittorica di un grande spaziodietro l'altare - che non c'e' in realta' : dietro l'altare vi sono 90 cm di spazio...

vedi slide seguente

L'abside della chiesa San Satiro

ma ritorniamo ora alla prospettiva

per quanto ci riguarda nella visualizzazione di scene 3Dcon il sistema OpenGL

rivediamo alcune cose ...

l' OpenGL consente la definizione di vari tipi di prospettivecon alcune procedure di libreria;

ricordiamo che l' OpenGL e' un sistema formato da piu'livelli di librerie:

+ insieme base libreria GL di procedure con prefisso gl

+ la libreria GLU (OpenGL Utility Lib)

+ le librerie di interfaccia per diversi sistemi operativi, ciascuna con procedure di gestione di finestre, menu, eventi ecc come previsto nei diversi S.O.,

+ la libreria GLUT (OpenGL Utility Toolkit)

l'OpenGL

insieme base con prefisso gl = un insieme di primitive base per la visualizzazione di oggetti 3D su uno schermo 2D es... glBegin(); glBlend();.. sono tutte procedure,funzioni,tipi,cost., con prefisso gl [c'e gia' nel Borland Builder 4 !! ]

poi c'e' l'insieme con prefisso glu:

* libreria GLU (OpenGL Utility Lib) = procedure di specifica di proiezioni, resa di poligoni e superfici nello spazio, e altro; tutte le procedure hanno un nome che inizia con glu (prefisso) (es: gluLookAt(...) gluPerspective(..), ecc )

inoltre ...

alcune proc di OpenGL base, prefisso gl:

glBegin(..), glEnd(), glBitmap(..), glBlend(..), glCallList(..), glClear(..), glClip(..), glColor*(..), glCopy(..), ... glRect*(..), glTex(..), .. glTranslate*(..), glVertex*(..), glViewport(..), ..glWindowPos*(..), dove * sta per 2f,3f,4f,2i,.. in particolare, tutte le glSet.. e glGet.. per gestire le variabili di stato dell'OpenGL, (circa 200 procedure)

* proc di GLU(OpenGL UtilityLib) prefisso glu:

gluBeginCurve(..), .. gluLookAt(...), gluNewQuadric(..), gluNurbs(..), gluPerspective(..), ..gluSphere(..), gluTessNormal(..), gluUnProject(..).. (circa 50 procedure),

l'OpenGL:

1) procedure di base con prefisso gl;

2) libreria GLU (OpenGL Utility Lib), procedure prefisso glu

3) alle parti 1 e 2 manca l'interfaccia grafica tra S.O. e utente: ma queste sono MOLTO diverse nei vari sistemi, e quindi esistono (esistevano) delle librerie per l'uso dell' interfaccia grafica dei sistemi operativi piu' diffusi: prefisso glX per X-Window, prefisso wgl per MS Windows pref. agl per l'Apple OS9, non riportiamo nulla ...

per il nostro corso ci limiteremo ad una particolare interfaccia ...

OpenGL:

1) libreria gl: procedure di base con prefisso gl; 2) libr. GLU (OpenGL Utility Lib), procedure prefisso glu 3) librer. per l'uso dell' interfaccia grafica di DIVERSI sist. operativi: prefissi glX per Unix X, wgl per MS Windows, agl per l'Apple OS9, infine:

4) GLUT: nel Mark Kilgard scrisse una libreria SEMPLIFICATA di interfaccia SO-utente (per il Unix X-Window system) che ebbe subito successo e fu portata su altri sistemi, come MSWindows dove continua a funzionare (+ o - ;-)

GLUT = OpenGL Utility Toolkit: le procedure di questa libreria hanno il prefisso glut, ad es: glutMainLoop();

* libreria GLUT(OpenGL Utility Toolkit) con prefisso glut : glutCreateWindow(..), glutDisplayFunc(..), glutIdleFunc(..), .. glutMainLoop(..), glutSolidCone(..), .. glutWireTorus(..),.. (circa 30 procedure)

nella prospettiva interessano la posizione e l'orientamento del piano di proiezione rispetto il centro di proiezione e rispetto gli oggetti che vogliamo rappresentare :

proiettori

centro di proiezione

piano di proiezione

asse z spazio oggetti normale al piano di proiezione

N

orientamento del piano di vista e del vettore normale N

posizioni del piano di proiezione sull'asse z

posizioni del piano di proiezione sull'asse z

z

xy

nota orientam. asse z;qui l'oggetto sta dalla parte delle z negative

distz distz

posizioni del piano di proiezione rispetto l'asse oggetto-centro proiezione

3 D - prospettiva parallela

z

xy

distz distz

prospettiva parallela: la posizione del piano di proiezione rispetto l'asse oggetto-centro proiezione non e' rilevante (il punto di vista sta all'infinito)

definiz del vettore normale al piano di vista

il punto Pref viene sceltodi solito comeorigine del mondo deglioggetti

fig. da D.Hearne M.P.Baker"Comp.Graphwith OpenGLPearson Prentice Hall3.rd ed.,2004

posizioni di riferimento per l' OpenGL 3D

Nel caso dell' OpenGLil punto di vista default sta all'origine, l'oggetto sta nell'origine(reference point - in qualchecaso sta in (0,0,-1),il piano di vista sta nell'origine - il tutto va benissimoper le prospettive paralelle

OpenGL 3D: posizione oggetto / centro prosp.

per la visualizzazione (specie se prospettica) di un oggetto 3D conviene separare il centro di vista (il punto dove sta la camera o l'occhio) dall'oggetto - o spostando la camera (sinistra) o spostando l'oggetto (destra) che ha ora le z negative

camera

oggetto

proiezioni geometriche piane (*)

proiezioni geometriche piane

(*) Fondam. di grafica tridimensionale interattiva di R.Scateni,P.Cignoni, C.Montani,R.Scopigno, McGrawHill It, 2005;

proiezioni geometriche piane (*)

parallele (vediamo prima queste) - e sono: ortografiche piante e alzati, assonometriche isometriche, dimetriche, trimetriche oblique cavaliera cabinet altre

prospettiche: e sono: a 1 punto di fuga, a 2 punti di fuga, a 3 punti di fuga

proiezione ortogonale o parallela: il punto di vista sta all'infinito, i raggi di proiezione sono paralleli.

non c' e' " distanza " tra : - piano proiezione, - punto vista, - oggetto: quindi l'asse z e le distanze z sono " irrilevanti "

proiezione parallela:

il punto di vista sta all'infinito, i raggi di proiezione sono paralleli, non c' e' "distanza" tra piano proiezione, punto vista, oggetto: l'asse z e' "irrilevante".se la direzione di proiezione e la normale al piano di proiezione coincidono allora abbiamo le proiezioni parallele ortografiche -

le piu'comuni nel disegno tecnico: il piano di proiezione e' perpendicolare ad uno degli assi cartesiani, l' asse e' la direzione di proiezione; abbiamo:vista frontale, vista laterale e pianta (vista dall'alto)

3 D- prospettiva ortografica (o ortogonale)

frontale

laterale

pianta

proiezioni parallele ortografiche

punto di vista all'infinito, raggi di proiezione paralleli agli assi: vista frontale, laterale e dall'alto (pianta).Si usano perche' dal disegno si possono rilevare le distanze e le dimensioni dell'oggetto;ma la resa 3D e' modesta, le tre prospettive non danno l'idea immediata di come e' fatto l'oggetto in 3D (infatti, in figura..)

se nella proiezione parallela ortografica la direzione di proiezione NON coincide con alcuno degli assi cartesiani abbiamo le proiezioni assonometriche:

Le prospettive assonometriche (isometrica dove la direzione di proiezione forma angoli uguali con i tre assi di proiezione, dimetrica se due angoli tra direzione di proiezione e assi vartesiani sono uguali, in generale e' trimetrica) si ottengono dalle ortografiche con direzione parallela all'asse z ruotando l'oggetto opportunamente.

PROIEZIONI OBLIQUE:la direzione di proiezione forma un angolo obliquo con il piano di proiezione; l'oggetto rappresentato conserva l'informazione della natura 3D (a differenza della proiez.ortografica fronte/fianco/pianta), ma appare deformato

in figura, prospettiva parallela obliqua (non ortografica) Cavaliera,gli spigoli laterali (*) hanno la stessa lunghezza dei frontali (o), angolo 30o

d

d

d

(*)

(o)

3 D - geometria, prospettive, OpenGL 3D

in generale una prospettiva parallela (ortho) puo' essere obliqua, come qui in figura, o come nella figura seguente ..

3 D - geometria, prospettive, OpenGL 3D

PROIEZIONI OBLIQUE:la direzione di proiezione forma un angolo obliquo con il piano di proiezione; l'oggetto rappresentato conserva l'informazione della natura 3D (a differenza della proiez.ortografica fronte/fianco/pianta), ma appare deformatoun rimedio e' l'accorciamento dei segmenti laterali (paralleli all'asse z che e' rivolto verso l'osservatore), nella proiezione cabinet la lunghezza delle linee laterali si riduce a meta':

d

d

d/2

l'OpenGL non prevede le prospettive obliqui come "predefinite", anche se e' possibile definire la matrice di trasformazione anche per tale prospettiva

3 D - prospettiva orto in OpenGL:glOrtho(xwinmin,xwinmax,ywinmin,ywinmax,distnear,distfar)

3 D - geometria, prospettive, OpenGL 3D

glOrtho (xwinmin,xwinmax, ywinmin,ywinmax, distnear,distfar)

nota: asse z verso chi guarda, assi x e y nel piano di vista (z=near)

nota: la procedura ortho e la procedura ortho2D sono "quasi" le stesse, nel senso che l'asse z e' quasi irrilevante; cambia il volume di visualizzazione, che nel caso della ortho ha una dimensione sull'asse z da specificare, gli oggetti fuori tale spazio saranno eliminati (clipping)

ortho2D assume znear 1 e zfar -1,

per cui tutti gli oggetti in 2D con z=0 sono dentro il volume di visualizzazione.

3 D - geometria, prospettive, OpenGL 3D

glOrtho (xwinmin,xwinmax, ywinmin,ywinmax, distnear,distfar);

attenzione: l'asse z e' orientato verso chi guarda, siamo su punto con z zero e stiamo guardando verso l'asse z negativo;gli oggetti sono di solito messi lungo l'asse z negativo;gli ultimi due parametri specificano due distanze (positive!) per i piani di clipping vicino e lontano

da cui ho la posizione per gli oggetti; ad es. con znear=10 e zfar=50 (distanza da chi guarda min e max) allora l'oggetto (che sta lungo l'asse z negativo), deve essere nella posizione tra -10 e -50.se non specifico nulla, si assume il volume unitario, come nella figura seguente:

glOrtho(xwinmin,xwinmax,ywinmin,ywinmax, distnear,distfar)

prospettiva parallela in OpenGL:glMatrixMode( GL_PROJECTION); glLoadIdentity();segue la specifica del tipo di proiezione e dei limiti dello spazio degli oggetti visualizzati, con piano di proiezione z==0, e con gli oggetti nell' origine:glOrtho(-2.0,2.0, -2.0,2.0, -2.0,2.0);// xmin,xmx, ymin,ymx, znear,zfarpoi, in Display:

glMatrixMode(GL_MODELVIEW);glLoadIdentity(); glPushMatrix(); glTranslatef(dx,dy,dz);glRotatef(ang,1.0,1.0,1.0); /*rotate ang degrees (/360) around vector 1,1,1*/ glScalef( 1.0, 1.0, 1.0); DrawCube();

nota:i lati si mantengonoparalleli!

(prog. EGD3D_01ORTHO)

provare l'uso e leggere con cura il programma OGL3D_1ORTHO

in figura, visualizzazione con proiezione parallela (orthographic) con oggetto (cubo) ruotato in due modi diversi

Qu

ickTim

e™

an

d a

TIF

F (

Uncom

pre

ssed)

de

com

pre

ssor

are

need

ed

to s

ee t

his

pic

ture

.

Qu

ickTim

e™

and

aTIF

F (

Un

com

pre

ssed

) d

ecom

pre

sso

rare

nee

de

d t

o s

ee t

his

pic

ture

.

ancora un' immagine in prospettiva ortografica, programma EGD3D_1ORTHO, con angoli di rotazione ax=-10, ay=-10, az=0

QuickTime™ and aTIFF (Uncompressed) decompressor

are needed to see this picture.

segue ora una breve presentazione del

programma

EGD3D_01ORTHO

dal programma EGD3D_01ORTHOvoid DrawCube(){ /* asse x a destra, asse y in alto, asse z in fuori verso l'osservatore 4------3 asse x a destra, / | . / | asse y in alto, 6------7 .| asse z in fuori, | 1---|--2 verso l'osservatore | / . | / piano con z=0.5 e' 5------8 1-5-8-2 */

//per disegnare le linee verdi da z<0 a z>0 1-5, 2-8, 4-6, 3-7glLineWidth(3.0); glColor3f(0.0,1.0,0.0); glBegin(GL_LINES); glVertex3f(-0.5,-0.5,-0.5 ); glVertex3f(-0.5,-0.5,+0.5 );//1-5 glVertex3f(+0.5,-0.5,-0.5 ); glVertex3f(+0.5,-0.5,+0.5 );//2-8 glVertex3f(-0.5,+0.5,-0.5 ); glVertex3f(-0.5,+0.5,+0.5 );//4-6 glVertex3f(+0.5,+0.5,-0.5 ); glVertex3f(+0.5,+0.5,+0.5 );//3-7glEnd(); ...

dal programma EGD3D_01ORTHOvoid DrawCube(){ /* asse x a destra, asse y in alto, asse z in fuori verso l'osservatore 4------3 asse x a destra, / | . / | asse y in alto, 6------7 .| asse z in fuori, | 1---|--2 verso l'osservatore | / . | / piano con z=0.5 e' 5------8 1-5-8-2*/

//disegna le linee blu della faccia dietro (z<0) punti 1,2,3,4

glColor3f(0.0, 0.0, 1.0); /* linee blu */ glBegin(GL_LINE_LOOP); /* 1-2-3-4 blu back face */ glVertex3f(-0.5, -0.5, -0.5 ); glVertex3f(+0.5, -0.5, -0.5 ); glVertex3f(+0.5, +0.5, -0.5 ); glVertex3f(-0.5, +0.5, -0.5 ); glEnd();

dal programma EGD3D_01ORTHOvoid DrawCube(){ /* asse x a destra, asse y in alto, asse z in fuori verso l'osservatore 4------3 asse x a destra, / | . / | asse y in alto, 6------7 .| asse z in fuori, | 1---|--2 verso l'osservatore | / . | / piano con z=0.5 e' 5------8 1-5-8-2*/

//disegna linee gialle faccia davanti (z>0) punti 5,6,7,8

glColor3f(1.0, 1.0, 0.0); /* giallo z=0.5, */ glBegin(GL_LINE_LOOP); /* 5-6-7-8 yellow front face */ glVertex3f(-0.5, -0.5, +0.5 ); glVertex3f(-0.5, +0.5, +0.5 ); glVertex3f(+0.5, +0.5, +0.5 ); glVertex3f(+0.5, -0.5, +0.5 ); glEnd();

dal programma EGD3D_01ORTHOvoid DrawCube(){ /* asse x a destra, asse y in alto, asse z in fuori verso l'osservatore 4------3 asse x a destra, / | . / | asse y in alto, 6------7 .| asse z in fuori, | 1---|--2 verso l'osservatore | / . | / piano con z=0.5 e' 5------8 1-5-8-2*/

// lo stesso disegno si ottiene con la procedura di libreria: glLineWidth(5.0); glColor3f(1.0,1.0,1.0); /* bianco */ glutWireCube(1.0); /* lato lungo 1, centro in origine */

// a faccie piene (rettangoli), proc di libr: glutSolidCube(1.0); // o, stesso disegno con GL_POLY:/* 4-------3 not wire -. / | / | disegna 4 poligoni . 6------7 .| attenzione all'ordine e . | 1--- |-- 2 al verso di orientamento . | / | / dei poligoni. 5-------8 */ glEnable(GL_BLEND); glBlendFunc( .., ...); // usa alfaglColor4f(0.4,0.4,0.4, alf); /* grigio */ glBegin(GL_POLYGON); /* 1-2-5-8 bottom y=-0.5 */ glVertex3f(-0.5, -0.5, -0.5 ); glVertex3f(+0.5, -0.5, -0.5 ); glVertex3f(+0.5, -0.5, +0.5 ); glVertex3f(-0.5, -0.5, +0.5 ); glEnd(); glBegin(GL_POLYGON); /* 6-7-3-4 top y= +0.5 */ glVertex3f(-0.5, +0.5, +0.5 ); glVertex3f(+0.5, +0.5, +0.5 ); glVertex3f(+0.5, +0.5, -0.5 ); glVertex3f(-0.5, +0.5, -0.5 ); glEnd(); ... ecc per le altre facce

void myPerspectiveSet(){ glMatrixMode( GL_PROJECTION); glLoadIdentity(); /* 4x4 projection matrix for openGL hw */ glOrtho( xmin, xmax, ymin, ymax, znear, zfar ); /* usa prospettiva parallela */} /* myPerspectiveSet */

void myGLInit ( ) { myWiWi=glutGet(GLUT_WINDOW_WIDTH); myWiHe=glutGet.. glViewport(0,0,myWiWi, myWiHe); myPerspectiveSet(); glMatrixMode( GL_MODELVIEW); glLoadIdentity(); } /* myInitGL */

void myReshape ( int w, int h ) { myWiWi=w; myWiHe= h; glViewport( 0, 0, w, h ); PerspectiveSet(); glMatrixMode( GL_MODELVIEW); glLoadIdentity(); glutPostRedisplay();} /* myReshape */

inizializzazioni per uso della prospettiva

// la procedura che disegna ha la struttura:

void myDisplay() { // start display glClearColor( 0.1, 0.1, 0.3, 1.0f ); glClear( GL_COLOR_BUFFER_BIT );

myPerspectiveSet(); /* esegue glOrtho( xmin, xmax, ... zfar);*/ glMatrixMode(GL_MODELVIEW); glLoadIdentity(); /* unita' */ glPushMatrix(); /* fai una copia, cambia la copia della matr. */ /* - non accumulare la trasformaz.che segue */ glTranslatef( tx, ty, tz ); /* inizia con tx=ty=tz=0.0 */ glRotatef( angx, 1.0, 0.0, 0.0); /* ruota di angx attorno asse x */ glRotatef( angy, 0.0, 1.0, 0.0); /* attorno asse y */ glRotatef( angz, 0.0, 0.0, 1.0 ); /* attorno asse z */ glScalef( 1.5, 1.5, 1.5 ); /* ingrandisci il cubo, e' -0.5..+0.5 */ myDrawCube(); /* fa il disegno del cubo */ glPopMatrix(); /* elimina tutte le trasformazioni fatte dal push */ glFlush(); /* fai passare da scheda grafica su schermo */ } /* myDisplay */

/* e il programma ha la struttura come segue */

int main (int argc, char * argv[]) { SpiegaFig(); SpiegaTasti(); myOpenWin( argc, argv ); myDataInit(); myInit( ); glutDisplayFunc( myDisplay); glutReshapeFunc( myReshape ); glutKeyboardFunc( myKeyboard ); glutSpecialFunc( myArrow_keys ); glutMainLoop( ); return 0; /* ma non si ritorna qui */ } /* main */void myOpenWin(int argc, char * argv[]){ glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE ); glutInitWindowPosition(WinX0, WinY0); glutInitWindowSize( WinSizex, WinSizey ); glutCreateWindow( "<OGL3D_01ORTHO>");} /* OpenWinPlease */