Tutorial

Biblioteca de Rotinas Gráficas - Graphics.h

A biblioteca gráfica encontrada em C tem por finalidade proporcionar uma

melhor interface entre o usuário e o software, a partir dela pode-se desenvolver

telas, menus, gráficos, manipulações de imagens etc. .

Algumas das vantagens de sua utilização, é que com uma melhor interface

com o usuário, o software pode se tornar mais atraente ao usuário além de

permitir a visualização de dados de formas diferentes, como em forma de gráfico

e tabelas sendo um trabalho que muitas vezes se torna impossível no modo

convencional

O sistema gráfico requer que a biblioteca graphics.h seja ligado com o

programa (Linker da biblioteca gráfica ao compilador).

Um conceito fundamental para a utilização do modo gráfico é o conceito de

janela, a parte ativa da tela dentro do qual a saída será exibida. Uma janela pode

ter toda largura da tela, como é o padrão, ou ser tão pequena como as

necessidades específicas exigirem. O "C" utiliza tamanhos de tela diferentes para

o modo texto e para o modo gráfico. As funções de texto referem-se as janelas

que possuem uma dimensão padrão de 80 colunas e 25 de linhas, já o modo

gráfico refere-se aos viewport (janelas gráficas) que possuem uma dimensão

variável de resolução de tela que vai depender da resolução do vídeo que está

sendo utilizado.

No modo texto o menor elemento que pode ser exibido é um caracter

enquanto que no modo gráfico é um pixel.

Entrando no ambiente gráfico a configuração do tamanho da tela é alterada de

acordo com o modo de vídeo que foi detectado. Normalmente será utilizado o

ambiente VGA, neste caso as dimensões da tela passará de 80x25 do modo

texto para, 640x480 no modo gráfico. No modo texto uma linha conteria até 80

caracteres e uma coluna 25 caracteres, já no modo gráfico a contagem não seria

mais em caracteres mas sim em pixels. Deste modo uma linha teria 640 pixels e

uma coluna 480 pixels.

Na biblioteca graphics.h é oferecido um rico conjunto de rotinas gráficas. Estas

funções gráficas contêm primitivas para desenhar pixels, linhas, retângulos,

arcos, círculos e ovais.(Elas são chamadas primitivas porque desenham apenas

uma forma básica.)

As funções mais avançadas incluem rotinas para desenhar gráficos setoriais e

de barras de duas ou três dimensões. Funções gráficas adicionais permitem o

usuário definir o modo gráfico, selecionar o viewport(o tamanho da imagem),

preencher objetos com cores e padrões, alterar o tipo e tamanho das fontes e

assim por diante.

As primeiras linhas de código

Quando utilizamos a biblioteca gráfica temos que detectar antes de mais nada

o controlador e modo de vídeo corrente e inicializar o sistema gráfico. Para isto

utilizaremos as funções "DETECT" e "initgraph" .

A função "DETECT" atribui o valor 0 como um valor "default" a uma variável

correspondente ao driver da biblioteca "BGI". Por sua vez a função "initgraph"

inicializará o sistema gráfico utilizando os parâmetros : driver de vídeo (utiliza-se

a variável com valor recebido pela função “DETECT” ) modo de vídeo e a

localização do diretório BGI corrente .

Exemplo 1

#include<graphics.h>
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
void main()
{
int gdriver,gmode,errorcode;

gdriver=DETECT;
initgraph(&gdriver,&gmode," "); // inicializa o modo gráfico
errorcode=graphresult() // se o modo gráfico for inicializado
corretamente a //função “graphresult”
retorna uma valor igual a zero

if(errorcode!=0)
{ printf("Error de função gráfica: %s\n",grapherrormsg(errorcode));
printf("Aperte qualquer tecla para parar!");
getch();
exit(1);
}

outtext("Meu primeiro programa gráfico"); // exibe a string na tela

getch();
closegraph(); //Finaliza o modo gráfico
}

OBS - Como você deve ter observado na última linha de código foi utilizada

a função “closegraph” , ela possibilita o retorno do modo gráfico ao modo

texto.
Linker da biblioteca gráfica ao compilador

Para utilizarmos a biblioteca gráfica devemos liga-la ao compilador acessando

a opção “Options” na caixa de ferramentas, em seguida “linker” e ”libraries”,

finalmente checando a opção “graphcs library” na lista de library. Mesmo que

isto não seja feito quando seu programa for compilado não aparecerá qualquer

erro, mas quando ele for executado(RUN) todas as funções gráficas não serão

reconhecidas com se não tivesse uma biblioteca correspondente.

Entrando com dados

Os comandos de entrada de dados do modo texto como scanf ou gets entre

outros não serão permitido neste ambiente ou seja ficaremos restritos apenas a

exibição de dados pela falta de comandos de entrada de dados do modo gráfico.

Isto acontece pois qualquer entrada via teclado não ecoa na tela como é feito no

modo texto. Este problema pode ser solucionado por uma rotina que permita a

visualização dos dados de entrada

Exemplo 2:

#include <graphics.h>

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>

#include <dos.h>

#include <string.h>

void inicializa();

char nome[20],pt[2];

void main()
{
inicializa();
setbkcolor(1);
setcolor(15);
cleardevice();

int i=0,x=200;
while(i<20)
{
nome[i]=getch();
pt[0]=nome[i];
pt[1]='\0';
 outtextxy(x,10,pt);
x+=10;i++;
}
getch();
}

void inicializa()
{ int gdriver = EGA, gmode = EGAHI, errorcode;
initgraph(&gdriver, &gmode, "..\\bgi");
errorcode = graphresult();
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
getch();
exit(1);
}
}

Funções gráficas:

arc Desenha um arco circular

arc (int x, int y , int anguloini, int angfim, int raio)

bar Desenha uma barra bidimensional

bar ( int esquerda, int topo, int direita, int base)

 bar3d Desenha uma barra tridimensional

bar 3d (int esquerda, int topo, int direita, int base, int profund, int

topflag);

circle Desenha um círculo

circle ( int x, int y, int raio);

cleardevice Limpa a tela gráfica

cleardevice (void);

clearviewport Limpa o viewport atual

clearviewport (void);

closegraph Fecha o sistema de gráficos

closegraph (void);

detectgraphc Determina o controlador e o modo do hardware

detectgraph ( int far *contro_graf, int far *modograf);

drawpoly Desenha o contorno de um polígono

drawpoly ( int numpontos, int far *pontos_poli);

ellipse Desenha um arco elíptico

ellipse (int x, int y, int anguloini, int angfim, int xraio, int yraio);
 fillellipse Desenha e preenche uma oval

fillellipse (int x, int y, int xraio, int yraio);

filpoly Desenha e preenche um polígono

fillpoly ( int numpontos, int far *pontos_poli);

floodfill Preenche todo uma região delimitada

floodfill (int x, int y, int limites);

getarccoords Obtém as coordenadas da última chamada para

o arc

getarccoords ( struct arccoordstype far *coords_arco);

getaspectratio Obtém a relação altura/largura para o modo atual

getaspectratio ( int far *xrelacao, int far *yrelacao);

getbkcolor Retorna a cor de fundo atual

getbkcolor (void);

getdefaultpallet Seleciona a definição da estrutura da paleta

getdefaultpallet (void);
getdrivename Aponta para uma string com o controlador

gráfico

getdrivername ( void);

getfillpatern Copia o padrão de preenchimento do usuário

ara a

memória

getfillpattern (char far *padrao);

getfillsettings Obtém informações sobre o padrão de

preenchimento e cor atual

getfillsettings (struct fillsettingstype far *info_preenche);

getgraphmode Retorna o modo gráfico corrente

getgraphmode (void);

getimage Salva a imagem especificada na memória

getimage (int esquerda, int topo, int direita, int base, void far

*mapabits);

getlinesettings Obtém o estilo de linha, padrão e espessura

getlinesettings (struct linesettingstype far *info_linha);

getmaxcolor Retorna o valor máximo que pode ser enviado

para o

setcolor

getmaxcolor (void);

getmaxmode Retorna o valor máximo para o modo para o

controlador

getmaxmode (void);

getmaxx Retorna a máxima coordenada de tela x (em

pixel)

getmaxx (void);

getmaxy Retorna a máxima coordenada de tela y (em

pixel)

getmaxy (void);

getpalette Retorna informações sobre a paleta atual

getpalette (struct palettetype fat *paleta);

getpalletsize Obtém o tamanho da tabela de consulta da

paleta de cores

getpalettesize (void);
getpixel Obtém a cor do pixel especificado

getpixel (int x, int y);

gettextsettings Retorna as informações da fonte do gráfico de

texto atual

gettextsettings ( struct textsettingstype far *infotipotexto);

getviewsettings Retorna o estado do viewport do gráfico

corrente

getviewsettings (struct viewporttype far *viewport);

getx Informa a posição x atual na tela

getx (void);

gety Informa a posição y atual na tela

gety (void);

graphdeaults Reinicializa todos os gráficos com valores

padrões

graphdefaults (void);

grapherrormsg Retorna o ponteiro para string da mensagem

de erro

grapherrormsg ( int cdgerro)

_graphfreemem Oferece uma entrada para desalocação da

memória gráfica

_graphfreemem (void far *ptr, unsigned tamanho);

_graphgetmem Oferece uma entrada para alocação da

memória gráfica

_graphgetmem ( unsigned tamanho);

graphresult Retorna o código de erro da última operação

que falhou

graphresult (void);

imagesize Retorna o número de bytes necessário para

armazenar uma imagem

imagesize ( int esquerda, in topo, int direita, int base);

initgraph Inicializa o sistema gráfico

initgraph(int far contro_graf, int far *modograf, char far

*caminho_controlador);

installuserdrive Instala um controlador fornecido pelo fabricante

installuserdriver(char far nome, int grandao(*detect) (void) );

installuserfonte Instala uma fonte fornecida pelo fabricante

installuserfonte (char far *nome);

line Desenha uma linha

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

linerel Desenha uma linha a uma determinada

distância de um ponto

linerel (int dx, int dy);

lineto Desenha uma linha do ponto atual até o ponto

especificado

lineto (int x, int y);

moveto Move a posição atual até um determinado ponto

moveto (int x, int y);

outtex Exibe uma string no viewport

outtext (cahr far *stringtext);

outtextxy Exibe uma string em uma determinada posição

outtextxy (int x, int y, char far *stringtext);

pieslice Desenha e preenche uma fatia do gráfico

setorial

pieslice (int x, int y, int anguloini, int angfim, int raio);

putimage Saída de bit de imagem para a tela

putimage (int esquerda, int topo, void far *mapabits, int op);

putpixel Coloca um pixel numa determinada posição

putpixel (int x, int y, int cor);

rectangle Desenha um retângulo

rectangle (int esquerda, int topo, int direita, int base);

sector Desenha e preenche uma fatia do gráfico

setorial eliptico

sector (int x, int y, int anguloini, int angulofim, int xraio, int yraio);

setactivepage Inicializa a pagina ativa para a saída gráfica

setactivepage (int pagina);

setallpalette Modifica todas as paletas de cores como

especificado

setallpalette (struct palettetype far *palette);

setaspectratio Modifica a relação altura/largura padrão

setaspectratio (int xrelacao, int yrelacao);

setbkcolor Modifica a cor de fundo

setbkcolor (int cor);

setfillpattern Modifica o padrão de preenchimento

setfillpattern (char far *upadrao, int cor);

setfillstyle Modifica o estilo de preenchimento

setfillstyle (int padrao, int cor);

setgraphbufsize Modifica o tamanho do buffer gráfico

setgraphbufsize (undigned tambuf);

setgraphmode Define o modo gráfico e limpa a tela

setgraphmode (int modo);

setlinestyle Define o tamanho e o estilo da linha

setlinestyle (int estilolinha,unsigned upadrao, int espessura);

setpalette Modifica uma paleta de cor

setpalette (int numcor, int cor);

setrgbpalette Define as cores para a tabela da paleta

setrgbpalette (int numcor, int vermelho, int verde, int azul);

settextjustift Define a justificação de texto para gráficos

settextjustift (int horiz, int vert);

settxtstyle Define as características de texto para gráficos

settxtstyle (int fonte, int direcao, int tamchar);

setusercharsize Define a altura e o tamanho das fonte vetoriais

setusercharsize (int multx, int divx, int multy, int divy);

setviewport Define o tamanho do viewport

setviewport (int esquerda, int topo, int direita, int base, int corte);

setvisualpage Define o número da página visual

setvisualpage (int pagina);

setwritemode Define o modo escrita para o desenho da linha

setwritemode (int modo);

textheight Retorna a altura de uma string em pixel

textheight (char far *stringtexto);

 textwidth Retorna a largura de uma string em pixel

textwidth (char far *stringtexto);

Funções básicas

Exemplo 3:

#include <graphics.h>
#include <stdio.h>
#include <stdlib.h>
#include<dos.h>

void main()
{
int gdriver=DETECT,gmode,errorcode;

initgraph(&gdriver,&gmode,"");
errorcode=graphresult();

if(errorcode)
exit(1);

//Limpa tela
cleardevice();
//Altera cor
setcolor(14);

//arc(int x, int y, int stangle, int endangle, int radius);

arc(20,50,0,90,40);

//bar(int left, int top, int right, int bottom);

bar(70,20,110,40);

//bar3d(int left, int top, int right, int bottom,int depth, int topflag);
bar3d(130,20,170,40,10,10);

//circle(int x, int y, int radius);

circle(220,30,25);

//drawpoly(int numpoints, int far *polypoints);

int poly[10];
poly[0]=270;poly[1]=35;poly[2]=290;poly[3]=8;
poly[4]=315;poly[5]=25;poly[6]=280;poly[7]=50;
//O drawpoly nao fecha o poligono automaticamente
poly[8]=poly[0];poly[9]=poly[1];
drawpoly(5,poly);

//fillpoly(int numpoints, int far *polypoints);

poly[0]=320;poly[1]=35;poly[2]=340;poly[3]=8;
poly[4]=365;poly[5]=25;poly[6]=330;poly[7]=50;
 //O drawpoly nao fecha o poligono automaticamente
poly[8]=poly[0];poly[9]=poly[1];
fillpoly(5,poly);

//ellipse(int x, int y, int stangle, int endangle,int xradius, int yradius);

ellipse(410,30,260,100,50,20);

//fillellipse(int x, int y,int xradius, int yradius);

fillellipse(530,30,50,20);

//line(int x1, int y1, int x2, int y2);

int x,y;
setcolor(getmaxcolor());
x = getmaxx();
y = getmaxy()/3;
line(0,y, x, y);

//moveto(int x, int y);

moveto(x,y);

//lineto(int x, int y);

lineto(320,200);
lineto(0,y);
//outtextxy(int x, int y, char far *textstring);
outtextxy(260,400,"Formas B sicas");

getchar();
//Fecha modo grafico
closegraph();

Fontes

Outro recurso importante é a manipulação de diferentes tipos de fontes

disponíveis na BGI, são elas: "DEFAUL, TRIPLEX, SMALL, SANS SERIF,

GOTHIC". Sendo possível alterar seu tamanho e justificação na tela.

Além dessas fontes existe a possibilidade de se estalar novas fontes.

Exemplo 4

#include <graphics.h>

#include <stdlib.h>

#include <stdio.h>

#include <conio.h>
char *Fontes[] = { "DEFAULT font",
"TRIPLEX font",
"SMALL font",
"SANS SERIF font",
"GOTHIC font"
};

void main()
{
int gdriver = DETECT, gmode, errorcode;
int estilo, x, y, tamanho = 1;

initgraph(&gdriver, &gmode, "");

errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
//Determina o ponto central da tela tanto na horizontal como na vertical
x = getmaxx() / 2;
y = getmaxy() / 2;

// Justifica o texto a partir do ponto x y

settextjustify(CENTER_TEXT, CENTER_TEXT);

for (estilo=DEFAULT_FONT; estilo<=GOTHIC_FONT; estilo++)

 {
cleardevice();
if (estilo == TRIPLEX_FONT)
tamanho = 4;

settextstyle(estilo, HORIZ_DIR, tamanho);

outtextxy(x, y, Fontes[estilo]);
getch();
}

closegraph();

Exemplo de um cubo 3D, rotacionando em seus 3 eixos.

Exemplo 5

#include <stdio.h>
#include <stdlib.h>
#include <dos.h>
#include <conio.h>
#include <math.h>

float cubo[8][3];
int x0,y0,i,j;
//int X=200,Y=300;

struct ram{
int x,y;
}R[1300];

void rotacao(float a,int b,int c);

void cubprop(int x,int y,int tam);
void tracos();

void main()
{

int gdriver=DETECT,gmode,errorcode;
initgraph(&gdriver,&gmode,"..\\bgi");

randomize();
for(i=0;i<1300;i++)
{ R[i].x=random(640);
R[i].y=random(480);
}

cubprop(320,240,35);

setfillstyle(1,9);

while(!kbhit())
{
cleardevice();
for(i=0;i<1300;i++)
 putpixel(R[i].x,R[i].y,15);
setcolor(14);
tracos();

rotacao(0.005,0,1); //rotacona no eixo z / o ultimo parametro nao altera

rotacao(0.01,0,2); //rotacona no eixo y
rotacao(0.01,1,2); //rotacona no eixo x
delay(7);

}
closegraph();
}

void rotacao(float a,int b,int c)

{ int l;
for(l=0;l<8;l++)
{ // se multiplicar muda proporcao se somar obj translada
cubo[l][b] =(cubo[l][b]*cos(a)-cubo[l][c]*sin(a));
cubo[l][c] =(cubo[l][b]*sin(a)+cubo[l][c]*cos(a));
}
}

void cubprop(int x,int y,int tam)

{
cubo[0][0]=-tam; cubo[0][1]=-tam; cubo[0][2]=-tam;
cubo[1][0]=-tam; cubo[1][1]=tam; cubo[1][2]=-tam;
cubo[2][0]=tam; cubo[2][1]=tam; cubo[2][2]=-tam;
cubo[3][0]=tam; cubo[3][1]=-tam; cubo[3][2]=-tam;
cubo[4][0]=tam; cubo[4][1]=-tam; cubo[4][2]=tam;
cubo[5][0]=-tam; cubo[5][1]=-tam; cubo[5][2]=tam;
cubo[6][0]=-tam; cubo[6][1]=tam; cubo[6][2]=tam;
cubo[7][0]=tam; cubo[7][1]=tam; cubo[7][2]=tam;

x0=x,y0=y;
}

void tracos()
{ setcolor(13);
for(i=0;i<7;i+=2) //se i iniciasse com 0 teria linhas do fundo
for(j=1;j<8;j+=2)
if( (i==0&&(j==1||j==3||j==5)) || (i==2&&(j==1||j==3||j==7)) ||
(i==4&&(j==3||j==5||j==7)) || (i==6&&(j==1||j==5||j==7)) )
{
line(x0+((cubo[i][0])-(0.33*cubo[i][2])) ,
y0-((cubo[i][1])-(0.33*cubo[i][2])) ,
x0+((cubo[j][0])-(0.33*cubo[j][2])) ,
y0-((cubo[j][1])-(0.33*cubo[j][2])));
}
}