5

ELEMENTE DE GRAFICĂ ŞTIINŢIFICĂ

5.1 Dispozitive grafice

• dispozitive cu reprezentare discretă (prin puncte) – monitoare şi imprimante

• dispozitive cu reprezentare continuă – plotter.

Monitoare
Pixel (”picture element”) – elementul grafic de bază.
Imagine raster – senzaţia vizuală de ansamblu creată de pixeli – reprezentarea des-
făşurată (maparea) memoriei grafice.
Imagine monocrom – starea 1/0 a unui bit → starea aprins/stins a unui pixel.
Imagine color – 8, 16, 24, 32 biţi/pixel → informaţia de culoare, luminozitate etc.
Rezoluţia – m × n – nr. maxim de pixeli pe direcţia orizontală × verticală
Rezoluţia → mărimea memoriei grafice (640 × 480, 800 × 600, 1024 × 768, 1200 × 1024,
1600 × 1200).

Imprimante
Imprimante cu jet de cerneală – imprimare (lentă) linie-cu-linie, memorie proprie mică.
Imprimante laser – imprimare (rapidă) pe întregul suport, memorie mare, limbajul PS.
Rezoluţia – n dpi – nr. maxim de puncte pe inch (dots per inch).
Rezoluţii tipice: 300, 600, 1200 dpi (Hewlett-Packard) sau 360, 720, 1440 dpi (Cannon).

Plotter
Sistem de motoare pas-cu-pas care realizează deplasarea pe direcţiile x şi y.
Sistem electric care comandă ridicarea/coborârea/schimbarea peniţelor.
Avantajos – reprezentări color de dimensiuni mari la rezoluţii foarte mari.
5.2 Funcţii grafice ale mediului Borland C++
Fişierul header GRAPHICS.H – bibliotecă cu peste 80 de funcţii grafice elementare –
utilizare simplă în aplicaţii DOS.
Interfaţa grafică BGI (Borland Graphics Interface); driver grafic uzual – EGAVGA.BGI.

(0,0) (getmaxx(),0)

(x,y)

(0,getmaxy()) (getmaxx(),getmaxy())

FIGURA 5.1. Sistemul coordonatelor ecran al interfeţei grafice BGI.

Coordonatele ecran
Ecranul grafic – zonă dreptunghiulară cu originea în colţul stânga-sus.
Valoarea coordonatei ecran x (pe direcţia orizontală) creşte spre dreapta.
Valoarea coordonatei ecran y (pe direcţia verticală) creşte de sus în jos.
Valorile maxime ale coordonatelor ecran → funcţiile getmaxx() şi getmaxy().
Funcţiunile grafice – deplasarea cursorului grafic pe ecran analog unui creion pe hârtie.

void far cleardevice(void);

void far closegraph(void);

int far getmaxx(void);

int far getmaxx(void);

void far initgraph(int far *driver, int far *mode, char far *path);

void far line(int x1, int y1, int x2, int y2);

void far lineto(int x, int y);

void far moveto(int x, int y);

void far outtextxy(int x,int y,char far *textstring);

void far rectangle(int left, int top, int right, int bottom);

void far settextjustify(int horiz, int vert);

void far settextstyle(int font, int direction, int charsize);

2
5.3 Reprezentarea funcţiilor de o variabilă
Se cere reprezentarea grafică a unei funcţii:

f : [xmin , xmax ] → [ymin , ymax ],

dată sub formă tabelară:

f (xi ) = yi , i = 1, 2, ..., n.

y
y max ymax
yn

y1
(xi ,yi ) (xi ,yi )
y min ymin
xmin xmax
xmin xmax x

FIGURA 5.2. Corespondenţa dintre coordonatele utilizator (xi , yi ) şi coordonatele ecran (x̄i , ȳi )
este liniară.

Nu pot fi utilizate direct coordonate utilizator, (xi , yi ), ca argumente pt. funcţiile

grafice.
Trebuie transformate în coordonate ecran, (x̄i , ȳi ), prin scalare cu o relaţie liniară
(reprezentare proporţionată):

x̄ = Ax x + Bx ,
ȳ = Ay y + By .

Coeficienţii de scalare (Ax , Bx , Ay , By ):

½ ½
x̄min = Ax xmin + Bx , Ax = (x̄max − x̄min )/(xmax − xmin )
⇒
x̄max = Ax xmax + Bx , Bx = x̄min − Ax xmax .
½ ½
ȳmin = Ay ymin + By , Ay = (ȳmax − ȳmin )/(ymax − ymin )
⇒
ȳmax = Ay ymax + By , By = ȳmin − Ay ymin .
Asimetrie în tratarea axelor x şi y – coordonatele yi nu sunt ordonate.
Coordonatele ecran corespunzătoare celor n puncte de tabelare:

x̄i = Ax xi + Bx , i = 1, 2, ..., n
ȳi = Ay yi + By .

3
/*------------------------------- graphlib.h ------------------------------*/
/*---------------------------------------------------------------------------
Contine rutine pentru realizarea pe display a graficelor functiilor de
o variabila utilizand biblioteca grafica BGI a mediului Borland C++
---------------------------------------------------------------------------*/
#ifndef GRAPHLIB
#define GRAPHLIB
#include <graphics.h>
/*=========================================================================*/
void InitGraph(void)
/*---------------------------------------------------------------------------
Initializeaza modul grafic
---------------------------------------------------------------------------*/
{
int gdriver = DETECT, gmode;
initgraph(&gdriver,&gmode,"c:/progra~1/borlandc/bgi");
}
/*=========================================================================*/
void Plot0(float x[], float y[], int n,
float fxmin, float fxmax, float fymin, float fymax)
/*---------------------------------------------------------------------------
Realizeaza reprezentarea grafica a unei functii tabelate de o variabila si o
incadreaza in fereastra [fxmin,fxmax] x [fymin,fymax], specificata prin
coordonate fractionare din intervalul [0,1]
x[] - abscisele punctelor
y[] - ordonatele punctelor
n - numarul punctelor
fxmin - abscisa relativa minima a ferestrei (0 < fxmin < fxmax< 1)
fxmax - abscisa relativa maxima a ferestrei
fymin - ordonata relativa minima a ferestrei (0 < fymin < fymax < 1)
fymax - ordonata relativa maxima a ferestrei
---------------------------------------------------------------------------*/
{
#define Nint(x) (int)floor(x + 0.5)
float ax, bx, ay, by, xmin, xmax, ymin, ymax;
int i, ixmin, ixmax, iymin, iymax;
/* coordonatele ferestrei */
ixmin = Nint(fxmin*getmaxx()); iymin = Nint((1.0-fymin)*getmaxy());
ixmax = Nint(fxmax*getmaxx()); iymax = Nint((1.0-fymax)*getmaxy());
rectangle(ixmin,iymax,ixmax,iymin); /* chenarul */
xmin = x[1]; xmax = x[n]; /* AXA X */
ax = (ixmax-ixmin)/(xmax-xmin); /* coeficienti de scalare */
bx = ixmin - ax*xmin;
ymin = y[1]; ymax = y[1]; /* AXA Y */
for (i=2; i<=n; i++) { /* ymin si ymax */
if (ymin > y[i]) ymin = y[i];
if (ymax < y[i]) ymax = y[i];
}
if (ymin == ymax) { ymin *= 0.9; ymax *= 1.1; }
ay = (iymax-iymin)/(ymax-ymin); /* coeficienti de scalare */
by = iymin - ay*ymin;
/* traseaza axele */
if (xmin*xmax < 0) line(Nint(bx),iymin,Nint(bx),iymax);
if (ymin*ymax < 0) line(ixmin,Nint(by),ixmax,Nint(by));
/* uneste punctele reprezentarii */
moveto(Nint(ax*x[1]+bx),Nint(ay*y[1]+by)); /* primul punct */
for (i=2; i<=n; i++) lineto(Nint(ax*x[i]+bx),Nint(ay*y[i]+by));
}
#endif

4
Funcţiei Plot0 i se transmit coordonatele relative ale colţurilor ferestrei de desenare.
Coordonatele ecran absolute → cu ajutorul funcţiilor getmaxx() şi getmaxy().
Directiva #ifndef GRAPHLIB permite includerea fişierului o singură dată într-o aplicaţie.

Exemplu de utilizare a funcţiei Plot0:

/*---------------------------------------------------------------------------
Reprezentarea grafica a unei functii de o variabila
---------------------------------------------------------------------------*/
#include <stdio.h>
#include <conio.h>
#include <math.h>
#include "memalloc.h"
#include "graphlib.h"
/*=========================================================================*/
float Func(float x)
{
return pow(x,3) * exp(-x);
}
/*=========================================================================*/
void main()
{
float h, xmin, xmax, *x, *y;
int i, n;
printf("xmin = "); scanf("%f",&xmin);
printf("xmax = "); scanf("%f",&xmax);
printf("n = "); scanf("%i",&n);
x = Vector(1,n);
y = Vector(1,n);
h = (xmax-xmin)/(n-1);
for (i=1; i<=n; i++) {
x[i] = xmin + (i-1)*h;
y[i] = Func(x[i]);
}
InitGraph();
Plot0(x,y,n,0.2,0.8,0.2,0.8);
getch();
closegraph();
FreeVector(x,1);
FreeVector(y,1);
}

5
FIGURA 5.3. Reprezentarea grafică a funcţiei x3 e−x cu ajutorul funcţiei Plot0 (xmin=-0.8,
xmax=7.8 şi n=51).

Funcţie mai elaborată în fişierul GRAPHLIB.H:

/*=========================================================================*/
void Plot(float x[], float y[], int n, int style,
float fxmin, float fxmax, float fymin, float fymax,
char xtext[], char ytext[], char title[])
/*---------------------------------------------------------------------------

Apelul concret:

Plot(x,y,n,1,0.2,0.8,0.2,0.8,"x","x^3 * exp(-x)","2D Plot");

FIGURA 5.4. Reprezentarea grafică a funcţiei x3 e−x cu ajutorul funcţiei Plot.

6
Bibliography

[1] Borland International, Inc., Borland C++ 3.1 Programming Guide (Borland Interna-
tional, Scotts Valley, CA, 1992).

[2] Microsoft Corporation, Microsoft Visual C++ 1.0 Programmer’s Guide (Microsoft
Corporation, 1993).

[3] T.A. Beu, Analiză numerică în Turbo Pascal (Microinformatica, Cluj-Napoca, 1992).