Professional Documents
Culture Documents
FACULTATEA DE INFORMATICA
GRAFICA PE CALCULATOR
Mironela Prnu
2014-2015
60%
40%
Vizualizarea informaiei
Proiectare
Modelare (simulare)
Interfa grafic pentru utilizatori GUI
inginerului,
omului de tiin,
artitilor plastici,
designerilor,
fotografilor,
pictorilor de animaie etc.
amestecul aditiv RGB (din englez de la Red-Green-Blue, rou-verdealbastru) amestec de culori lumin se utilizeaz pentru ecran,
monitor, televiziune, scanare, aparate foto, design web, animaie i
altele.
amestec substractiv CMYK (de la Cyan-Magenta-Yellow-blacK)
amestec de culori pigment se utilizeaz pentru proiecte poligrafice
destinate tiparului color.
Unele modele de culoare admit variaii ale diapazonului cromatic, din acest
motiv sunt mprite n diverse profiluri de culoare destinate diferitelor
necesiti. De exemplu, pentru modelul RGB exist mai multe profiluri. sRGB
IEC61966-2.1 diapazon mediu utilizat mai des pentru pagini web, sau Adobe
RGB (1998) diapazon mai mare utilizat pentru prelucrarea imaginilor destinate
produselor pentru tipar.
6
Pe lng modelele cromatice RGB i CMYK mai exist i altele precum: Lab,
HSB / HSL / HSI, Culori Indexate, Culori Pantone/PMS (Pantone Matching
System), Culori Spot.
Aplicaiile grafice avansate pot combina imagini din surse vectoriale i raster i
pun la dispoziie unelte pentru amndou, n cazurile n care unele pri ale
proiectului pot fi obinute de la o camer, iar altele desenate prin grafic
vectorial.
Vectorizarea
Aceasta se refer la programe i tehnologii/servicii folosite pentru a converti
imagini de tip bitmap n imagini de tip vectorial. Exemple de utilizare:
Dezavantaje i limitri
Principalul dezavantaj al imaginilor vectoriale este c, fiind alctuite din obiecte
descrise cu formule matemetice, att numrul acestor obiecte ct i
complexitatea lor sunt limitate, depinznd de biblioteca de formule matematice
folosit de programul de desenare. De exemplu, dispozitivele digitale, cum ar fi
camerele foto sau scannerele, produc fiiere raster care nu pot fi reprezentate
fidel folosind imagini vectoriale. Chiar i n cazul n care se reuete
vectorizarea unei astfel de imagini, editarea acesteia la complexitatea original
este dificil.Un alt dezavantaj este c formatele n care sunt stocate imaginile
vectoriale sunt foarte complexe. Implementarea acestor formate pe dispozitive
diferite este problematic din aceast cauz. Conversia dintr-un format n altul
este de asemenea dificil.
Aplicaii
Datorit flexibilitii n ceea ce privete rezoluia imaginilor vectoriale, acestea
sunt folosite intensiv pentru crearea materialelor ce trebuie imprimate la mrimi
foarte diverse: acelai fiier poate fi folosit pentru un card de vizit ct i pentru
un panou publicitar, n ambele cazuri.rezultatele fiind foarte clare i precise.
9
10
Seleciile
Straturile (Layers)
Mtile (Masks)
11
Canalele (Channels)
Retuarea
Optimizarea imaginilor pentru Web
Formate fiiere
Photoshop poate citi majoritatea fiierelor raster i vector. De asemenea, are o
serie de formate proprii:
Ultimele instrumente
18
OpenGl
Dintre bibliotecile grafice existente, biblioteca OpenGL, scris n limbajul C,
este una dintre cele mai utilizate, datorit faptului c implementeaz un numr
mare de funcii grafice de baz pentru crearea apliciilor grafice interactive,
asigurnd o interfa independent de platforma hardware.
Desi introdus n anul 1992, biblioteca OpenGL a devenit n momentul de
fa cea mai intens folosit interfa grafic pentru o mare varietate de
platforme hardware i pentru o mare varietate de aplicaii grafice 2D i 3D,
de la proiectare asistat de calculator (CAD), la animaie, imagistic
medical i realitate virtual.
Datorit suportului oferit prin specificaiile unui consoriu specializat (OpenGL
Architecture Review Board) i a numrului mare de implementri existente, n
momentul de fa OpenGL este n mod real singurul standard grafic
multiplatform. www.opengl.org.
Aplicaiile OpenGL pot rula pe platforme foarte variate, ncepnd cu PC,
staii de lucru i pn la supecalculatoare, sub cele mai cunoscute sisteme de
operare: Linux, Unix, Windows NT, Windows 95, Mac OS. Funiile OpenGL
sunt apelabile din limbajele Ada, C, C++ i Java.
Din consoriul de arhitectur OpenGL fac parte reprezentani de la firmele
Compaq, Evens-Sutherland, Hewlett-Packard, IBM, Intel, Intergraph, Microsoft
i Silcon Graphics. Pentru scrierea aplicaiilor folosind interfaa OpenGL de
ctre utilizatori finali nu este necesar obinerea unei licene.
Folosind biblioteca OpenGL, un programator n domeniul graficii se poate
concentra asupra aplicaiei dorite i nu mai trebuie s fie preocupat de detaliile
de implementare a diferitelor funcii standard. Programatorul nu este obligat
s scrie algoritmul de generare a liniilor sau a suprafeelor, nu trebuie s
calculeze decuparea obiectelor la volumul de vizualizare, etc, toate acestea fiind
deja implementate n funciile bibliotecii i, cel mai probabil, mult mai eficient
i adaptat platformei hardware dect le-ar putea realiza el nsui.
n redarea obiectelor tridimensionale, biblioteca OpenGL folosete un numr
redus de primitive geometrice (puncte, linii, poligoane), iar modele complexe
ale obiectelor i scenelor tridimensionale se pot dezvolta particularizat pentru
fiecare aplicaie, pe baza acestor primitive.
Dat fiind c OpenGL prevede un set puternic, dar de nivel sczut, de comenzi de
redare a obiectelor, mai sunt folosite i alte biblioteci de nivel mai nalt care
utilizeaz aceste comenzi i preiau o parte din sarcinile de programare grafic.
19
fiecare tip de sistem Windows. Header-ul glut.h trebuie s fie inclus n fiierele
aplicaiei, iar biblioteca glut.lib trebuie legat (linkat) cu programul de
aplicaie.
Sub GLUT, orice aplicaie se structureaz folosind mai multe funcii
callback. O funcie callback este o funcie care aparine programului aplicaiei i
este apelat de un alt program, n acest caz sistemul de operare, la apariia
anumitor evenimente. n GLUT sunt predefinite cteva tipuri de funcii callback;
acestea sunt scrise n aplicaie i pointerii lor sunt transmii la nregistrare
sistemului Windows, care le apeleaz (prin pointerul primit) n momentele
necesare ale execuiei.
Funcii de control ale ferestrei de afiare
Funcii callback.
Funciile callback se definesc n program i se nregistreaz n sistem prin
intermediul unor funcii GLUT. Ele sunt apelate de sistemul de operare atunci
cnd este necesar, n funcie de evenimentele aprute.
a. glutDisplayFunc(void(*Display)(void));
Aceast funcie nregistreaz funcia callback Display n care se
calculeaz i se afieaz imaginea. Argumentul funciei este un pointer la o
funcie fr argumente care nu returneaz nici o valoare.
Atentie:
Funcia Display (a aplicaiei) este apelat oridecte ori este necesar desenarea
ferestrei: la iniializare, la modificarea dimensiunilor ferestrei.
glutReshapeFunc(void(*Reshape)(int w, int h));
nregistreaz funcia callback Reshape care este apelat ori de cte ori se
modific dimensiunea ferestrei de afiare. Argumentul este un pointer la funcia
cu numele Reshape cu dou argumente de tip ntreg i care nu returneaz nici o
valoare. n aceast funcie, programul de aplicaie trebuie s refac
transformarea fereastr-poart, dat fiind c fereastra de afiare i-a modificat
dimensiunile.
glutKeyboardFunc(void(*Keyboard)(unsigned int key,
int x, int y);
nregistreaz funcia callback Keyboard care este apelat atunci cnd se
acioneaz o tast. Parametrul key este codul tastei, iar x i y sunt coordonatele
(relativ la fereastra de afiare) a mouse-ului n momentul acionrii tastei.
glutMouseFunc(void(*MouseFunc)(unsigned int button, int state, int x,
int y);
nregistreaz funcia callback MouseFunc care este apelat atunci cnd
este apsat sau eliberat un buton al mouse-ului.
Parametrul button este codul butonului si poate avea una din constantele
GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON sau
GLUT_RIGHT_BUTTON) . Parametrul state indic apsarea (GLUT_DOWN)
sau eliberarea (GLUT_UP) al unui buton al mouse-ului. Parametrii x i y sunt
coordonatele relativ la fereastra de afiare a mouse-ului n momentul
evenimentului.
Exemplu:
void mouse(int buton, int stare, int x, int y)
{
switch(buton)
{
22
case GLUT_LEFT_BUTTON:
if(stare == GLUT_DOWN)
glutIdleFunc(animatieDisplay);
break;
case GLUT_RIGHT_BUTTON:
if(stare== GLUT_DOWN)
glutIdleFunc(NULL);
break;
}
}
Funcii de execuie GLUT
Execuia unui program folosind toolkit-ul GLUT se lanseaz prin apelul
funciei glutMainLoop(), dup ce au fost efectuate toate iniializrile i
nregistrrile funciilor callback. Aceast bucl de execuie poate fi oprit prin
nchiderea ferestrei aplicaiei. n cursul execuiei sunt apelate funciile callback
n momentele apariiei diferitelor evenimente.
Generarea obiectelor tridimensionale
Multe programe folosesc modele simple de obiecte tridimensionale pentru
a ilustra diferite aspecte ale prelucrrilor grafice. GLUT conine cteva funcii
care permit redarea unor astfel de obiecte tridimensionale n modul wireframe
sau cu suprafee pline (filled). Fiecare obiect este reprezentat ntr-un sistem de
referin local, iar dimensiunea lui poate fi transmis ca argument al funciei
respective. Poziionarea i orientarea obiectelor n scen se face n programul de
aplicaie. Exemple de astfel de funcii sunt:
void glutWireCube(GLdouble size);
void glutSolidCube(GLdouble size);
void glutWireSphere(GLdouble radius, GLint slices,
GLint stacks);
void glutSolidSphere(GLdouble radius, GLint slices,
GLint stacks);
Programele GLUT au un mod specific de organizare, care provine din
felul n care sunt definite i apelate funciile callback.
23
(update rate) i, dac acest proces are loc simultan cu extragerea datelor din
buffer i afiarea lor pe display, atunci ecranul va prezenta un timp foarte scurt
imaginea complet a fiecrui cadru, iar cea mai mare parte din timp ecranul va fi
ters sau va conine imagini pariale ale cadrului. Tehnica universal folosit
pentru redarea imaginilor dinamice (care se schimb de la un cadru la altul) este
tehnica dublului buffer de imagine.
n aceast tehnic exist dou buffere de imagine: bufferul din fa (front), din
care este afiat imaginea pe ecran i bufferul din spate (back), n care se nscriu
elementele de imagine generate. Cnd imaginea unui cadru a fost complet
generat, ea poate fi afiat pe ecran printr-o simpl operaie de comutare ntre
buffere: bufferul spate devine buffer fa, i din el urmeaz s fie afiat imagine
cadrului curent, iar bufferul fa devine buffer spate i n el urmeaz s fie
generat imaginea noului cadru. Comutarea ntre bufferele de imagine se poate
sincroniza cu cursa de revenire pe vertical a monitorului i atunci imaginile
sunt prezentate continuu, fr s se observe imagini fragmentate sau plpiri.
n OpenGL comutarea bufferelor este efectuat de funcia SwapBuffers().
Aceast funcie trebuie s fie apelat la terminarea generrii imaginii tuturor
obiectelor vizibile n fiecare cadru.
Modul n care se execut comutarea bufferelor depinde de platforma hardware.
Operaiile de baz OpenGL
OpenGL deseneaz primitive geometrice (puncte, linii i poligoane) n diferite
moduri selectabile. Primitivele sunt definite printr-un grup de unul sau mai
multe vrfuri (vertices). Un vrf definete un punct, captul unei linii sau vrful
unui poligon. Fiecare vrf are asociat un set de date:
coordonate,
culoare,
normal,
coordonate de textur.
Aceste date sunt prelucrate independent, n ordine i n acelai mod pentru toate
primitivele geometrice. Singura deosebire care apare este aceea c, dac o linie
sau o suprafa este decupat, atunci grupul de vrfuri care descriau iniial
primitiva respectiv este nlocuit cu un alt grup, n care pot apare vrfuri noi
rezultate din intersecia laturilor cu planele volumului de decupare (volumul
canonic) sau unele vrfuri din cele iniiale pot s dispar.
Comenzile sunt prelucrate n ordinea n care au fost primite n OpenGL, adic
orice comand este complet executat nainte ca s fie executat o nou
comand.
Biblioteca OpenGL primete o succesiune de primitive geometrice pe care
le deseneaz, adic le convertete n mulimea de pixeli corespunztoare,
nscriind valorile culorilor acestora ntr-un buffer de imagine. n continuare sunt
25
Primitive geometrice
OpenGL execut secvena de operaii grafice asupra fiecrei primitive
geometrice, definit printr-o mulime de vrfuri i tipul acesteia. Coordonatele
unui vrf sunt transmise ctre OpenGL prin apelul unei funcii glVertex#().
Aceasta are mai multe variante, dup numrul i tipul argumentelor. Iat, de
exemplu, numai cteva din prototipurile funciilor glVertex#():
void glVertex2d(GLdouble x, GLdouble y);
void glVertex3d(GLdouble x, GLdouble y, GLdouble z);
void glVertex3f(GLfloat x, GLfloat y, GLfloat z);
Vrfurile pot fi specificate n plan, n spaiu ( sau n coordonate omogene),
folosind apelul funciei corespunztoare.
O primitiv geometric se definete printr-o mulime de vrfuri (care dau
descrierea geometric a primitivei) i printr-unul din tipurile prestabilite, care
indic topologia, adic modul n care sunt conectate vrfurile ntre ele.
Mulimea de vrfuri este delimitat ntre funciile glBegin() i glEnd(). Aceeai
mulime de vrfuri (v0, v1, v2,.vn1) poate fi tratat ca puncte izolate, linii,
poligon, etc, n funcie de tipul primitivei, care este transmis ca argument al
funciei glBegin():
void glBegin(GLenum mode);
Exista mai multe tipuri de primitive pe care le putem desena folosind OpenGL.
Tipurile de primitive geometrice
Argument
GL_POINTS
GL_LINES
GL_LINE_STRIP
GL_LINE_LOOP
GL_TRIANGLES
Primitiv geometric
Deseneaz n puncte
Deseneaz segmentele de dreapt izolate
(v0,v1), (v2,v3), .a.m.d. Dac n este impar
ultimul vrf este ignorat
Deseneaz linia poligonal format din
segmentele (v0,v1), (v1,v2), .. . (vn2, v n
1)
La fel ca primitiva GL_LINE_STRIP, dar se
mai desenez segmentul (vn, v0) care
nchide o bucl.
Deseneaz o serie de triunghiuri folosind
vrfurile (v0,v1,v2), (v3,v4,v5), .a.m.d. Dac
n nu este multiplu de 3, atunci ultimele 1
27
GL_TRIANGLE_STRIP
GL_TRIANGLE_FAN
GL_QUADS
GL_QUADS_STRIP
GL_POLYGON
flotant, astfel nct valoarea negativ maxim este transformat n 1.0, iar
valoarea pozitiv maxim este transformat n 1.0 (intensitate maxim).
Valoarea final a culorii unui pixel, rezultat din toate calculele de umbrire, antialiasing, texturare, etc, este memorat n bufferul de imagine, o component
fiind reprezentat printr-un numr n de bii (nu neaprat acelai numr de bii
pentru fiecare component). Deci componentele culorilor pixelilor memorate n
bufferul de imagine sunt numere ntreg n intervalul (0 , 2n 1), care se obin
prin conversia numerelor n virgul mobil prin care sunt reprezentate i
prelucrate culorile primitivelor geometrice, ale materialelor, etc.
glColor3f(0.8,0.8,0.8);
glBegin(GL_POLYGON);
glVertex3d(-4,2,-20);
glVertex3d(-1,5,-20);
glVertex3d(5,2.5,-20);
glVertex3d(3,-3,-20);
glVertex3d(-1,-4,-20);
glEnd();
Sistemul de vizualizare OpenGL
Sistemul de vizualizare OpenGL definete sistemele de referin, transformrile
geometrice i relaiile (matriceale) de transformare pentru redarea primitivelor
geometrice. Sistemul de vizualizare OpenGL este o particularizare a sistemului
PHIGS, n care centrul sistemului de referin de observare (VRP) coincide cu
centrul de proiecie (PRP).
Transformri geometrice
Aa dup cum s-a mai artat, nu este eficient s se calculeze produsul dintre
matricea de reprezentare a fiecrui punct i matricele de transformri succesive,
ci se calculeaz o matrice de transformare compus, care se poate aplica unuia
sau mai multor obiecte. Pentru calculul matricelor de transformare compuse
(prin produs de matrice) se folosete o matrice de transformare curent i
operaii de acumulare n matricea curent prin postmultiplicare (nmulire la
dreapta): se nmulete matricea curent cu noua matrice (n aceast ordine) i
rezultatul nlocuiete coninutul matricei curente. Pentru nceput, se consider o
matrice curent oarecare C stabilit n OpenGL. Matricea curent se poate
iniializa cu matricea identitate prin funcia glLoadIdentity(), sau cu o matrice
oarecare, dat prin pointer la un vector de 16 valori consecutive, prin funcia
glLoadMatrix#():
30
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,
GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,
GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
GL_NEAREST);
glEnable(GL_TEXTURE_2D);
}
void Display(){
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glBindTexture(GL_TEXTURE_2D, texName[1]);
glPushMatrix();
glTranslated(-2.0,0.0,-8);
glBegin(GL_QUADS);
glTexCoord2f(0.0,0.0);glVertex3f(-0.5,-1.0,0.0);
glTexCoord2f(0.5,0.0);glVertex3f( 0.5,-1.0,0.0);
glTexCoord2f(0.5,1.0);glVertex3f( 0.5, 1.0,0.0);
glTexCoord2f(0.0,1.0);glVertex3f(-0.5, 1.0,0.0);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslated(0.0,0.0,-8);
glRotated(-70,1.0,0.0,0.0);
glBegin(GL_QUADS);
glTexCoord2f(0.0,0.0);glVertex3f(-0.5,-1.0,0.0);
glTexCoord2f(0.5,0.0);glVertex3f( 0.5,-1.0,0.0);
glTexCoord2f(0.5,1.0);glVertex3f( 0.5, 1.0,0.0);
glTexCoord2f(0.0,1.0);glVertex3f(-0.5, 1.0,0.0);
glEnd();
glPopMatrix();
glBindTexture(GL_TEXTURE_2D, texName[0]);
glPushMatrix();
glTranslated(1.5,0.0,-8);
glBegin(GL_QUADS);
glTexCoord2f(0.5,0.0);glVertex3f(0.0,-1.0,0.0);
glTexCoord2f(1.0,0.0);glVertex3f( 1.0,-1.0,0.0);
glTexCoord2f(1.0,1.0);glVertex3f( 1.0, 1.0,0.0);
glTexCoord2f(0.5,0.5);glVertex3f(-0.0, 0.0,0.0);
glEnd();
glPopMatrix();
39
glutSwapBuffers();
}
void Reshape(int w, int h){
h = (h == 0) ? 1 : h;
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat) w/(GLfloat) h,
0.1, 4000.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main(int argc, char** argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
glutInitWindowSize(500,500);
glutInitWindowPosition(100,100);
glutCreateWindow("Texture Check Image");
Init();
glutDisplayFunc(Display);
glutReshapeFunc(Reshape);
glutMainLoop();
return 0;
}
40
Exemple OpenGl
Exemplu 1
Exemplu 2
41
Exemplu 3
Exemplu 4
42
Exemplu 5
Exemplu 6
43
Exemplu 7
Exemplu 8
44
Exemplu 9
Exemplu 10
45
Exemplu 11
46
Exemplu 12
Exemplu 13
47
Exemplu 14
Exemplu 15
48
Exemplu 16
Exemplu 17
49
Exemplu 18
Exemplu 19
50
Exemplu 20
51
Exemplu 21
52
Exemplu 22
Exemplu 23
53
Exemplu 24
54
Exemplu 25
55
Exemplu 26
Exemplu 27
56
Exemplu 28
Exemplu 29
57
Exemplu 30
Exemplu 31
58
Exemplu 32
59
60
Exemplu 33
61
Exemplu 34
62
Exemplu 35
63
exemplu 37
#include <GL/glut.h> //header OpenGL ce include gl.h si glu.h
void init()//functia initiere
{
// glClearColor (0.0, 0.0, 0.0, 0.0);//stabileste culoarea de sters
// glShadeModel (GL_FLAT);
}
void display()//functia de desenare si afisare
{
glClear (GL_COLOR_BUFFER_BIT);//sterge urmele de desene din fereastra curenta
glBegin(GL_POLYGON);//initializare desen poligon
glColor3f (2.0, 0.0, 0.0);//culoarea de desenare
glVertex2f(200.0,200.0);//stabilire coordonate triunghi
glVertex2f(400.0,200.0);//stabilire coordonate triunghi
glVertex2f(400.0,400.0);//stabilire coordonate triunghi
glEnd();//sfisit desenare
glFlush ();//executare functie
glColor3f (1.0, 1.0, 0.0);//culoarea de desenare
glBegin(GL_POLYGON);//initializare desen poligon
glVertex2f(200.0,400.0);//stabilire coordonate triunghi
glVertex2f(400.0,400.0);//stabilire coordonate triunghi
glVertex2f(200.0,200.0);//stabilire coordonate triunghi
glEnd();//sfisit desenare
glFlush ();//executare functie
glColor3f (0.0, 1.0, 1.0);//culoarea de desenare
glBegin(GL_POLYGON);//initializare desen poligon
glVertex2f(000.0,000.0); //stabilire coordonate triunghi
glVertex2f(200.0,200.0);//stabilire coordonate triunghi
glVertex2f(000.0,200.0);//stabilire coordonate triunghi
glEnd();//sfisit desenare
glFlush ();//executare functie
glColor3f (1.0, 0.5, 1.0);//culoarea de desenare
glBegin(GL_POLYGON);//initializare desen poligon
glVertex2f(000.0,000.0); //stabilire coordonate triunghi
glVertex2f(200.0,200.0);//stabilire coordonate triunghi
glVertex2f(000.0,200.0);//stabilire coordonate triunghi
glEnd();//sfisit desenare
glFlush ();//executare functie
glColor3f (1.0, 1.0, 0.5);//culoarea de desenare
glBegin(GL_POLYGON);//initializare desen poligon
glVertex2f(600.0,000.0); //stabilire coordonate triunghi
glVertex2f(600.0,200.0);//stabilire coordonate triunghi
glVertex2f(400.0,200.0);//stabilire coordonate triunghi
glEnd();//sfisit desenare
glFlush ();//executare functie
glColor3f (0.0, 1.0, 0.0);//culoarea de desenare
glBegin(GL_POLYGON);//initializare desen poligon
glVertex2f(200.0,400.0);//stabilire coordonate triunghi
glVertex2f(000.0,400.0);//stabilire coordonate triunghi
glVertex2f(200.0,600.0);//stabilire coordonate triunghi
64
glEnd();//sfisit desenare
glFlush ();//executare functie
glColor3f (0.0, 1.0, 1.0);//culoarea de desenare
glBegin(GL_POLYGON);//initializare desen poligon
glVertex2f(400.0,400.0); //stabilire coordonate triunghi
glVertex2f(600.0,400.0);//stabilire coordonate triunghi
glVertex2f(600.0,600.0);//stabilire coordonate triunghi
glEnd();//sfisit desenare
glFlush ();//executare functie
glColor3f (3.0, 0.0, 0.0);//culoarea de desenare
glBegin(GL_POLYGON);//initializare desen poligon
glVertex2f(400.0,600.0); //stabilire coordonate triunghi
glVertex2f(400.0,400.0);//stabilire coordonate triunghi
glVertex2f(600.0,600.0);//stabilire coordonate triunghi
glEnd();//sfisit desenare
glFlush ();//executare functie
} void reshape (int w, int h)//functia redesenare
{ glViewport (0, 0, (GLsizei) w, (GLsizei) h);//stabilirea viewportului la dimensiunea
ferestrei
glMatrixMode (GL_PROJECTION);//specificare matrice modificabila la valoare
argumentului de modificare
glLoadIdentity ();//initializarea sistemului de coordonate
gluOrtho2D (0.0, (GLdouble) w, 0.0, (GLdouble) h);//stabileste volumul de vedere folosind
o proiectie ortografica
}
int main(int argc, char** argv) //creare fereastra {
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);//se specifica modelul de culoare al
ferestrei: un singur buffer si culoare RGB
glutInitWindowSize (600, 600);//initiaza dimensiunea ferestrei principale 600x600 pixeli
glutInitWindowPosition (200,10);//initiaza in fereastra principala fereastra de afisare
glutCreateWindow ("TRIUNGHIURI");
init ();
glutDisplayFunc(display);//se reimprospateza continutul ferestrei
glutReshapeFunc(reshape);//functia redesenare
glutMainLoop();//bucla de procesare a evenimentelor
return 0; }
exemplu 38
#include <GL/glut.h>
#include <stdlib.h> #include <math.h>
void init() {
// Stabileste culoarea cu care se va curata interiorul ferestrei, prin parametrii dati
stabilindu-se
// componenetele culorii ce au valori reale de la 0.0 la 1.0 (cu pasi aproximativi de
0.00006).
glClearColor (0.0, 0.0, 0.0, 0.0);
// select flat or smooth shading.
glShadeModel (GL_FLAT);
} void display() {
// Sterge eventualele desene din fereastra curenta
glClear (GL_COLOR_BUFFER_BIT);
// stabileste culoarea (RGB)
65
67
MODEL BILET 1
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
{
20.
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
21.
glMatrixMode (GL_PROJECTION);
22.
glLoadIdentity ();
23.
gluOrtho2D (0.0, (GLdouble) w, 0.0,
(GLdouble) h);
24.
}
25.
int main(int argc, char** argv)
26.
{
27.
glutInit(&argc, argv);
28.
glutInitDisplayMode (GLUT_SINGLE |
GLUT_RGB);
29.
glutInitWindowSize (600, 600);
30.
glutInitWindowPosition (100,100);
31.
glutCreateWindow (argv[0]);
32.
init ();
33.
glutDisplayFunc(display);
34.
glutReshapeFunc(reshape);
35.
glutMainLoop();
36.
return 0;
37.
}
#include <GL/glut.h>
void init()
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}
void display()
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 0.0, 0.0);
glBegin(GL_POLYGON);
glVertex2f(200.0,200.0);
glVertex2f(400.0,200.0);
glVertex2f(400.0, 400.0);
glEnd();
glFlush ();
}
void reshape (int w, int h)
5. Sa se scrie setul de comenzi (utilizand OpenGl) care, in urma executiei, vor conduce la
fereastra din figura alaturata (1.5 pct).
68
Model bilet 2
1. Prezentati cel putin 4 idei principale din referatul intocmit (2 pct).
2. Caracterizati grafica vectorial (2 pct).
3. Explicati modelele de culori RGB si CMYK (1 pct).
4. Sa se explice fiecare functie OpenGl utilizata in programul urmator (2 pct).
1.
#include <GL/glut.h>
2.
void init()
3.
{
4.
glClearColor (0.0, 0.0, 0.0, 0.0);
5.
glShadeModel (GL_FLAT);
6.
}
7.
void display()
8.
{
9.
glClear
(GL_COLOR_BUFFER_BIT);
10.
glColor3f (1.0, 0.0, 0.0);
11.
glBegin(GL_POLYGON);
12.
glVertex2f(200.0,200.0);
13.
glVertex2f(400.0,200.0);
14.
glVertex2f(400.0, 400.0);
15.
glEnd();
16.
glFlush ();
17.
}
18.
void reshape (int w, int h)
19.
{
20.
glViewport (0, 0, (GLsizei) w,
(GLsizei) h);
21.
glMatrixMode
(GL_PROJECTION);
22.
glLoadIdentity ();
23.
gluOrtho2D (0.0, (GLdouble) w,
0.0, (GLdouble) h);
24.
}
25.
int main(int argc, char** argv)
26.
{
27.
glutInit(&argc, argv);
28.
glutInitDisplayMode
(GLUT_SINGLE | GLUT_RGB);
29.
glutInitWindowSize (600, 600);
30.
glutInitWindowPosition
(100,100);
31.
glutCreateWindow (argv[0]);
32.
init ();
33.
glutDisplayFunc(display);
34.
glutReshapeFunc(reshape);
35.
glutMainLoop();
36.
return 0;
37.
}
69