Ejemplos de Rpogramacion Grafica

Arc
Sintaxis
#include <graphics.h>
void arc(int x, int y, int stangle, int endangle, int radius);

Descripcin.
arc dibuja un arco circular del color de lnea actual centrado en (x,y) con radio dado por radius. El
arco va de stangle to endangle. Si stangle es igual a 0 y endangle igual a 360 la referencia arc
dibuja un crculo completo.

El ngulo para arc se reconoce en sentido contrario a las agujas del reloj, con 0 grados at 3 en
punto, 90 a las 12 en punto, y sucesivamente de esa manera.

El parmetro linestyle no afecta en arco, circulXXXXo, elipses o segmentos curvos (pie slices).
Solamente el parmetro thickness es usado.

Si se ocupa CGA en modo de alta resolucin o un adaptador grafico monocromtico el ejemplo de
ayuda en lnea , que muestra como usar las funciones graficas puede no producir los resultados
esperados. Si el sistema corre en CGA o adaptador monocromtico, se lleva la evaluacin 1 a
aquellas funciones que alteran el color de llenado o delineado
(setcolor, setfillstyle, and setlinestyle, por ejemplo), en lugar de un color constante simblico
(definido en graphics.h).

Valor regresado
Ninguno

Ejemplo
/* ejemplo de arco */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* pedir autodeteccin */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
int stangle = 45, endangle = 135;
int radius = 100;
/* inicializar de variables graficas y locales */
initgraph(&gdriver, &gmode, "");
/* Lectura de los resultados de inicializacin */
errorcode = graphresult();
if (errorcode != grOk) { /* an error occurred */
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* Terminacin con cdigo de error */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor());
/* draw arc */
arc(midx, midy, stangle, endangle, radius);
/* clean up */
getch();
closegraph();
return 0;
}

Barra

Sintaxis
void bar(int left, int top, int right, int bottom);

Descripcin
Barra dibuja una barra bidimensional rellena. El relleno empleado son los parmetros actuales de
patrn de relleno y color de relleno. bar no delinea la barra; para dibujar una barra bidimensional
delineada se empela bar3 con profundidad igual a 0.

Las esquinas superioras izquierda e inferior derecha del rectngulo esta dadas por (left, top) y
(right,bottom), respectivamente. Las coordenadas refieren a los pixeles.

Valor regresado
Ninguno

Example
/* ejemplo de barra*/
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* Pedir autodeteccion */
int midx, midy, i;
/* inicializar variables graficas y locales*/
/* Lectura de los resultados de inicializacin */
getch();
exit(1); /* Terminacin con cdigo de error */
}
/* Enlazar los parmetro de relleno */
for (i=SOLID_FILL; i<USER_FILL; i++) {
/* Establecer el estilo de relleno */
setfillstyle(i, getmaxcolor());
/* dibujar la barra */
bar(midx-50, midy-50, midx+50, midy+50);
getch();
}
/* limpiar */
closegraph();
return 0;
}

Barra 3d

Sintaxis
void bar3d(int left, int top, int right, int bottom, int depth, int
topflag);

Descripcion
bar3d dibuja una barra rectangular tridimensional, despues la rellana con los patrones actuales de
relleno y color de relleno. El delineado de la barra tridimensional se dibuja con el estilo de linea y
color actual.
La barra tiene profundidad en pixeles y esta dada por depth. El parametro topflag gobierna su una
punta tridimensional se coloca en la barra. Si topflag es diferente de cero, un punta se coloca; de
otra manera, en la barra no se colocara la punta (haciendo posible de encajar una varias barras
sobre sus cimas).
Las esquinas superiores izquierda e inferior derecha del rectangulo esta dadas por (left, top) y
(right,bottom), respectivamente.

Para calcular un profundidad tpica de una barra tridimensional, se toma el 25% del ancho de la
barra, por ejemplo: bar3d(left,top,right,bottom, (right-left)/4,1);

Valor regresado
Ninguno.

Ejemplo
/* ejemplo de barra tridimensional */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* Pedir autodeteccion */
int midx, midy, i;
/* inicializar variables graficas y locales */
/* Lectura de los resultados de incializacion */
getch();
exit(1); /* terminacion con codigo de error */
}
/* enlazar los patrones de relleno */
for (i=EMPTY_FILL; i<USER_FILL; i++) {
/* establecer el estilo de relleno */
/* dibujar la barra tridimensional */
bar3d(midx-50, midy-50, midx+50, midy+50, 10, 1);
getch();
}
/* limpiar */
closegraph();
return 0;
}

Circulo

Sintaxis.
void circle(int x, int y, int radius);

Descripcin.
circle dibuja un circulo en el color actual de dibujo con centro en (x,y) y radio dado por radius.
El parmetro linestyle no afecta en arco, circulo, elipses o segmentos curvos (pie slices).
Solamente el parametro thickness es usado.Si el crculo no es completamente Redondo, se ajusta
la proporcion de aspecto.

Valor regresado
Ninguno.

Ejemplo
/* ejemplo de circulo */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* pedir autodeteccion */
int midx, midy, radius = 100;
/* inicializar variables graficas y locales */
/* Lectura de los resultados de incializacin */
if (errorcode != grOk) { /* un error ocurrido */
getch();
exit(1); /* terminacin con cdigo de error */
}
/* dibujar el circulo */
circle(midx, midy, radius);
/* limpiar */
getch();
closegraph();
return 0;
}
Dispositivo de limpieza

Sintaxis
#include >graphics.h<
void cleardevice(void);

Descripcin
cleardevice borra (que es, rellana con el color actual de fondo) la pantalla grafica completa y mueve
el CP (posicin actual ) por defecto a (0,0).

Valor regresado
Ninguno.

Example
/* ejemplo de dispositivo de limpieza */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* pedir autodeteccion*/
int midx, midy;
/* inicializar variables grficas y locales*/
/* lectura de los resultados de incializacin */
getch();
exit(1); /* terminacin con cdigo de error*/
}
/* para centrar mensajes de pantalla */
settextjustify(CENTER_TEXT, CENTER_TEXT);
/* enviar un mensaje a pantalla */
outtextxy(midx, midy, "Press any key to clear the screen:");
getch(); /* wait for a key */
cleardevice(); /* limpiar pantalla */
/* enviar otro mensaje a pantalla */
outtextxy(midx, midy, "Press any key to quit:");
/* limpiar */
getch();
closegraph();
return 0;
}

Limpieza con clic del mouse

Syntax
#include "winbgim.h"
void clearmouseclick(int kind);

Descripcion
La funcion clearmouseclick esta disponible en la librera winbgim de implementacin de grficos BGI.

Esta es igual a getmouseclick, excepto porque no provee las coordenadas x y y del evento.
El valor del argumento kind pueda ser cualquiera de las constantes declaradas arriba. Despus de
invocar getmouseclick, para un tipo de evento particular, ismouseclick wil se volver falso para ese
tipo de evento hasta que otro como tal ocurra.

El argumento kind para clearmouseclick es una de esas constantes de la librera winbgim.h archivo:

WM_MOUSEMOVE
[WIN]
if you want to detect a mouse movement
WM_LBUTTONDBLCLK
...detect when the left mouse button is double clicked
WM_LBUTTONDOWN
...detect when the left mouse button is clicked down
WM_LBUTTONUP
...detect when the left mouse button is released up
WM_MBUTTONDBLCLK
...detect when the middle mouse button is double clicked
WM_MBUTTONDOWN
...detect when the middle mouse button is clicked down
WM_MBUTTONUP
...detect when the middle mouse button is released up
WM_RBUTTONDBLCLK
...detect when the right mouse button is double clicked
WM_RBUTTONDOWN
...detect when the right mouse button is clicked down
WM_RBUTTONUP
...detect when the right mouse button is released up

Ejemplo
/* limpieza con clic del mouse */
void main(void)
{
const int LIMIT = 10; // Numero de clicks para detener el programa.
int maxx, maxy; // Coordenadas de pixeles mximos en x y y
int count = 0; // numero de clicks
int divisor; // Divisor para el largo de un lado del triangulo
// Colocar la maquina dentro del modo grafico y obtener el maximo de coordenadas
initwindow(450, 300);
maxx = getmaxx( );
maxy = getmaxy( );
//Dibujar un circulo blanco con rojo dentro y radio de 50 pixeles:
setfillstyle(SOLID_FILL, RED);
setcolor(WHITE);
fillellipse(maxx/2, maxy/2, 50, 50);
// Imprimir mensaje y espera para un pixel rojo para darle doble click settextstyle(DEFAULT_FONT,
HORIZ_DIR, 2);
outtextxy(20, 20, "Left click " << LIMIT << " times to end.");
setcolor(BLUE);
divisor = 2;
while (count < LIMIT)
{
triangle(maxx/divisor, maxy/divisor);
delay(500);
divisor++;
if (ismouseclick(WM_LBUTTONDOWN))
{
clearmouseclick(WM_LBUTTONDOWN));
count++;
}
}
// Regresar al modo de texto:
closegraph( );
}

clearviewport

Sintaxis
void clearviewport(void);

Descripcion
clearviewport borra el viewport y mueve CP (posicion actual) a por defecto (0,0), relativo a
viewport.

Valor regresado
Ninguno.

Ejemplo
/* ejemplo de clearviewport */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#define CLIP_ON 1 /* activar el recorte en viewport */
int main(void)
{
int gdriver = DETECT, gmode, errorcode, ht;
/* inicializar variables grficas y locales */
getch();
}
ht = textheight("W");
/* mensaje por defecto en la pantalla complete de viewport */
outtextxy(0, 0, "* <-- (0, 0) in default viewport");
/* crear un viewport mas pequeo */
setviewport(50, 50, getmaxx()-50, getmaxy()-50, CLIP_ON);
/* mostrar algunos mensajes por pantalla */
outtextxy(0, 0, "* <-- (0, 0) in smaller viewport");
outtextxy(0, 2*ht, "Press any key to clear viewport:");
getch(); /* esperar por una tecla */
clearviewport(); /* clear the viewport */
/* mandar otro mensaje */
outtextxy(0, 0, "Press any key to quit:");
/* limpieza */
getch();
closegraph();
return 0;
}

Cerrar grafico

Sintaxis
void closegraph(void);

Descripcion
closegraph desasigna toda la memoria asignada por el sistema de graficos, despues restaura la
pantalla al modo en que estaba antes de invocar initigraph.(El sistema grafico desasigna memoria tal
como los drivers, Fuentes y buffer interno por medio de la invocacion
_graphfreemem.)

Valor regresado
Ninguno

Example
/* ejemplo de cerrar grafico */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int gdriver = DETECT, gmode, errorcode, x, y;
/* incializar modo grafico */
getch();
}
x = getmaxx() / 2;
y = getmaxy() / 2;
/* output a message */
outtextxy(x, y, "Press a key to close the graphics system:");
getch(); /* wait for a key */
/* cierra el sistema grafico */
closegraph();
printf("We're now back in text mode.\n");
getch();
return 0;
}

Retardo

Sintaxis
void delay(int millisec);

Descricion

La function delay esta disponible en la liberia winbgim implementacion de graficos BGI. No es
necesario incluir conio.h; solamente incluir winbgim.h. La funcion pausa la computacion por el
numero de milisegundos especificados.

Valor regresado
Ninguno

Ejemplo
/* ejemplo de retardo */
int main(void)
{
int midx, midy, i;
/* Inciar el tamo de ventana */
initwindow(100, 100);
/* Enlazar los patrones de relleno con 4 segundos de retardo */
for (i=SOLID_FILL; i<USER_FILL; i++) {
/* establecer es estilo de relleno*/
/* dibujar la barra */
bar(midx-50, midy-50, midx+50, midy+50);
delay(4000);
}
/* limpiar */
closegraph();
return 0;
}

Detectar grafico

Sintaxis
void detectgraph(int *graphdriver, int *graphmode);

Descripcion
detectgraph detecta el adapatadorgrafico de tu sistema y escoge el modo que prove la mayor
resolucion para ese adaptador. Si no se detecta un hardawer grafico, *graphdriver se establece en
grNotDetected (-2), y graphresult regresa grNotDetected (-2).
*graphdriver es un entero que especifica el driver grafico que se empleara. Se puede darle valor
usando una constente de tipo enumeracion de graphics_drivers definida en graphics.h y se en lista:
graphics_drivers Valores constantes numericos:

DETECT 0 (pedir autodeteccion)
CGA 1
MCGA 2
EGA 3
EGA64 4
EGAMONO 5
IBM8514 6
HERCMONO 7
ATT400 8
VGA 9
PC3270 10
*graphmode es un etero que especifica el modo grafico incial (almenos que *graphdriver sea igual a
DETECT; en cuyo caso, *graphmode se establece con la maxima resolucion para el sistema
encontrado). Se puede darle valor usando una constente de tipo enumeracion de graphics_mdes
definida en graphics.h y se en lista:

Columnas Graficas
Driver graphics_mode Value x Rows Palette Pages
CGA CGAC0 0 320 x 200 C0 1
CGAC1 1 320 x 200 C1 1
CGAC2 2 320 x 200 C2 1
CGAC3 3 320 x 200 C3 1
CGAHI 4 640 x 200 2 color 1
MCGA MCGAC0 0 320 x 200 C0 1
MCGAC1 1 320 x 200 C1 1
MCGAC2 2 320 x 200 C2 1
MCGAC3 3 320 x 200 C3 1
MCGAMED 4 640 x 200 2 color 1
MCGAHI 5 640 x 480 2 color 1
EGA EGALO 0 640 x 200 16 color 4
EGAHI 1 640 x 350 16 color 2
EGA64 EGA64LO 0 640 x 200 16 color 1
EGA64HI 1 640 x 350 4 color 1
EGA-MONO EGAMONOHI 3 640 x 350 2 color 1 w/64K
EGAMONOHI 3 640 x 350 2 color 2 w/256K
HERC HERCMONOHI 0 720 x 348 2 color 2
ATT400 ATT400C0 0 320 x 200 C0 1
ATT400C1 1 320 x 200 C1 1
ATT400C2 2 320 x 200 C2 1
ATT400C3 3 320 x 200 C3 1
ATT400MED 4 640 x 200 2 color 1
ATT400HI 5 640 x 400 2 color 1
VGA VGALO 0 640 x 200 16 color 2
VGAMED 1 640 x 350 16 color 2
VGAHI 2 640 x 480 16 color 1
PC3270 PC3270HI 0 720 x 350 2 color 1
IBM8514 IBM8514HI 0 640 x 480 256 color ?
IBM8514LO 0 1024 x 768 256 color ?
Nota: La razon principal de la invocacion detectgraph directamente es para anular el modo grafico
que detectgraph recominedo para initgraph.

Valor regresado
Ninguno
.
Notas de la Windows
La version winbgim de detectgraph regresa VGA para graphdriver y VGAHI para
graphmode, a pesar del hardaware de la maquina. Sin embargo, no es necesariamente 640x 480.

Ejemplo
/* ejemplo de detector grafico */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* nombres de varias tarjetas soportadas */
char *dname[] = { "requests detection",
"a CGA",
"an MCGA",
"an EGA",
"a 64K EGA",
"a monochrome EGA",
"an IBM 8514",
"a Hercules monochrome",
"an AT&T 6300 PC",
"a VGA",
"an IBM 3270 PC"
};
int main(void)
{
/* usado para regresar la informacion detectada del hardware. */
int gdriver, gmode, errorcode;
/* detecta el hardaware grafico disponible */
detectgraph(&gdriver, &gmode);
/* Lectura de los resultados de la invocacion detectgraph */
[WIN]
getch();
exit(1); /* termnacion con codigo de error */
}
/* mostrar la informacion detectada */
clrscr();
printf("You have %s video display card.\n", dname[gdriver]);
getch();
return 0;
}

Dibujar poligono

Sintaxis
void drawpoly(int numpoints, int *polypoints);

Descripcion
drawpoly dibuja un poligono con puntos numpoints ,usando el estilo actual de linea y color.

*polypoints puntos a una secuencia (numpoints * 2) de enteros . Cada par de enteros da las
coordenas x,y de un punto en el poligono.De manera que para dibujar una figura cerrada con n
vertices, se debe poner n+1 coordenadas para drawpoly donde la n-esima coordenada es igual a la
0.

Valor regresado
Ninguno

Ejemplo
/* ejemplo de dibujar poligono */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int maxx, maxy;
int poly[10]; /* our polygon array */
if (errorcode != grOk){ /* un error ocurrido */
getch();
}
maxx = getmaxx();
maxy = getmaxy();
poly[0] = 20; /* primer vertice */
poly[1] = maxy / 2;
poly[2] = maxx - 20; /* segundo vertice */
poly[3] = 20;
poly[4] = maxx - 50; /* tercer vertice */
poly[5] = maxy - 20;
poly[6] = maxx / 2; /* cuarto vertice */
poly[7] = maxy / 2;
poly[8] = poly[0]; /* drawpoly no cierra automaticamente */
poly[9] = poly[1]; /* el poligono, asi que nosotros lo cerramos */
drawpoly(5, poly); /* dibujar el poligono */
/* limpiar*/
getch();
closegraph();
return 0;
}

Elipse

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

Descripcion
ellipse dibuja un arco eliptico en el color actual de dibujo con centro en (x,y) y las aberturas
horizontales y verticales dadas por xradius y yradius, respectivamente. La elipse viaja de
stangle to endangle. Si stangle es igual a 0 y endangle igual a 360, la invocacion ellipse dibujara
una elipse completa.

El angulo para elipses es reconocido en sentido contrario a las manecillas del reloj, con 0 grados en
3 en punto , 90 grados en 12 en puntos y asi consecutivamente.

El parametro linestyle no afecta arcos, circulos, elipses, segmentos curvos or pie slices.
Solamente el parametro thickness es usado

Valor regresado
Ninguno

Ejemplo
/* ejemplo de elipse */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int midx, midy;
int xradius = 100, yradius = 50;
/* inicializar variables grficas y locales*/
/* lectura de los resultados de incializacin*/
getch();
}
/* dibujar elipse */
ellipse(midx, midy, stangle, endangle, xradius, yradius);
/* limpiar */
getch();
closegraph();
return 0;
}

Elipse rellena

Sintaxis
void fillellipse(int x, int y, int xradius, int yradius);

Descripcion
Dibuja una elipe usando (x,y) como punto central y radio xradius y yradius para las aberturas
horizontales y verticales, se rellena con el color y parametro actual.

Valor regresado
Ninguno

Ejemplo
/* ejemplo de elipse rellena */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* pedir autodeteccion*/
int midx, midy, i;
int xradius = 100, yradius = 50;
/* lectura de los resultados de incializacin*/
if (errorcode != grOk) { /* un error ocurrido*/
getch();
}
for (i = EMPTY_FILL; i < USER_FILL; i++) {
/* establecer el parametro de relleno */
/* dibujar elipse rellena */
fillellipse(midx, midy, xradius, yradius);
getch();
}
/* limpiar */
closegraph();
return 0;
}

Poligono relleno

Sintaxis
void fillpoly(int numpoints, int *polypoints);

Descripcion
fillpoly dibuja el delineado de un poligono con puntos numpoints en el estilo actual de linea y color
(tal como drawpoly lo hace),despues rellena el poligono usando los parametros actuales de relleno y
color.

*polypoints puntos a una secuencia (numpoints * 2) de enteros . Cada par de enteros da las
coordenas x,y de un punto en el poligono

Valor regresado
Ninguno.

Ejemplo
/* ejemplo de poligono relleno */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int i, maxx, maxy;
/* nuestro arreglo del poligono */
int poly[8];
getch();
}
maxx = getmaxx();
maxy = getmaxy();
poly[0] = 20; /* primer vertice */
poly[1] = maxy / 2;
poly[2] = maxx - 20; /* segundo vertice */
poly[3] = 20;
poly[4] = maxx - 50; /* tercer vertice */
poly[5] = maxy - 20;
poly[6] = maxx / 2; /* cuarto, fillpoly automaticamente */
poly[7] = maxy / 2; /* cierra el poligono */
for (i=EMPTY_FILL; i<USER_FILL; i++) {
/* establecer el parametro de relleno */
/* dibujar poligono relleno */
fillpoly(4, poly);
getch();
}
/* limpiar */
closegraph();
return 0;
}

Floodfill

Sintaxis
void floodfill(int x, int y, int border);

Descripcion
floodfill frellena un area cerrada en un dispositivo de bitmap. (x,y) es un punto de semilla dentro del
area cerrada a ser rellenada. El area resaltada por el color del borde es rellena con el parametro de
color y relleno actual. Si el punto semilla esta dentro de un area encerrada, el interior sera relleno.
Si la semilla esta fuera del area encerrada, el exterior se rellenara.

Se emplea fillpoly en lugar de floodfill siempre que sea posible de esa manera se mantiene un
codigo de compartibilidad con versiones futuras. Floodfill no trabaja con IBM-8514 driver.

Valor Regresado
Si un error ocurre mientras se rellena una region, el resultado grafico regresa un valor de -7

Notas de Windows [WIN
La version de winbgim permite al argumento del borde ser de un color ordinario BGI(de 0 a 15) o un
color RGB

Ejemplo
/* ejemplo de relleno */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int maxx, maxy;
/* read result of initialization */
getch();
}
maxx = getmaxx();
maxy = getmaxy();
/* sleccionar color del dibujo */
/* seleccionar color de relleno */
setfillstyle(SOLID_FILL, getmaxcolor());
/* dibujar borde alrededor de la pantalla */
rectangle(0, 0, maxx, maxy);
/* dibujar algunos circulos */
circle(maxx / 3, maxy /2, 50);
circle(maxx / 2, 20, 100);
circle(maxx-20, maxy-50, 75);
circle(20, maxy-20, 25);
/* espera por una tecla */
getch();
/* rellenar la region resaltada */
floodfill(2, 2, getmaxcolor());
/* limpiar */
getch();
closegraph();
return 0;
}

Obtener pagina activa

Sintaxis
int getactivepage(void);

Descripcion
La funcin getactivepage esta disponible en la implemntacion de BGI graficos winbgim.
getactivepage obtiene el numero de la pagina actual en actividad (donde se encuentra el dibujo). La
pagina activa puede no ser la que ves en la pantalla, dependiendo de cuantas paginas graficas esten
disponibes en el sistema.

Wingbig original fue diseado para soportar 16 paginas, pero solamente se han usado las paginas 1
y 2.
NOTA: usar la pagina 0 podria mezclar los colores.

Valor regresado
El numero de la pagina actual en actividad.

Obtener coordenadas del arco

Sintaxis
void getarccoords(struct arccoordstype *arccoords);
[WIN]

Descripcion
getarccoords rellena la estructura arccoordstype sealada por arccoords con la informacion sobre la
ultima invocacion de arco. La estructura arccoordstype esta definida en graphics.h como:

struct arccoordstype {
int x, y;
int xstart, ystart, xend, yend;
};

Los miembros de esta estructura son usados para especificar el punto central (x,y), la posicion incial
(xstart, ystart), y la posicion final (xend, yend) del arco. Estos valores son utiles si necesitas hacer
encontrar una linea con el final de un arco.

Valor regresado
Ninguno.

Ejemplo
/* ejemplo de obtener coordenadas del arco */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* pedir autodeteccin*/
struct arccoordstype arcinfo;
int midx, midy;
char sstr[80], estr[80];
getch();
}
/* dibujar arco y obtener coordenadas*/
arc(midx, midy, stangle, endangle, 100);
getarccoords(&arcinfo);
/* convertir la informacion del arco en cadenas */
sprintf(sstr, "*- (%d, %d)", arcinfo.xstart, arcinfo.ystart);
sprintf(estr, "*- (%d, %d)", arcinfo.xend, arcinfo.yend);
/* enviar la informacion del arco */
outtextxy(arcinfo.xstart, arcinfo.ystart, sstr);
outtextxy(arcinfo.xend, arcinfo.yend, estr);
/* limpiar */
getch();
closegraph();
return 0;
}

Getaspectration

Sintaxis
void getaspectratio(int *xasp, int *yasp);

Descripcin
El factor y aspect, *yasp, esta normalizado de 10,000. Para todos los adaptadores graficos excepto el VGA,
*xasp (el facto x aspect) es menor que *yasp porque los pixeles son mas altos que anchos. Para VGA, que
tiene pixeles "cuadrados", *xasp es igual a *yasp. En general, la relacin entre *yasp y *xasp puede
presentarse como:
*yasp = 10,000
*xasp <= 10,000
getaspectratio obtiene los valores en *xasp y *yasp.

Valor regresado
Ninguno.

Ejemplo
/* Ejemplo de getaspectratio */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
main()
{
int xasp, yasp, midx, midy;
if (errorcode != grOk) { /* error ocurrido */
getch();
}
/* obtener configuraciones actuales de radio */
getaspectratio(&xasp, &yasp);
/* dibujar un circulo normal */
circle(midx, midy, 100);
getch();
/* dibujar un circulo ancho */
cleardevice();
setaspectratio(xasp/2, yasp);
getch();
/* dibujar un circulo angosto */
cleardevice();
setaspectratio(xasp, yasp/2);
/* limpiar */
getch();
closegraph();
return 0;
}
Obtener el color de fondo

Sintaxis
int getbkcolor(void);

Descripcin
getbkcolor regresa el color actual del fondo (ver la tabla en establecer color de fondo para mas
detalles).

Valor regresado
regresa el color actual del fondo

Notas de Windows [WIN]
En la version winbgim,el usuario podia establecer el color del fondo en RGB. Por lo tanto el valor
regresado de getbkcolor podia ser un color ordinario de BGI (entero del 0 a 15) o un color

Ejemplo
/* Ejemplo de getbkcolor */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int bkcolor, midx, midy;
char bkname[35];
getch();
}
/* Para centrar el texto en la pantalla */
/* get the current background color */
bkcolor = getbkcolor();
/* Convertir el valor del color en cadenas */
itoa(bkcolor, bkname, 10);
strcat(bkname, " is the current background color.");
/* Mostrar el mensaje por pantalla */
outtextxy(midx, midy, bkname);
/* limpiar */
getch();
closegraph();
return 0;
}

Getch

Sintaxis
int getch(void);

Descripcin
La funcion getch esta disponible en la implementacion de graficos BGI winbgim. No es necesario
incluir conio.h; solamente winbgim.h. La funcion lee un caracter proviniente del teclado y regrega un
valor ASCII (sin esperar por el regreso de una tecla). Para trabajar, el usuario debe hacer click en la
ventana grafica (por ejemplo, el enfoque de Windows debe estar en la ventana de graficos ). Para
teclas especiales, la funcion getch primero regresa el 0 ASCII. La siguiente invocaion regresa una de
esas teclas especiales:

#define KEY_HOME 71
#define KEY_UP 72
#define KEY_PGUP 73
#define KEY_LEFT 75
#define KEY_CENTER 76
#define KEY_RIGHT 77
#define KEY_END 79
#define KEY_DOWN 80
#define KEY_PGDN 81
#define KEY_INSERT 82
#define KEY_DELETE 83
#define KEY_F1 59
#define KEY_F2 60
#define KEY_F3 61
#define KEY_F4 62
#define KEY_F5 63
#define KEY_F6 64
#define KEY_F7 65
#define KEY_F8 66
#define KEY_F9 67

Valor regresado
El valor ASCII de la tecla presionada

Ejemplo
#include <stdio.h> // Provee sprintf
#include <iostream.h> // Provides cout
void outintxy(int x, int y, int value);
int main( )
{
int i;
char c;
// incializa la ventana grafica.
init_window(400, 300);
// Convierte algunos numero a cadenas y los dibuja la ventana de graficos
outtextxy(10, 10, "Here are some numbers:");
for (i = 10; i <= 100; i += 10)
outintxy(20, i+10, i);
// obtiene algunos caracteres del teclado, hasta que se presiona x:
outtextxy(20, 130, "Click in this graphics window,");
outtextxy(20, 140, "and then press arrow keys.");
outtextxy(20, 150, "Watch the console window while pressing.");
outtextxy(20, 160, "Press X to exit.");
do
{
c = (char) getch( );
if (c != 0)
cout << "That is ASCII value: " << (int) c << endl;
else
{ // Proceso para tecla especial
c = (char) getch( );
switch (c)
{
case KEY_HOME: cout << "Home key." << endl; break;
case KEY_UP: cout << "Up key." << endl; break;
case KEY_PGUP: cout << "PgUp key." << endl; break;
case KEY_LEFT: cout << "Left key." << endl; break;
case KEY_CENTER: cout << "Center key." << endl; break;
case KEY_RIGHT: cout << "Right key." << endl; break;
case KEY_END: cout << "End key." << endl; break;
case KEY_DOWN: cout << "Down key." << endl; break;
case KEY_PGDN: cout << "PgDn key." << endl; break;
case KEY_INSERT: cout << "Insert key." << endl; break;
case KEY_DELETE: cout << "Delete key." << endl; break;
case KEY_F1: cout << "F1 key." << endl; break;
default: cout << "Unknown extended key." << endl;
}
}
} while ((c != 'x') && (c != 'X'));
closegraph( );
}
void outintxy(int x, int y, int value)
{
char digit_string[20];
sprintf(digit_string, "%d", value);
outtextxy(x, y, digit_string);
}

Obtener color

Sintaxis
int getcolor(void);

Descripcin
getcolor regresa el color actual del dibujo. El color del dibujo es el valor para elc ual los pixeles estan
estableciondos cuando lineas y otras son dibujadas. Por ejemplo, en el modo CGAC0, la paleta
contiene cuatro coles: el color de fondo, verde claro, rojo claro y amraillo. En este modo, getcolor
regresa1, el color actual del color es verde claro.

Valor regresado
El color actual del dibujo

Notas de Windows
En la version winbgim version, el usuario podia establecer el color del dibujo de un color RGB. Por o
tanto el valor regresado de getcolor podira ser un color ordinario BGI (entero de 0 a 15) o un color
RGB

Ejemplo
/* Ejemplo de getcolor */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
[WIN]
int color, midx, midy;
char colname[35];
getch();
}
/* centrar texto en la pantalla*/
/* obtener el color de dibujo actual */
color = getcolor();
/* convertir el valor del color en cadena */
itoa(color, colname, 10);
strcat(colname, " is the current drawing color.");
/* mostrar mensaje por patalla*/
outtextxy(midx, midy, colname);
/* limpiar */
getch();
closegraph();
return 0;
}

Obtener paleta por defecto

Sintaxis
struct palettetype *getdefaultpalette(void);

Descripcin
getdefaultpalette encuentra la estructura del tipo de paleta que contiene la paleta inicializada por el
driver durante el arranque.

Valor regresado
getdefaultpalette regresa un apuntador a la paleta instalada por defecto en el actual driver cuando
este fue inciado

Ejemplo
/* Ejemplo de getdefaultpalette */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* apuntador a la estructura de la paleta */
struct palettetype *pal = NULL;
int i;
getch();
}
/* regresa el apuntador a la paleta por defecto */
pal = getdefaultpalette();
for (i=0; i<pal->size; i++) {
printf("colors[%d] = %d\n", i, pal->colors[i]);
getch();
}
/* limpiar */
getch();
closegraph();
return 0;
}

Obtener el nombre del driver

Sintaxis
char *getdrivername(void);

Descripcin
Despues invocar initgraph, getdrivername regresa el nombre del driver que esta actualmente
cargado.

Valor regresado
getdrivername regresa un puntero a una cadena con el nombre del driver de graficos cargado
actualmente.

Notas de Windows
La version getdrivername de winbgim regresa "EGAVGA" para el nombre del driver, a pesar de la
manera en que se llame initgraph.

Ejemplo
/* Ejemplo de obtner nombre del driver */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main()
{
/* almacena el nombre del diver */
char *drivername;
getch();
}
/* pone el nombre del driver en uso */
drivername = getdrivername();
/* centra el texto sobre la pantalla */
/* mostrar en nombre del driver */
outtextxy(getmaxx() / 2, getmaxy() / 2, drivername);
/* limpiar */
getch();
[WIN]
closegraph();
return 0;
}

Obtener el patron de relleno

Sintaxis
void getfillpattern(char *pattern);

Descripcin
getfillpattern copia el patron de relleno definido por el usuario, puesto en setfillpatter, dentro de un
area de 8 bytes apuntada por un patron.

Patron es un apuntador a una secuancia de 8 bits, con cada correspondiente a 8 pixeles en el
patron. Cuando un bit en un patron del byte es puesto en 1, el pixel correspondiente sera el
argumento.

Por ejemplo, el siguiente patron de relleno definido por el usuario representa un tablero de damas
char checkboard[8] = {
0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55
};

Valor regresado
Ninguno

Ejemplo
/* getfillpattern Ejemplo */ #include <graphics.h> #include <stdlib.h> #include <stdio.h>
#include <conio.h> int main(void) { /* pedir autodeteccin */ int gdriver = DETECT,
gmode, errorcode; int maxx, maxy; char pattern[8] = {0x00, 0x70, 0x20, 0x27, 0x25, 0x27,
0x04, 0x04}; /* inicializar variables grficas y locales */ initgraph(&gdriver, &gmode, ""); /*
lectura de los resultados de incializacin */ errorcode = graphresult(); if (errorcode != grOk) { /* an
error
occurred */ printf("Graphics error: %s\n", grapherrormsg(errorcode)); printf("Press any key
to halt:"); getch(); exit(1); /* terminacin con cdigo de error */ } maxx = getmaxx(); maxy =
getmaxy(); setcolor(getmaxcolor()); /* seleccionar un patron definido por el usuario */
setfillpattern(pattern, getmaxcolor()); /* fill the screen with the pattern */ bar(0, 0, maxx,
maxy); getch(); /* obtener el actual patron definido por el usuario */ getfillpattern(pattern); /* alter
the pattern we grabbed */ pattern[4] -= 1; pattern[5] -= 3; pattern[6] += 3; pattern[7] -= 4; /*
seleccionar nuestro nuevo patron*/ setfillpattern(pattern, getmaxcolor()); /* llenar la pantalla con el
nuevo patron*/ bar(0, 0, maxx, maxy); /* limpiar */ getch(); closegraph(); return 0; }

Obtener configuracion de relleno

Sintaxis
void getfillsettings(struct fillsettingstype *fillinfo);

Descripcin
getfillsettings llena la estructura fillsettingstype apuntada por fillinfo con iformacion acerca del patron
actual de relleno y color. La estructura de fillsettingstype esta definida en
graphics.h como:

struct fillsettingstype {
int pattern; /* current fill pattern */
int color; /* current fill color */
};

La barra de funciones, bar3d, fillpoly, floodfill, y pieslice llenan un area con los parametros actuales
de relleno y color.Hay 11 estilos predefinidos de parametros (tales como solido, sombreado,
punteado y consecutivamente). Nombres simbolicos para los patrones predefinidos son dados por el
tipo enumerado fill_patterns en graphics.h, como se muestra aqui:

Descripcin del valor del nombre
EMPTY_FILL 0 Fill with background color
SOLID_FILL 1 Solid fill
LINE_FILL 2 Fill with ---
LTSLASH_FILL 3 Fill with ///
SLASH_FILL 4 Fill with ///, thick lines
BKSLASH_FILL 5 Fill with \\\, thick lines
LTBKSLASH_FILL 6 Fill with \\\
HATCH_FILL 7 Light hatch fill
XHATCH_FILL 8 Heavy crosshatch fill
INTERLEAVE_FILL 9 Interleaving line fill
WIDE_DOT_FILL 10 Widely spaced dot fill
CLOSE_DOT_FILL 11 Closely spaced dot fill
USER_FILL 12 User-defined fill pattern
Note: All but EMPTY_FILL fill with the current fill color; EMPTY_FILL uses the current
background color. In addition, you can define your own fill pattern. If pattern equals 12
(USER_FILL), then a user-defined fill pattern is being used; otherwise, pattern gives the
number of a predefined pattern.

Valor regresado
Ninguno

Notas de Windows
En la version winbgim, el usuario podia establecer el relleno del color con un color RGB. A pesar de
que el color en la estructura fillsettingstype podia ser un color ordinario BGI (entero de 0 a 15) o un
color RGB

Ejemplo
/* getfillsettings Ejemplo */
#include
#include
#include
#include
/* the names of the fill styles supported */
char *fname[] = { "EMPTY_FILL", "SOLID_FILL", "LINE_FILL", "LTSLASH_FILL",
"SLASH_FILL", "BKSLASH_FILL", "LTBKSLASH_FILL", "HATCH_FILL",
"XHATCH_FILL", "INTERLEAVE_FILL", "WIDE_DOT_FILL", "CLOSE_DOT_FILL",
"USER_FILL" };
int main(void)
{
struct fillsettingstype fillinfo;
int midx, midy;
char patstr[40], colstr[40];
getch();
}
/* obtener la informacion acerca del patron actual de relleno y color */
getfillsettings(&fillinfo);
/* convertir la informacion de relleno en cadena */
sprintf(patstr, "%s is the fill style.", fname[fillinfo.pattern]);
sprintf(colstr, "%d is the fill color.", fillinfo.color);
/* mostrar la informacion por pantalla */
outtextxy(midx, midy, patstr);
outtextxy(midx, midy+2*textheight("W"), colstr);
/* limpiar */
getch();
closegraph();
return 0;
}

Obtener modo grafico

Sintaxis
int getgraphmode(void);

Descripcin
El programa debe de hacer una invocacion exitosa a inithgraph antes de invocar getgraphmode.

La numeracion graphics_mode, definida en graphics.h, dar los nombres para los modos graficos
predeterminados. Para enlistar una tabla esos valores de enumeracion refieren al de la descripcion
de initgraph

Valor regresado
getgraphmode regresa el modo grafico establecido por turns initgraph o setgraphmode.

Notas de Windows
La version de getgraphmode de winbgim regresa VGAHI para graphmode, a pesar de como se
invocara initgraph .Sin embargo, la pantalla no es necesariamente 640 x 480.

Ejemplo
/* getgraphmode Ejemplo */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int midx, midy, mode;
char numname[80], modename[80];
[WIN]
getch();
}
/* obtener cadenas del modo de numero y nombre*/
mode = getgraphmode();
sprintf(numname, "%d is the current mode number.", mode);
sprintf(modename, "%s is the current graphics mode.",
getmodename(mode));
/* mostrar la informacion por pantalla */
outtextxy(midx, midy, numname);
outtextxy(midx, midy+2*textheight("W"), modename);
/* limpiar */
getch();
closegraph();
return 0;
}

Obtener imagen

Sintaxis
void getimage(int left, int top, int right, int bottom, void *bitmap);

Descripcin
getimage copa una imagen de la memoria de la pantalla. Izquierda, arriba,derecha, y abajo definen
el area de la pantall de la cual se copiara el rectangulo. Se coloca en puntos de mapa de bits el area
de la memoria donde el bit de la imagen sera almacenado. Las primera dos palabras de esta son
usadas por el ancho y alto del rectangulo; los restantes permanecen a la imagen misma.

Valor regresado
Ninguno.

Ejemplo
/* Ejemplo de obtener imagen */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
void save_screen(void *buf[4]);
void restore_screen(void *buf[4]);
int maxx, maxy;
int main(void)
{
int gdriver=DETECT, gmode, errorcode;
void *ptr[4];
/* Auto detectar el modo y driver grafico */
errorcode = graphresult(); /* check for any errors */
if (errorcode != grOk) {
getch();
exit(1);
}
maxx = getmaxx();
maxy = getmaxy();
/* dibujar una imagen en la pantalla */
rectangle(0, 0, maxx, maxy);
line(0, 0, maxx, maxy);
line(0, maxy, maxx, 0);
save_screen(ptr); /* save the current screen */
getch(); /* pause screen */
cleardevice(); /* clear screen */
restore_screen(ptr); /* restore the screen */
getch(); /* pause screen */
closegraph();
return 0;
}
void save_screen(void *buf[4])
{
unsigned size;
int ystart=0, yend, yincr, block;
yincr = (maxy+1) / 4;
yend = yincr;
/* obtiene el tamao de byte de la imagen */
size = imagesize(0, ystart, maxx, yend);
for (block=0; block<=3; block++) {
if ((buf[block] = farmalloc(size)) == NULL) {
closegraph();
printf("Error: not enough heap space in save_screen().\n");
exit(1);
}
getimage(0, ystart, maxx, yend, buf[block]);
ystart = yend + 1;
yend += yincr + 1;
}
}
void restore_screen(void *buf[4])
{
int ystart=0, yend, yincr, block;
yincr = (maxy+1) / 4;
yend = yincr;
for (block=0; block<=3; block++) {
putimage(0, ystart, buf[block], COPY_PUT);
farfree(buf[block]);
ystart = yend + 1;
yend += yincr + 1;
}
}

Obtener la configuracin de lneas

Sintaxis
void getlinesettings(struct linesettingstype *lineinfo);

Descripcin
getlinesettings llena la estructura linesettingstype apuntada por lineinfo con informacin acerca del
estilo actual, patrones y espesor.

La estructura linesettingstype esta definida en graphics.h como:
struct linesettingstype {
int linestyle;
unsigned upattern;
int thickness;
};

linestyle especifica en cual estilo las lneas subsecuentes era dibujadas (como solido,sombreado,
punteado, centrado). La numeracin line_styles, definida en graphics.h, le da nombres a los
siguientes operadores:

Valor del nombre de descripcin

SOLID_LINE 0 Solid line
DOTTED_LINE 1 Dotted line
CENTER_LINE 2 Centered line
DASHED_LINE 3 Dashed line
USERBIT_LINE 4 User-defined line style
Espesor especifica si el ancho de las lneas subsecuentes ser normal o espeso.

Descripcin del valor del nombre
NORM_WIDTH 1 1 pixel wide
THICK_WIDTH 3 3 pixels wide

Valor regresado
Ninguno

Ejemplo
/* Ejemplo de obtener la configuracin de lneas*/
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* nombres de los estilos de lnea soportados */
char *lname[] = { "SOLID_LINE", "DOTTED_LINE", "CENTER_LINE",
"DASHED_LINE", "USERBIT_LINE" };
int main(void)
{
/* pedir auto deteccin */
struct linesettingstype lineinfo;
int midx, midy;
char lstyle[80], lpattern[80], lwidth[80];
/* lectura de los resultados de inicializacin */
getch();
}
/* obtener la informacion acerca del configuracin actual */
getlinesettings(&lineinfo);
/* convertir la informacin de la lnea en cadenas */
sprintf(lstyle, "%s is the line style.", lname[lineinfo.linestyle]);
sprintf(lpattern, "0x%X is the user-defined line pattern.",
lineinfo.upattern);
sprintf(lwidth, "%d is the line thickness.", lineinfo.thickness);
/* mostrar la informacin por pantalla */
outtextxy(midx, midy, lstyle);
outtextxy(midx, midy+2*textheight("W"), lpattern);
outtextxy(midx, midy+4*textheight("W"), lwidth);
/* limpiar */
getch();
closegraph();
return 0;
}

Obtener maximo de color

Sintaxis
int getmaxcolor(void);

Descripcin
getmaxcolor regresa al color validos mas alto para el actual driver grafico y modo que puede pasar a
setcolor.

Por ejemplo, en un 256K EGA, getmaxcolor siempre regresa 15, lo cual significa que cualquier
invocacin a setcolor con un valor de 0 a 15 es valido. En CGA en modo de alta resolucin o en un
adaptador mono cromado Hrcules, getmaxcolor regresa el valor de 1.

Notas de Windows
La versin getmaxcolor de winbgim regresa 15 para el color mximo. Sin embargo, en adicin a los
colores BGI usuales (0 al 15), el programado puede tambin usar colores RGB.

Valor regresado
getmaxcolor regresa el valor del color ms altamente disponible.

Ejemplo
/* getmaxcolor Ejemplo */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int midx, midy;
char colstr[80];
[WIN]
getch();
}
/* arrastra la informacion del colory la convierte en cadena*/
sprintf(colstr, "This mode supports colors 0..%d", getmaxcolor());
/* muestra la informacion por pantalla. */
outtextxy(midx, midy, colstr);
/* limpiar */
getch();
closegraph();
return 0;
}

Obtener modo maximo.

Sintaxis
int getmaxmode(void);

Descripcin
getmaxmode te permite encontrar el nmero de modo mximo para el driver actualmente cargado,
esto directamente del driver. Esto te da la ventaja sobre getmoderange, el cual trabaja solamente
para drivers Borland. El modo mnimo es 0

Valor regresado
getmaxmode regresa el numero mximo del driver actualmente cargado.

Ejemplo
/* getmaxmode Ejemplo */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int midx, midy;
char modestr[80];
getch();
}
/* arrastra la informacin y la convierte en cadena */
sprintf(modestr, "This driver supports modes 0..%d", getmaxmode());
/* muestra la informacin por pantalla */
outtextxy(midx, midy, modestr);
/* limpiar */
getch();
closegraph();
return 0;
}

getmaxx

Sintaxis
int getmaxx(void);

Descripcin
getmaxx regresa el valor mximo (screen-relative) x para el driver grafico actual y modo.

Por ejemplo, en modo CGA in 320*200, getmaxx regresa 319. getmaxx es invaluable para centrar,
determinar las re saltaciones sobre la pantalla, entre otras.

Valor regresado
getmaxx regresa el valor mximo x coordenado a la pantalla.

Ejemplo
/* getmaxx Ejemplo */
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
int midx, midy;
char xrange[80], yrange[80];
/* lectura de los resultados de inicializacin */
getch();
}
/* convertir los valores de mxima resolucin en cadenas */
sprintf(xrange, "X values range from 0..%d", getmaxx());
sprintf(yrange, "Y values range from 0..%d", getmaxy());
/* mostrar la informacin por pantalla */
outtextxy(midx, midy, xrange);
outtextxy(midx, midy + textheight("W"), yrange);
/* limpiar */
getch();
closegraph();
return 0;
}

Ejemplos de Rpogramacion Grafica

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Ejemplos de Rpogramacion Grafica

Cargado por

Copyright:

Formatos disponibles

Arc

También podría gustarte