Elementi di Grafica Digitale standard grafici primitive grafiche.

Elementi di Grafica Digitale

standard graficiprimitive grafiche

grafica raster, parte software:

librerie standardizzate: GKS (Graphical Kernel System) (primo standard ISO e ANSI) GKS 3D PHIGS (Programmer's Hierarchical Interactive Graphics Standard Open GL (Open Silicon Graphics Graphical Library) Open GL 2 (vedi rete, http://www.sgi.com/products/software/opengl/ ... DirectX (proprietario MS)

(ad es. http://www.deakin.edu.au/~agoodman/scc308/index.html ,corso di COMPUTER GRAPHICS ... )

http://www.deakin.edu.au/~agoodman/scc308/index.html

Core : The Core Graphics System.

Created in the late 1970s by the ACM SIGGRAPH Graphics Standards Planning Committee.

Designed to provide a standard set of library routines, based on (then) current device-independent graphics practice (largely vector terminals attached to mainframes, with off-line processing),

it was overtaken (replaced) by the more comprehensive GKS and (later) PHIGS, as well as by developments in raster display systems, and the development of real-time processing on graphics workstations.

Its significance includes the fact that many of its principles were later adopted by both GKS and PHIGS.

http://www.deakin.edu.au/~agoodman/scc308/topic3.html


GKS: The Graphical Kernel System.

Originally devised by a combined British and German group, GKS became the first graphics system to be fully standardised by ANSI and ISO in 1984.

Originally a two-dimensional system, it has been extended to three dimensions;

directly, as GKS3D, and indirectly, through PHIGS.

Still vector-based, although with much greater emphasis on interactivity.

It introduced the idea of a 'virtual workstation' as a way of encouraging and enforcing device-independence.

PHIGS

The Programmers Hierarchical Interactive Graphics System.

Fundamentally a development from both CORE and GKS, with powerful 3D functionality, reflecting the development in the late 1980s of powerful workstations capable of real time display of complex 3D objects.

It also supports direct data structure creation and manipulation.

Greater direct support for raster operations was added with PHIGS+ in 1986.



negli anni 80 furono studiate diverse alternative per il problema della scrittura di software adatto alla progettazione e realizzazione di disegni / immagini di vario tipo (dal disegno tecnico per meccanici al disegno a mano libera per artisti):

soluzione gia' presente e che alla fine ha prevalso: librerie grafiche da usare come libreria accessibile da un linguaggio di programmazione standard (ad es. dal Fortran)

la soluzione piu' elegante dei linguaggi grafici - con i linguaggi standard piu' diffusi al tempo estesi alla grafica, ad es. il Graphic Pascal, con operatori e tipi grafici predefiniti - non ha avuto successo

con l'introduzione dei object-oriented languages e' rimasta la prima soluzione: linguaggio standard+libreria

Ogni libreria grafica prevede un collegamento con diversi linguaggi, “Language Binding",cosi' il GKS - libreria grafica - aveva un'interfaccia per il Fortran, una per il Pascal, una per il C ecc;cosi' PHIGS,e cosi' Open GL

ad es. con la libreria PHIGS, per tracciare una spezzata di n punti e n-1 segmenti in Fortran si scrivera': CALL GPL(n, Xtab, Ytab )in Pascal si scrivera': polyline(n,xtab,ytab);in C : gpolyline(n, points);dove points e' un array di punti, che sono a loro volta delle struct di coordinate (x,y) oppure (x,y,z) oppure (x,y,z,a) ecc (vedremo)

Introduzione alla Grafica Digitale

primitive grafiche:

*oggetti e attributi grafici elementari (predefiniti) disponibili al programmatorees.: punto, linea, ...


primitive grafiche:


*descrizione del "mondo" utente, spazio di coordinate del problema dove si costruisce l'immaginees.: limiti per x,y,z


primitive grafiche:


*descrizione dell' HW che produce l'immagine, per quanto interessa la visualizzazione dell'immagine su schermo e l' intera-zione con l' utente del programma, es.:finestra schermo

*descrizione del "mondo" utente, spazio di coordinate del problema dove si costruisce l'immaginees.: limiti per x,y,z


primitive grafiche:puntosegmentotriangolorettangolopoligonocerchioellissebitmapcarattere

attributi:posizione,orientamento,forma, colore, trasparenza,..

descrizione dell'HW dove si produce l'immagine

caratteristiche dello schermo, della finestra sullo schermo, dei colori disponibili, dispositivi di interazioneecc

descrizione del mondo utente o spazio problemadove e' costruita l'immagine, quindi limiti delle coordinate, specifica del passaggio dalle coordinate "mondo alle coordinate schermo ...

si noti che per tracciare un'immagine sullo schermo e per memorizzare e/o trasmettere un'immagine

devo utilizzare un insieme di primitive grafiche, devo specificare lo spazio del problema e le caratteristiche dello schermo e della finestra o parte dello schermo usata ("Work-station" o "Window")

e anche il formato del "display file" o "meta-file"

ad es. in PHIGS per costruire un'immagine si fara' : openPhigs( errFile, memSize) openWorkstation(ws, connection,type,...) ... create and display the picture ... closeWorkstation(ws) closePhigs

La libreria Open GL e' stata inizialmente definita solo per la parte delle primitive e delle operazioni disponibili, e sono le due librerie di base, la gl e la glu,

mentre la parte "apri finestra" specifica dispositivo grafico ecc era legata al Sistema Operativo in uso, ed era (ed e') diversa da Unix, Windows, Apple OS 9, ecc;

in seguito fu aggiunta

una libreria di "interfaccia standard" per le funzioni di piu' usate e piu' semplici legate al sistema operativo, e' la libreria gl-utility library, o glut, che rende un programma sorgente eseguibile su sistemi operativi diversi (windows, unix, apple os)

per inizializzare una finestra di lavoro in OpenGL con la libr. glut si avra' la sequenza di comandi:

glutInit(&argc, argv); (vedremo) glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);glutInitWindowPosition( dove_sta_x0, dove_sta_y0 );glutInitWindowSize( X_SIZE_width, Y_SIZE_height );glutCreateWindow( " TITOLO " );...glut NON appartiene alla parte centrale di OpenGL, ma alla libreria estesa glut - gl utility toolkit, - NOTA: il Borland Builder usa la VCL (visual class lib), cosi'MS Win NT.. usa una sua libreria (vedi NeHe.gamedev.com)(anche la specifica del formato di un file grafico non appartiene a OpenGL) - ma per Win NT.. esiste la versione glut adattata per MS win (vedi http://www.opengl.com )

http://www.opengl.com/

openGL e' disponibile su molte piattaforme (Unix, Windows, Apple OS9, Apple OSX... su Windows piu' versioni, compresa quella che usa la libreria pubblica glut; su rete si trova una gran quantita' di materiale !http://nehe.gamedev.net/ (NEHE Jeff Molofee univ.Hull,York,UK)---------------------------------------------------------

windows + glut version: original (#include <windows.h>) runs on Win NT etc; When creating your project, uncheck OWL, uncheck Class Library, select Static instead of Dynamic and change the target model to Console from GUI. Also link glut.lib to your project once its done.

http://nehe.gamedev.net/

http://nehe.gamedev.net/

-----------------------------------------------------------------------

nota: la libreria glut e' disponibile in sorgente su rete, dalla stessa organizzazione dell'OpenGL-----------------------------------------------------------------------

Racano (corso EGD05) segnala gl e glut per Borland 5.5, richiesto: Borland C++5.5, OpenGL runtime sw della MS, e GLUT da rete: scaricare OpenGL95.exe (unzip), copiare opengl32.dll in \windows\system\ (o winnt\system32\), copiare GL.H, GLU.H, GLAUX.H in <borland\include\gl\ (creare il dirett. gl), poi creare da .dll le .lib di: opengl32.dll, glu32.dll, glut32.gll, glut.dll, winmm.dll (con implib della Borland: implib <libname>.lib <libname>.dll e poi copiare le lib in \borland\libs\-----------------------------------------------------------------------

ricorda: manuale OpenGL "libro rosso"

istruzioni per l'installazione di OpenGL su Windows:

Istruzioni per l'installazione delle librerie OpenGL in VS 2008:nota: PVS sta per C:\Program Files\Microsoft Visual Studio 9.0scaricare da rete quanto richiesto sotto;

- copiare freeglut.h in: 'PVS\VC\include\GL\'- copiare freeglut_ext.h in: 'PVS\VC\include\GL\'- copiare freeglut_std.h in: 'PVS\VC\include\GL\'- copiare freeglut.lib in: 'PVS\VC\lib\'- copiare freeglut.dll in: 'C:\WINDOWS\system32\'- copiare glut32.dll in: 'C:\WINDOWS\system32\'- copiare glut32.lib in: 'PVS\VC\lib\'- copiare glut.h in: 'PVS\VC\include\GL\'

1. Create a new C++ Console project in VS.

1a. In the Create Application Wizard, select Empty Project.

2. Add a new cpp file to the empty project. Add a bit of template code in there. For example:#include int main () { return 0; }

3. If you try to compile, VS will fail to compile. This is because it can't see the freeglut header files.

3a. On the menu bar, go to Project -> Properties (Alt+F7).

3b. Go to Linker -> Input and copy and paste this line. opengl32.lib glu32.lib glut32.lib

4. If you try to compile now, errors may still show up. You'll probably need to add directories for your header and lib files in Project/Solutions directories.

5. The program should now compile.

le librerie OpenGL funzionano su piattaforme diverse, ma hanno bisogno di include diverse,

per cui si usa la include condizionale:#if defined __APPLE__

#include ... sara' attivo se il sistema su cui sto compilando e' Apple OS

#else // not apple : win or unix

#include ... ... sara' attivo se il sistema su cui sto compilando non e' Apple OS, e quindi e' Windows oppure Unix ...

#endif // which o.s.

// schema per include che va ok per Apple e Win#if defined __APPLE__

#include <GLUT/glut.h> /* APPLE OSX Xcode */ typedef char BYTE;

#else // not apple : win or unix

/* #define WIN32_LEAN_AND_MEAN */ /* evita inclusione di tutti i package ms */#include <windows.h> /* TOGLI SE UNIX *//* following is common to win and unix */#include <GL/gl.h> #include <GL/glu.h> #include <GL/glut.h> #include <GL/glaux.h>

#endif // which o.s. /* #include <GL/glext.h> // extensions */

vi sono anche altri punti di diversita' tra Apple OSX e Windows,(che sono emersi durante il corso EGD)

ad es. random(n) su Win, random()%n su Applee altri, come M_PI definito nella math.h in Apple OSXma che richiede un #define _USE_MATH_DEFINES // NECESSARIO in WinMS se uso M_PI, M_PI_4

...

interfaccia "multi uso" per esempi su Apple OSX e su Windows:

/* file include.h 29/3/05 GL includes //-----------------------------------------#if defined __APPLE__#include <GLUT/glut.h> /* includes GL/gl.h */// #include <GL/glext.h> /* extensions ... */

#else // avoid inclusion of all (or too much) MS stuff:#define WIN32_LEAN_AND_MEAN#include <windows.h> /* and now include */#include <GL/gl.h> #include <GL/glu.h> #include <GL/glut.h> // #include <GL/glext.h> /* extensions ... */#include <wingdi.h>#endif //----------------------------------------- // nota: la libreria glut e' disponibile in sorgente // su rete, dalla stessa organizzazione dell'OpenGL,

#ifndef myINCLUDE_H /* A.Zupan 4 mar 06 */ #define myINCLUDE_H#if defined WIN32 /*Win98,NT,XP MS VS C++ */ #include <windows.h> #include <GL/gl.h> #include <GL/glu.h> #include <GL/glut.h> #elif defined __APPLE__ /*APPLEOSX Xcode */ #include <GLUT/glut.h> #else /* Linux code */ #include <GL/gl.h> #include <GL/glu.h> #include <GL/glut.h> #include <string.h> #include <stdlib.h>#endif#include <GL/glext.h> /*seguono altri includ*/

un programma in C o C++ che usa penGL deve specificare l'ambiente in cui si disegna - quindi una finestra grafica; al minimo:... includes (abbiamo visto) ... prototipivoid faDisplay( void ); /*chiamare quando il gestore eventi decide di disegnare */void myInit(); /*inizializzazioni (una tantum) per il mio programma OGL*/void OpenWindow( int argc, char* argv[] ); /* inizializzazione della finestra */void myGlReshape (int wi, int he);

int main (int argc, char * argv[]) {

un programma in C o C++ che usa penGL deve specificare l'ambiente in cui si disegna - quindi una finestra grafica; al minimo:... includes... prototipiint main (int argc, char * argv[]) { OpenWindow( argc, argv ); glutDisplayFunc(faDisplay); /* NB: parametro e' una proc: */ /* avverti GLUT chi chiamare quando si disegna */ /* in faDisplay c'e' quanto necessario per fare il disegno */ glutReshapeFunc(myGlReshape); myInit(); /* tutte le cose da fare una volta glutMainLoop(); /* il programma va in letargo ... sara' OGL a attivare le procedure in risposta agli eventi previsti nel main prima di passare al mainloop */ return 0; /*non sara'mai eseguito */} /* main */

void OpenWindow( int argc, char* argv[] ){ GLint dimx, dimy; do{ printf("dimens.x y? "); scanf("%d%d", &dimx, &dimy ); } while (dimx<100||dimx>800||dimy<100||dimy>600); glutInit(&argc, argv); /* inizializza GLUT */ /* **** chiamata per prima ***** */ glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE ); /* modalita' RGB 8 bit/color (24 bit)+AlfaChannel */ glutInitWindowPosition(60, 20); /* posizione angolo sopra a sinist su schermo zero zero = angolo in alto a sinistra ... */ glutInitWindowSize(dimx, dimy); /*dimensione della finestra, in pixel */ glutCreateWindow("OGL1A_2RIGHE"); /* crea la finestra; non disegnata, finche' non si chiama glutMainLoop */ /*e questo e' la trafila standard per creare una finestra...*/ } /* OpenWindowPlease */

void myInit() { glViewport( 0,0, /* punto in basso a sinistra */ glutGet(GLUT_WINDOW_WIDTH), /* in alto a destra */ glutGet(GLUT_WINDOW_HEIGHT) ); glMatrixMode( GL_PROJECTION); /* 4x4 projection matrix for openGL hw */ glLoadIdentity(); /* si parte da una matrice unitaria */ gluOrtho2D( 0,glutGet(GLUT_WINDOW_WIDTH), /* left right clipping planes */ 0, glutGet(GLUT_WINDOW_HEIGHT) ); /* bottom and top clipping planes */} /* MyGLInit */

void myGlReshape (int wi, int he) { /*sara' chiamata su evento reshape (cambia forma finestra) wi,he nuove dimensioni della finestra */ myInit(); glutPostRedisplay(); } // myGlReshape ()


riprendiamo leprimitive grafiche:

puntosegmentotriangolorettangolopoligonocerchioellissebitmapcarattere

e gli attributi delle primitive grafiche,come:

posizione,orientamento,forma,colore

per disegnare un punto specifico posizione coordinate x,y colore componenti RGB dimensione: larghezza (==altezza)

il frammento seguente di programma disegna due punti (nota suffissi 2f e 3f !)

glPointSize( 4.4 ); glBegin( GL_POINTS ); // NOTA INIZIO glColor3f( 0.3, 0.3, 1.0 ); // blu glVertex2f( width/2.0, height/2.0 ); glColor3f( 1.0, 0.0, 0.0 ); // rosso glVertex2f( width*0.45, height*0.45 );glEnd(); // E FINE DI SEQUENZA


procedimento standard OpenGL per disegnare piu' punti:struct Tpunto{ float x; float y; };...glColor3f( colR, colG, colB );glPointSize(10.0); glBegin(GL_POINTS); // <<<<<<<<<<<< glVertex2f( Punto1.x, Punto1.y); glVertex2f( Punto2.x, Punto2.y); glVertex2f( Punto3.x, Punto3.y); glVertex2f( Punto4.x, Punto4.y);glEnd();

qui vengono disegnati quattro punti...

tracciare o disegnare un pixel in OpenGL:

approccio standard: con la funzione glVertexABC, con A,B,C che possono essere ... es:

int P1[]={50,110}; // un punto dato come vettore

struct TP{float x; float y;} P2={0.5, 0.5}; //pto come struct

glBegin(GL_POINTS);

glVertex2i( 50, 100 );

glVertex2iv( P1 ); // nota sufisso 2iv - vector di 2 elem.

glVertex3f( 7.2, 10.3, 100.0 ); // suffisso 3f

glVertex2f( P2.x, P2.y ); // suffisso 2f

glEnd();

// si noti le varianti della glVertex, a seconda del tipo e

// del numero dei parametri (Open GL non e' C++, ma C!)

// glFunz4f(4 parametri float) glFunz3i(tre parametri int)


Passaggio da primitiva matematica (geometrica) punto, linea

a primitiva grafica su schermo raster: pixel, linea di pixel

un punto ha dimensione zero, spessore zero, area zero

in un rettangolo astratto ("finestra" nel piano {x,y} ) vi

sono infiniti punti !

un pixel ha dimensione fissa non nulla (pixel pitch),

sullo schermo c'e' un insieme ben delimitato di punti

(ad es. 1600x1024)

linea: l'oggetto matematico linea (dimensione 1) ha

spessore zero, area zero;

linea: l'oggetto grafico e' una stringa di pixel con area, spessore,

VEDIAMO ORA COME SI

TRACCIA UNA LINEA SU SCHERMO

void myDisplay() { //due linee: una verde in basso, blu digonale // myw,myh=limiti spazio utente, width,height = larghez,altez // prima una LINEA SOTTILE VERDE in basso glColor3f( 0.0, 1.0, 0.0 );//red,green,blue glLineWidth(2.0); a=0.02*myw; b=0.02*myh; c=0.98*myw; d=0.02*myh; glBegin(GL_LINES); // NB: (0,0) sta in basso a sinistra glVertex2f( a,b ); // coordinate punto sinistra,basso, glVertex2f( c,d ); // coordinate punto destra, basso, glEnd(); // poi una LINEA GROSSA BLU DIAGONALE glColor3f( 0.0, 0.0, 1.0 ); glLineWidth(8.0); x1=0.04*myw; y1=0.96*myh; x2=0.96*myw; y2=0.04*myh; glBegin(GL_LINES); glVertex2f(x1,y1); // punto a sinistra in alto glVertex2f(x2,y2); // punto a destra in basso glEnd();

// Open GL, disegna due linee:// myw, myh = width,height spazio utente, // LINEA SOTTILE VERDE in bassoglColor3f( 0.0, 1.0, 0.0 );//red,green,blueglLineWidth(2.0); a= 0.02*myw; b=0.02*myh; // sinistra,altoc= 0.98*myw; d=0.02*myh; // destra, basso,// QUI (0,0) sta in basso a sinistra! possibili // entrambe le posizioni glBegin(GL_LINES); glVertex2f( a,b ); glVertex2f( c,d ); glEnd();// LINEA GROSSA BLU DIAGONALEglColor3f( 0.0, 0.0, 1.0 ); glLineWidth(8.0); x1=0.04*myw; y1=0.96*myh; x2=0.96*myw; y2=0.04*myh; glBegin(GL_LINES); glVertex2f(x1,y1);//sin,alto glVertex2f(x2,y2);//des,basso glEnd();

0=GL_POINTS, separate points P[0],P[1],..P[k] abbiamo visto due esempi di uso di punti e di linee:glPointSize( 4.4 ); glBegin( GL_POINTS ); // NOTA procedura INIZIO diseg glColor3f( 0.3, 0.3, 1.0 ); // blu glVertex2f( width/2.0, height/2.0 ); glColor3f( 1.0, 0.0, 0.0 ); // rosso glVertex2f( width*0.45, height*0.45 );glEnd(); // procedura FINE DI SEQUENZA

1=GL_LINES, points pairs= separate line segmentsa= 0.02*mywidth; b=0.02*myheight; // sinistra,altoc= 0.98*mywidth; d=0.02*myheight; // destra, basso,glColor3f( 0.0, 1.0, 0.0 ); //red,green,blueglLineWidth(2.5); glBegin( GL_LINES ); // procedura INIZIO disegna glVertex2f( a,b ); glVertex2f( c,d ); glEnd(); // procedura FINE DI SEQUENZA

primitive grafiche:

ogni immagine e' costruita utilizzando elementi di base, detti primitive grafiche: l'Open GL definisce 10 primitive grafiche

da usare come parametro di glBegin( param ); ... glEnd();

0=GL_POINTS, separate points P[0],P[1],..P[k]

1=GL_LINES, points pairs=separate line segments

2=GL_LINE_LOOP,closed line P[0],P[1]..P[n],P[0]

3=GL_LINE_STRIP, open line P[0],P[1]..P[n]

4=GL_TRIANGLES, each vert. triplet = triangle

non ripetiamo i due esempi visti di uso di punti e di linee,dopo la tabella seguente sono dati 10 es di uso;

primitive grafiche: Open GL

5=GL_TRIANGLE_STRIP, odd and even vert. define a triangolarized polygon 6

6=GL_TRIANGLE_FAN, vertex V[0] is common to triangles V[0]-(V[k]-V[k+1])

7=GL_QUADS, each quadruple V[k]-V[k+3]=quadril.

8=GL_QUAD_STRIP, V[0]..V[n] = polygon mesh of quadrilaterals, odd=one side,even the other

9=GL_POLYGON V[0]..V[n] a closed polygon

dopo la tabella (pagina seguente) sono dati 10 esempi di uso:

Tutte le primitive:

0=GL_POINTS, separate points P[0],P[1],..P[k] 1=GL_LINES, points pairs=separate line segments2=GL_LINE_LOOP,closed line P[0],P[1]..P[n],P[0]3=GL_LINE_STRIP, open line P[0],P[1]..P[n] 4=GL_TRIANGLES, each vertex triplet = triangle5=GL_TRIANGLE_STRIP, odd and even vertex define a triangolarized polygon 6=GL_TRIANGLE_FAN, vertex V[0] is common to all triangles V[0]-(V[k]-V[k+1]) 7=GL_QUADS, each quadruple V[k]-V[k+3]=quadril.8=GL_QUAD_STRIP, V[0]..V[n] = polygon mesh of quadrilaterals, odd=one side,even the other9=GL_POLYGON V[0]..V[n] a closed polygon

vediamo ora altri esempi

0) figura di 6 punti ottenuta con la sequenza: // xx2, yy2 sono le dimensioni della finestra !! P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0);

glBegin( GL_POINTS ); // GL_POINTS = 0 = primitiva 0 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd();

Nota per tutte le figure "PRIMITIVE": e' aggiunta una GL_LINE_STRIP che unisce i punti, e anche su alcuni sono aggiunte le etichette dei punti P1..P6

es zero: punti singolila spezzata solo per mostrare la sequenza

primitiva zero - POINTS

1) figura di segmenti di retta, ottenuta con:

// GL_LINES each couple Vk,Vk+1 define a line P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_LINES );// primitiva 1 // disegna un segmento di linea // per ogni coppia di punti glVertex2fv( P1 ); // 1 a sinis,basso glVertex2fv( P2 ); glVertex2fv( P3 ); // 2 a dest,basso glVertex2fv( P4 ); glVertex2fv( P5 ); // 3 in alto glVertex2fv( P6 ); glEnd();nota che su tutti gli es. e' aggiunta la GL_LINE_STRIP in rosso, e (su alcuni) le etichette dei punti

es 1 : linee separate

2) figura di una spezzata chiusa, ottenuta con la sequenza:

P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_LINE_LOOP ); // == 2 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd();

es. OGL2A_PRIMITIVE)nota che su tutti gli es. e' aggiunta la GL_LINE_STRIP in rosso,

es 2 : linea spezzata chiusa

3) figura di una spezzata aperta, ottenuta con la sequenza:

P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_LINE_STRIP ); // primitiva == 3 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd();

es. OGL2A_PRIMITIVE; nota che anche qui e'aggiunta la linea spezzata rossa e i nomi dei punti

es 3: linea spezzata aperta

primitiva 3 LINE_STRIP

4) figura con due triangoli ottenuta con : P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_TRIANGLES ); // primitiva 4 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd();

OGNI TERNA DI PUNTI DEFINISCE UN TRIANGL.(nota che su tutti gli es. sono aggiunti la GL_LINE_STRIP in rosso, e qui anche inomi dei punti)

es 4: triangoli separati

PRIMITIVA 4 = TRIANGLES

un poligono = superficie con contorno dato da un poligonopuo' essere pensata come formata da un mosaico di triangoli,

5) figura di poligono pieno fatto con triangoli, ottenuta con la sequenza: P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_TRIANGLE_STRIP ); // primitiva == 5 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P6 ); glVertex2fv( P3 ); glVertex2fv( P5 ); glVertex2fv( P4 ); glEnd();

NB:i vertici dei triangoli sono alternati (pari da una parte, dispari dall'altra)

es 5: poligono di triangoli pieni uniti -notare l'ordine dei punti !

PRIMITIVA 5 = TRIANGLE STRIP

6) figura a poligono pieno di triangoli, ottenuta con la sequenza:

P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0); glBegin( GL_TRIANGLE_FAN ); // primitiva == 6 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 ); glEnd();

i triangoli hanno tutti un verticein comune !(ricorda: FAN=ventaglio)

PRIMITIVA 6 = TRIANGLE FAN

es 6: poligono di triangoli pieni uniti a ventaglio

7) figura di quadrilateri, ottenuta con la sequenza:Q1[0]= xx2*0.1; Q1[1]= yy2*0.7;Q2[0]= xx2*0.1; Q2[1]= yy2*0.3;Q3[0]= xx2*0.3; Q3[1]= yy2*0.3;Q4[0]= xx2*0.3; Q4[1]= yy2*0.7;Q5[0]= xx2*0.6; Q5[1]= yy2*0.8;Q6[0]= xx2*0.6; Q6[1]= yy2*0.2;Q7[0]= xx2*0.9; Q7[1]= yy2*0.2;Q8[0]= xx2*0.9; Q8[1]= yy2*0.8; ...glBegin( GL_QUAD ); // == 7 glVertex2fv( Q1 ); // uno glVertex2fv( Q2 ); // uno glVertex2fv( Q3 ); // uno glVertex2fv( Q4 ); // uno glVertex2fv( Q5 ); // due glVertex2fv( Q6 ); // due glVertex2fv( Q7 ); // due glVertex2fv( Q8 ); // dueglEnd();

// ogni 4 punti definiscono // un quadrilatero

es 7: rettangoli pieni non unitinotare l' ordine dei punti

primitiva 7 rettangoli

8) figura di quadrilateri contigui, ottenuta con la sequenza: ...P1[0]= xx2*0.1; P1[1]= yy2*0.7;P2[0]= xx2*0.1; P2[1]= yy2*0.3;P3[0]= xx2*0.3; P3[1]= yy2*0.3;P4[0]= xx2*0.3; P4[1]= yy2*0.7;P5[0]= xx2*0.6; P5[1]= yy2*0.8;P6[0]= xx2*0.6; P6[1]= yy2*0.2;P7[0]= xx2*0.9; P7[1]= yy2*0.2;P8[0]= xx2*0.9; P8[1]= yy2*0.8;...glBegin( GL_QUAD_STRIP ); glVertex2fv( P1 );//disp sinist glVertex2fv( P2 );// pari dest glVertex2fv( P4 );//disp sinist glVertex2fv( P3 );// pari dest glVertex2fv( P5 );//disp sinist glVertex2fv( P6 );// pari dest glVertex2fv( P8 );//disp sinist glVertex2fv( P7 );// pari destglEnd();//NOTA l'ordine della squenza!NOTA: i vertici dei quadrilateri sono alternati (i vertici pari da una parte, i dispari dall'altra)

primitiva 8 QUAD STRIP

es. 8: poligono fatto da striscia di quadrilateri uniti tra loro (ogni quadr. e' fatto da due triangoli)

9) ultima primitiva, il poligono pieno :figura ottenuta con la sequenza:

P1[0]= xx2*0.1; P1[1]= yy2*0.5; P2[0]= xx2*0.30; P2[1]= yy2*0.2; P3[0]= xx2*0.70; P3[1]= yy2*0.2; P4[0]= xx2*0.9; P4[1]= yy2*0.5; P5[0]= xx2*0.70; P5[1]= yy2*0.8; P6[0]= xx2*0.30; P6[1]= yy2*0.8; glColor4f(0.7, 0.7, 0.2 , 1.0 ); glLineWidth(4.0); glPointSize(6.0);glBegin( GL_POLYGON );// == 9 glVertex2fv( P1 ); glVertex2fv( P2 ); glVertex2fv( P3 ); glVertex2fv( P4 ); glVertex2fv( P5 ); glVertex2fv( P6 );glEnd();

primitiva 9 = un poligono chiuso, pieno (non solo il contorno)

primitiva 9 poligono pieno

es. 9: poligono pieno definito dalla linea spezzata chiusa (e' fatto con triangoli)

MA ATTENZIONE - nota:l'open GL disegna correttamente poligoni convessi, mentre un poligono

concavo non viene disegnato correttamente: il frammento di programma seguente produce la fig a fianco:glBegin( GL_POLYGON ); glVertex2f(xx2*0.2, yy2*0.2); glVertex2f(xx2*0.5, yy2*0.75); glVertex2f(xx2*0.8, yy2*0.2); glVertex2f(xx2*0.8, yy2*0.8); glVertex2f(xx2*0.2, yy2*0.8); glEnd();glLineWidth(2.5); glColor4f( 0.8, 0.8, 0.1 , 1.0 ); glBegin( GL_LINE_STRIP ); glVertex2f(xx2*0.2, yy2*0.2); glVertex2f(xx2*0.5, yy2*0.75); glVertex2f(xx2*0.8, yy2*0.2); glVertex2f(xx2*0.8, yy2*0.8); glVertex2f(xx2*0.2, yy2*0.8); glEnd();

Attenzione: l'OpenGL non disegna sempre corret-tamente un poligono concavo (con rientranze)

a

a

b

b

c

cd

de

e

primitiva 9 poligono pieno

ancora un poligono concavo, ma con un ordine diverso di disegno:glBegin( GL_POLYGON ); glVertex2f(xx2*0.2, yy2*0.2); glVertex2f(xx2*0.8, yy2*0.2); glVertex2f(xx2*0.8, yy2*0.8); glVertex2f(xx2*0.5, yy2*0.25); glVertex2f(xx2*0.2, yy2*0.8); glEnd();..glColor4f(0.8,0.8,0.1,1.0); glBegin( GL_LINE_STRIP ); glVertex2f(xx2*0.2, yy2*0.2); glVertex2f(xx2*0.8, yy2*0.2); glVertex2f(xx2*0.8, yy2*0.8); glVertex2f(xx2*0.5, yy2*0.25); glVertex2f(xx2*0.2, yy2*0.8); glEnd();

==>> i poligoni pieni sono sempre triangolarizzati, ma per un poligono concavo e' meglio che lo faccia l'utente!

abcde

a b

c

d

e

l' OpenGL

oltre le dieci primitive grafiche viste

offre alcune altre primitive grafiche :

BitMap = porzioni dello schermo = insiemi di pixel,


tra le primitive grafiche in Open Gl

vi sono ancora

elementi di immagine

definiti come porzioni dello schermo,

sono insiemi di pixel, o BitMap,

usati ad es. per copiare caratteri (di tipo

bitmap) sull'immagine grafica

procedura glBitMap(...)

procedura glDrawPixels(...)

e altre;

la figura a destra e' data da :... glWindowPos3i( x1+dd, y1+dd, 0 ); // position without transformation by // modelview or projection and without clipping glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24, (char)('A'+co+ri) );...e...glColor4f( 1.0, 1.0, 1.0, 1.0 ); //MUSt call before glRasterPos glRasterPos3i( 100, 100, 0 ); glutBitmapCharacter( GLUT_BITMAP_TIMES_ROMAN_24, '@' );...

(es. OGL8_STRING)

l'area dove disegno, il "foglio di disegno"

non coincide

con lo schermo


Posizionare un punto:

lo schermo corrisponde alla memoria grafica, ma (come noto) si ricorda che la dimensione massima dell'immagine

non necessariamente e' uguale alla dimensione massima del reticolo di pixel che lo schermo riesce a mostrare

posso avere un'immagine piu' piccola che viene mostrata in una finestra (parte) dello schermo,

come posso avere un'immagine piu' grande che viene mostrata solo in parte sullo schermo (oppure intera, ma opportunamente rimpiccolita o scalata)

vedremo negli esempi concreti ...

schermo

schermo

la memoria grafica o frame buffer corrisponde al raster dell'immagine finale,e quindi ogni pixel dell'immagine finale ha una posizione in memoria data dalle sue coordinate schermo

gli esempi seguenti saranno ripresi in seguito,qui solo per dire che vi sono molte primitive ...

GLubyte bitShape[20] = { 0x1C,0x00, 0x1c, ... };// store a bit pattern in 8-bit blocks, 10 rows, 16 bit per rowglPixelStorei(GL_UNPACK_ALIGNEMENT,1);// set pixel storage modeglRasterPos2i(30,40);// raster position in world coordinates !!glBitmap( 16, 10, 0.0, 0.0, 20.0, 15.0, bitShape);// width,height, x0, y0, x0offset, y0offset

altre funzioni:glDrawPixels(width,height,dataFormat,dataType,pixMap);eg:glDrawPixels(128,128, GL_RGB, GL_UINSIGNED_BYTE, colorShape);...riprenderemo ...

cenno:un bitmap (un reticolo binario) puo' essere definito con apposite procedure, a cui per ora solo accenniamo:

glBitmap( width, height, x0, y0, x0offset, y0offset, bitShapeArray);

dove il bitShapeArray e' una tabella di bit compressi, come ad es:

GLubyte bitShapeArray[20]={0x1c,0x00,0x1c,..0xff,..0x00};

si deve dare la posizione prima della copia del bit-map, con lal proc glRasterPos*(x,y); dove *(..) sono gli stessi che si possono usare con glVertex*(..)

glDrawPixels(width,height,dataFormat,dataType, pixMapArr)copia un array di pixel su schermo, ad es:glDrawPixels(128,128, GL_RGB, GL_UNSIGNED_BYTE, MyColShap);..glReadPixels(...) per estrarre un array di pixel da un buffer, glCopyPixels(...) per copiare una zona del buffer in un'altra..

fine parte

primitive OpenGL standard

EGD11_stnd_prmtv.ppt

Elementi di Grafica Digitale standard grafici primitive grafiche.

Documents

Transcript of Elementi di Grafica Digitale standard grafici primitive grafiche.