Programacion Grafica en C++ - Programación Gráfica SIS-2430

Transcripción

PROGRAMACIÓN DE GRÁFICOS EN LENGUAJE C
Para producir la imagen de video, la mayoría de los miembros de la familia PC
requiere un adaptador de video. Los adaptadores de video fueron diseñados para el
PCjr, pero inmediatamente se generalizó su uso al resto de las PC’s, a tal punto que se
llega a un nivel como el de VGA (Video Graphics Array) quien claramente ha
demostrado ser el adaptador de video más popular de los últimos tiempos.
Las aplicaciones de software han evolucionado gigantescamente. Si nos
remontamos una o dos décadas en el tiempo veremos que el entorno en el que giraban
los programas era muy limitado y, de poseer capacidades gráficas, estas eran apenas
unos garabatos cuadriculados (monocromo, por supuesto). Hoy en día no nos
imaginamos una aplicación de software sin su adecuado entorno gráfico (La prueba
más concisa: El dominio en el mercado de los “Software for Windows”). Es por este
motivo que todo programador debe tener al menos una noción de programación
gráfica.
Adaptadores de Video y Controladores de Gráficos:
El adaptador de video conecta el ordenador al monitor a través de un chip
llamado controlador de CRT. El adaptador también tiene un conjunto de puertos de
E/S programables, una ROM generadora de caracteres y memoria RAM para
almacenar información del visualizador.
Los generadores de video operan fundamentalmente según dos modos
diferentes, llamados por IBM, modo texto y modo gráfico. El modo texto solo permite
visualizar caracteres (El código ASCII completo), aunque hay quienes programan en
este modo de una forma pseudográfica. El modo gráfico se utiliza principalmente para
producir dibujos complejos, pero puede reproducir caracteres de texto con gran
variedad de formas y tamaños.
Ninguna función gráfica de “C” puede funcionar sin un controlador de gráficos
en memoria. Los controladores de gráficos están contenidos en los archivos .BGI
(Borland Graphics Interface), los cuales deben estar disponibles en el sistema. Los
diversos drivers que Borland provee para esta versión de Turbo C se listan a
continuación:
1. CGA
2. MCGA
3. EGA
4. EGA64 (EGA de 64K)
5. EGAMONO (EGA Monocromática)
6. IBM8514
7. HERCMONO (Hercules)
8. ATT400 (Adaptador de AT&T 6300 PC)
9. VGA
10.PC3270 (IBM 3270)
Es importante destacar que todas las declaraciones de funciones gráficas, el
Turbo C las realiza en un archivo llamado graphics.h que será necesario incluir en el
programa, de la siguiente manera:
INFORMÁTICA II - Ayte. Mauricio Varea - Ing. Oscar Nasisi - Ing. Carlos Gil
1
#include <graphics.h>
Inicialización del sistema de gráficos:
Antes de que se pueda usar cualquiera de las funciones gráficas es preciso
colocar el adaptador de video en uno de las modos gráficos usando la función
initgraph(), que tiene la siguiente sintaxis:
void far initgraph (int far *controlador, int far *modo, const char far *camino);
La función initgraph() carga en memoria un controlador de gráficos que
corresponda al número indicado por controlador. Este número está estrechamente
ligado con los 10 enumerados en el tema anterior, pudiendo ser 0 para la opción de
autodetección (cuya macro es: DETECT ). El parámetro modo indica un número
entero que especifica el modo de video usado por las funciones gráficas. Por último se
deberá especificar un camino al controlador si este es distinto al directorio de trabajo.
Los distintos modos, de acuerdo a cada controlador, son los que se muestran
en la siguiente tabla:
Controlador
CGA
MCGA
EGA
EGA64
EGAMONO
HERC
ATT400
VGA
Modo
CGAC0
CGAC1
CGAC2
CGAC3
CGAHI
MCGAC0
MCGAC1
MCGAC2
MCGAC3
MCGAMED
MCGAHI
EGALO
EGAHI
EGA64LO
EGA64HI
EGAMONOHI
HERCMONOHI
ATT400C0
ATT400C1
ATT400C2
ATT400C3
ATT400CMED
ATT400CHI
VGALO
VGAMED
VGAHI
Valor
0
1
2
3
4
0
1
2
3
4
5
0
1
0
1
3
0
0
1
2
3
4
5
0
1
2
Resolución
320 x 200
320 x 200
320 x 200
320 x 200
640 x 200
320 x 200
320 x 200
320 x 200
320 x 200
640 x 200
640 x 480
640 x 200
640 x 350
640 x 200
640 x 350
640 x 350
720 x 348
320 x 200
320 x 200
320 x 200
320 x 200
640 x 200
640 x 200
640 x 200
640 x 350
640 x 480
2
PC3270
IBM8514
PC3270HI
IBM8514LO
IBM8514HI
0
0
1
720 x 350
640 x 480
1024 x 768
Para dejar de usar un modo de video gráfico y volver a modo texto, se usa o
bien closegraph() o restorecrtmode(). Sus prototipos son:
void far closegraph (void);
void far restorecrtmode (void);
La diferencia entre ambas estriba principalmente en que la primera descarga
toda la memoria asignada a especificaciones gráficas, mientras que la segunda la deja
intacta para permitir el regreso al modo indicado cuando se encuentre la siguiente
función:
void far setgraphmode (int modo);
Ejemplo: Veamos el siguiente programa que alterna de modo gráfico a texto y
viceversa para mostrar el uso de estas funciones.
#"%$&(')
*+
,-. ! /
! 0
12 ! 345667
! 8
9')8
! 3:;
6 <.= ! >/?8
')@-AB
C2,
.?/D8
<
6C
EF6GH1 I27."KJ9L&(J9$MN&(J;O&(PQ"%J9LR&(J9$9MN&(J;O&S/?8
6C
EF6EF7.. ! T 2 U ! V IC/DWYX9PZ. ! T [6,-U ! T C/?WYX9PQ\2J;1-
T')
] Î? __ \`/?8
6C
EF6EF7.. ! T 2 U ! V IC/DWYX9P ! T [6C,Ua
EF
.?\2b\2/DP
\c`2
< B
>2>')d&(
EF_e \`/D8
C.?/D8
2
fC,
.D/?8
2 96Ig.\fhi2>
1C,V
B')d&(
EF jj\`/?8
2 96Ig.\c`2
< B
>2 ! ! `>') ] 2^kIg e_ \`/?8
C.?/D8
<
,-@
.')/?8
<
6C
EF6GH1 I27."KJ9L&(J9$MN&(J;O&(PQ"%J9LR&(J9$9MN&(J;O&S/?8
6C
EF6EF7.. ! T 2 U ! V IC/DWYX9PZ. ! T [6,-U ! T C/?WYX9PQ\5lm
C>
n')@
] Î? __ \`/?8
3
6C
EF6EF7.. ! T 2 U ! V IC/DWYX9P ! T [6C,Ua
EF
.?\2b\2/DP
B
>2o< g__ \`/?8
C.?/D8
\c`2
< p
, .?/
0
9"%C ÀB*TJ;&(J9"+&(8
9')8
9"% J9228
C2.=q"K92 @2PQ=q')PQ\`\`/?8
"%@ J922An2
; C.?/D8
/D8
Ig."% J92RrfAn2sutv/?0
2 6Ig.?\b>2 BJ92gwxS<j\2PQ
22,d<."%@ J922/
Ey C.zV/?8
p
p
"%$&(')@
*T
,.?/?8
;
2.D/?8
Cuando se deja al sistema de gráficos de Turbo C que establezca el modo de
video, el programa necesita alguna manera de conocer el entorno. La función
getviewsettings() devuelve las dimensiones de la ventana y getmaxcolor() devuelve el
número de colores permitido en el modo de video aplicable.
La sintaxis es la siguiente:
void far getviewsettings (struct viewporttype far *info );
int far getmaxcolor (void);
Se ve claramente que la función getviewsettings() devuelve el entorno de
trabajo a través de una estructura pasada por referencia. La estructura viewporttype
se define en graphics.h como se muestra a continuación:
struct viewporttype {
int left, top, right, bottom;
int clip;
};
Los campos left, top, right y bottom contienen las coordenadas de los
extremos de la ventana. Cuando clip == 0 no existe salida que sobrepase los límites de
la ventana. Si este es distinto de cero, se realizará corte manual para no sobrepasar los
límites.
Las funciones básicas:
Las funciones elementales en cualquier lenguaje para el trazado de gráficos en
general, son las que dibujan: puntos, líneas y círculos. En Turbo C estas funciones son
llamadas putpixel(), line() y circle() respectivamente. Sus prototipos son:
4
void far putpixel (int x, int y, int c);
void far line (int x_ini, int y_ini, int x_fin, int y_fin);
void far circle (int x, int y, int r);
La función putpixel() coloca un pixel de color c en la posición dada por x e
y.
La función line() dibuja una línea desde la posición ( x_ini , y_ini ) hasta la
posición especificada por ( x_fin , y_fin ) en el color preestablecido.
La función circle() dibuja un circulo de radio r centrado en ( x , y ).
Ejemplo: El siguiente programa muestra principalmente el uso de putpixel() y
circle(). Su implementación se ha pensado para que sirva también para mostrar el
funcionamiento de funciones como outtextxy(), rectangle(), bar() (y las funciones
elementales de seteo de parámetros gráficos) que serán analizadas más adelante.
[T 2T @
Ig J;{Z"
|;E}z;[
~')kEy"% 5<P_')E;O@P_')kEFR8
! #"% <. ! @/?8
! #c`C<. ! /?8
! #c`9<.? /?8
! 4lm
C.D C/D8
! 4{NCkC<.? 9PQ`Y/?8
! #Z
. ! /?8
, .?/
0
9"%C ÀB*TJ;&(J9"+&(8
9') ] I? 8
C2.=q"K92 @2PQ=q') ] 2kIg PZ\\`/?8
')kEy"% 5TAn
,-kEy 2.?/z;8
')kEFOAn
,-kEFEy.D/?8
')kEF-AB
,E;7.?/?8
3n .z;/0
5
c`C<.?/D8
"% 2 <.?/?8
p
p
#"% <. ! @/
! 0
9')kEy$8
lm
.zV/?8
{N;.z;P_\c`2
< B
2,[ .?J;{Z"2o{ 2/?\/?8
')kEy$#An')kEF-WSz;|98
3n .r5tN[ C.?//D0
<
C 2.,.')kEy"% 5TU@zV/zV/?8
.,.?')kEFO/?PQ2,.?')kEFR/?PQ2,.?')kEy$//D8
p
c`<.z;/D8
p
#c`C<. ! /
! 0
9}VAz;9998
9 PGHPEyP7PZP34PQ 8
12 ! 345667
! 8
lm
.|:/?8
! 3:;
6 <.= ! >/?8
BA ! T [6,U ! V 8
3A ! T 2 ~U ! T I28
I?2.GHA|98 GHX98 GHB/0
<2.V/D8
Ig. A|:8Z 9|9|9|8QF/?0
EAzVB2,.3UzV/?8
7nAzVB2@,-.BUzV/?8
ÀB.G/u
Ey
.E9PN7n/w2@,-.'4Ey"K 5T/?8
I?..GH/u. ÀAn,.?')kEy"% 5<//wQzq/C E9
.EyP7P
.eGH/u|nwN 2/?8
p
p
p
c`<.?|9/D8
#c`9<.? /
! 0
1 ,u<T_}An\c`2
< B
>2>,[ `.?J;{Z"2o{Z 2/D\28
98
6
p
{N;. PQ,d;>/?8
AB
.?/?8
Ig.J;{Z"AAn/?0
<
2.?/D8
Ey C.zV/?8
p
Ig.|:AAn/?0
An
.D/?8
p
4lm
C. ~;/
! 0
<
2.'4Ey"K 5TUzV/?8
Ig.r5T/0
<
! 3nfC.|9PQ|9PZ'4EFOWYX9Uz;PQ')kEFRPzq/D8
Q2
.?/D8
<
! 3nfC.z;Pz;PZ'4EFOWYX9UX9PQ')kEFRUz;Pzq/D8
! 3nfC.?/D8
p
;
0
<
! 3nfC.')kEFOWYX9PQ|9PZ')kEFOPQ')E;RPzV/?8
Q2
.?/D8
<
! 3nfC.')kEFOWYX9z;Pz;PQ')kEFOUz;PZ'4EFUz;PzV/?8
! 3nfC.?/D8
p
p
4{NCkC<. <PQ`Y,d</
! 0
98
<
2.'4Ey"K 5TUzV/?8
<
6C
EF617 .{Z'hi1MZFsuLR&(PZbsu$ FMZ*T $P4/D8
<
6C
EF6GH1 I27."KJ9L&(J9$MN&(J;O&(P&(sucMN&(J;O&S/?8
<
167 .{Zsu< *RMZ< L+J9PZ|9PQLTsu$'MN *R&(b/?8
<
6Ig 167 .J9')c&YM; <PZ|:/?8
BA:
EF
9.\2b\`/?8
Ig.r5T/0
<
! 3nfC.|9PQ|9PZ'4EFOWYX9Uz;PQ')kEFRPzq/D8
[.|9PZ')kEFRU.D/?PQ')kEFOWYX9Uz;PZ'4EF-/D8
2
.|9PQ')kEFRU.?/?PQ')kEFOWYX9Uz;PZ')kEF-/?8

EF6EF7.')kEFOWDPZ'4EFU.?X9/DPZ,d</?8
<
! 3nfC.z;Pz;PZ'4EFOWYX9UX9PQ')kEFRU.?9/?Pzq/D8
p
;
0
<
! 3nfC.')kEFOWYX9PQ|9PZ')kEFOPQ')E;RPzV/?8
[.')E;O@WYX9PQ')kEFRU.?/?PQ')kEFOPZ')kEF-/?8
2
.|9PQ')kEFRU.?/?PQ')kEFOWYX9PZ')kEF-/?8
7

EF6EF7.')kEFOWDPZ'4EFU.?X9/DPZ,d</?8
p
<
! 3nfC.')kEFOWYX9z;Pz;PQ')kEFOUz;PZ'4EFU.?9/DPzV/?8
p
< 6C
EF617 .*TJ9¡h%¢1&YMZFsuLR&(PZbsu$ FMZ*T $Pzq/D8
#Z
. ! /
! 0
12 ! 345667
! 8
p
<
2.'4Ey"K 5TUzV/?8
<
! 3:;
6 <.= ! >/?8
C .|9PZ|9P ! V 9U ! T I2P ! T [6,-U ! T C>/?8
También existe otro par de funciones para facilitar el trazado de líneas:
void far linerel (int dx, int dy);
Este comando es útil cuando trabajamos en forma relativa. Su misión es trazar
una línea tomando como referencia la posición actual y, por medio de los parámetros
dx y dy, introducimos un incremento positivo o negativo en la coordenada final.
Sino tenemos:
void far lineto (int x, int y);
Que también es utilizada para generar líneas, solo que ahora introducimos la
coordenada final en forma absoluta mediante los parámetros x e y.
Ejemplo: A continuación se verá un programa que, ejecutandolo paso a paso, nos
mostrará el funcionamiento sutilmente distinto entre ambas funciones, aunque la
disposición impuesta hace que con ambas podamos hacer lo mismo.
,-k@ @
Ig 'h+O@c(&Y{
z;
12~c(&Y{d0
9}EyP78
p68
12~c(&Y{dT_'hTOc&Y{ZP_TH'hTOc&Y{Zz;CH'h+O@c(&Y{z;68
! #< &(*T
,.?[ /?8
! #< $
*T
,.?[ /?8
! #c`2,-
2<.?@[ /D8
8
#, . ! #/
! 0
9 ] 2*+2 ! An*+J;&(J9"+&(8
9 ] 2')@
8
9}Eyk;P7<8
[ $
8
C2.= ] *T ! 2PQ= ] 2'4
PZ\\`/?8
Ck<
2k .=@Eyk<PQ=@7<>/?8
$
BAB.?[ /Eyk;>W£.?[ /7<8
&(*T
,.?$
/D8
C.?/D8
! .?/D8
$
*+
,-.D$
/?8
C.?/D8
p
;
2.D/?8
#c`2,-
2<.[ $
F/
! 0
12 ! 345667
! 8
9 PGHPQtNPZ PZP34PEyP7PZtN8
92PQPZk;8
[ ¤2}<8
! 3:;
6 <.= ! >/?8
BA ! T [6,U ! T 8
3A ! T 2 U ! V IC8
EyAi3W£X98
7ABnW£X98
`AB.?BU9|9/W.D$
;X9/D8
<AB¥9¦9|W£'h+Oc&Y{Z8
AB|98
I?2. A|:8Q 'hTOc&Y{§8QF/0
2}TAn.D[ /?>'Mc(WSz;9| |98
T_ C EAiEyn.? C/?.<.?;/£`/D8
T_ C 7nA:7U.? 9/?.< .?;/£`£$
F/?8
>An<8
WY{Z C
YW
p
I?2.GHAzV8GHA'hTOc&Y{§8NGn/0
Ig. A|9P_ A|:8Z 'hTOc&Y{§8Z P_ AGy/0
p
tNA xd'hTOc&Y{Z8
tNA.? UaGH/x§'hTOc&Y{Z8
T_ C GHUz; EAnT_tN EUTH.? /?.?tN/w .?tN/? Ey8
T_ C GHUz; 74ABT_tN 7nUT_.? /?`.?tN/w .?tN/? 78
9
T_'hTOc&Y{ZC GHUz; EAnTH|9C EUVH'h+O@c(&Y{UaGC Ey8
T_'hTOc&Y{ZC GHUz; 7nAnT_|9 7nUTH'hTOc&Y{ZUaGH 78
p
2 .eEyP 7Pe/?8
p
#< &(*T
,.[ 2>/
! 0
9 PGH8
p
c`2,
C<.2>/?8
I?2. A|:8Q 'hTOc&Y{§8QF/0
Ig.GHAF8GH'h+O@c(&Y{d8Q9G9/0
, ! C.?TH E9PZT_ C 7/?8
.?T GC EyPQT GC 7/?8
p
p
#< $
*T
,.?[ /
! 0
9 PGH8
c`2,
C<.?2/?8
I?2. A|:8Q A'hTOc&Y{§8ZF/0
, ! C.DVH|9C EyPQT_|9 7/?8
Ig.GHA|:8NGA'hTOc&Y{§8ZGy/0
.?@V GH_ C EyPQT GCH 7/?8
p
p
p
Lógicamente se intuye que es necesario contar con una función que me
establezca el color de dibujo aplicable al usar line() o circle() (o muchas más). Por ello
surge:
void far setcolor (int color);
El valor de color tiene que estar comprendido en el rango válido para el modo
de gráficos actual. Esto es entre 0 y getmaxcolor().
Funciones para el tratamiento de figuras geométricas:
La siguiente es una síntesis de las funciones más usadas para todo tipo de
figuras geométricas. Como se puede apreciar, son de funcionemiento bastante
intuitivo.
void far rectangle (int left, int top, int right, int bottom);
Realiza un rectángulo con los límites establecidos.
10
void far arc (int x, int y, int StartAngle, int EndAngle, int Radio);
Realiza un arco, donde ( x , y ) son las coordenadas del centro, StartAngle y
EndAngle nos da el ángulo (en radianes) donde comienza o termina respectivamente
de trazar el arco, y Radio fija el valor del radio.
void far bar (int left, int top, int right, int bottom);
void far bar3d (int left, int top, int right, int bottom, int depth, int topflag);
Usados para la creación de gráficos estadísticos.
void far
RadioY);
ellipse (int x, int y, int StartAngle, int EndAngle, int RadioX, int
Ellipse con centro en ( x , y ); valores de radio máximo y mínimo ( RadioX e
RadioY alternativamente). StartAngle y EndAngle nos da la posibilidad de no generar
la ellipse completa.
void far sector (int x, int y, int StartAngle, int EndAngle, int RadioX, int RadioY);
Dibuja y rellena una porción elíptica.
Funciones para el tratamiento de áreas:
Se puede rellenar cualquier figura cerrada usando la función floodfill() cuya
sintaxis es:
void far floodfill (int x, int y, int ColorBorde);
Al usar esta función para el relleno de figuras cerradas, llámese por las
coordenadas de un punto dentro de la figura y el color de las líneas que constituyen la
figura (su contorno). Está demás aclarar que deberá tratarse de una figura cerrada.
Usando setfillstyle() se puede determinar la forma usada para el relleno.
void far setfillstyle (int modelo, int color);
Los valores para modelo y sus macros equivalentes se listan a continuación:
Macros
EMPTY_FILL
SOLID_FILL
LINE_FILL
LTSLASH_FILL
SLASH_FILL
BKSLASH_FILL
LTBKSLASH_FILL
HATCH_FILL
XHATCH_FILL
Valor
0
1
2
3
4
5
6
7
8
Significado
Relleno con color de fondo
Relleno con textura uniforme
Relleno -------------------Relleno ////////////////////////
Relleno //////////////////////// con líneas gruesas
Relleno \\\\\\\\\\\\\\\\\\\\\\\\ con líneas gruesas
Relleno \\\\\\\\\\\\\\\\\\\\\\\\
Relleno con espaciado ligero
Relleno con espaciado denso
11
INTERLEAVE_FILL
WIDE_DOT_FILL
CLOSE_DOT_FILL
USER_FILL
9
10
11
12
Relleno con líneas entrecortadas
Relleno punteado con gran espaciado
Relleno punteado con poco espaciado
Relleno definido por el usuario
Salida de texto en modo gráfico:
Aunque las funciones estándares de texto de Turbo C, tales como la printf(),
pueden usarse en la mayoría de los modos gráficos, no son la alternativa más flexible.
Para aprovechar al máximo el entorno gráfico de Turbo C será necesario usar las
funciones de salida de texto en modo gráfico, descritas a continuación:
void far outtext (char *cadena);
void far outtextxy (int x, int y, char *cadena);
Estas funciones sacan la cadena (apuntada por el puntero) a la ventana gráfica
predefinida. Las principales ventajas de usar outtext() sobre la de usar printf() son sus
posibilidades en el manejo de strings en diferentes tipos de caracteres, tamaños,
direcciones o resolución en las posiciones. También es una ventaja la posibilidad de
cortar la salida que desbordaría la ventana. Por el contrario, printf() no puede cortar la
salida.
void far settextstyle (int tipo, int direccion, int tamaño);
El parámetro tipo determina el juego de caracteres a ser usados. Por omisión,
es un tipo “mapa de 8x8 bits”. Se puede dar a tipo uno de los siguientes valores:
Tipo
DEFAULT_FONT
TRIPLEX_FONT
SMALL_FONT
SANS_SERIF_FONT
GOTHIC_FONT
Valor
0
1
2
3
4
Significado
Tipo mapa de 8x8 bits
Letras Grandes
Letras pequeñas
Tipo Sans Serif
Letra Gótica
La dirección en la que se visualiza el texto, izquierda a derecha o de abajo a
arriba, se determina por el valor de dirección que puede ser HORIZ_DIR o bien
VERT_DIR, correspondiendo cada uno de estos a 0 o 1 respectivamente.
El parámetro tamaño es un multiplicador que aumenta el tamaño del caracter.
Su rango válido es de 0 a 10.
Al igual que lo hacíamos con las ventanas gráficas, para obtener información
respecto a las especificaciones de texto en modo gráfico, puede usarse una función
cuyo argumento es una estructura pasada por referencia.
void far gettextsettings (struct textsettingstype *TextInfo);
Esta estructura ha sido definida en graphics.h de la siguiente manera:
12
struct textsettingstype {
int font;
int direction;
int charsize;
int horiz;
int vert;
};
Cambio de estilo de línea:
Turbo C permite cambiar la forma en la que se dibuja una línea. Todas las
líneas son sólidas por omisión, pero mediante la especificación correcta esta puede ser
de puntos, de trazos, de puntos y trazos contiguos o personalizado. Para efectuar estos
cambios usaremos la función:
void far setlinestyle (int estilo, unsigned modelo, int ancho);
A continuación se detallan los posibles valores del parámetro estilo:
Valor
SOLID_LINE
DOTTED_LINE
CENTER_LINE
DASHED_LINE
USERBIT_LINE
Significado
Línea continua
Línea de puntos
Eje de simetría
Línea de trazos
Línea definida por el usuario
Si se desea un estilo personalizado mediante este último valor, la forma de la
línea se introduce por el parámetro modelo como si se tratase de un mapa de bits. Por
ejemplo si (estilo==4)&&(modelo==0x1234), cada vez que tracemos una línea tendrá
una forma que se corresponderá a 0001001000110100 donde los ceros son pixels
apagados y los unos son pixels prendidos.
El valor del ancho podrá ser NORM_WIDTH o bien THICK_WIDTH siendo
el primero una forma de especificar un espesor de 1 pixel, y el segundo un espesor de 3
pixels.
Funciones que trabajan con porciones de pantalla:
Aquí aparece una filosofía distinta de trabajo. Ya no se trata de dibujar con las
nociones básicas de geometría (como se venía haciendo), sino de aprovechar el manejo
de la memoria de video como un complemento útil a las funciones antes vistas para
evitar la redundancia en el dibujo.
La función getimage() se usa para copiar una región de la ventana de gráficos
en una memoria intermedia. La función putimage() pone el contenido de una porción
de memoria en la pantalla. La sintaxis es la siguiente:
void far getimage (int left, int top, int right, int bottom, void far *buffer);
void far putimage (int left, int top, void far *buffer, int op);
La función getimage() copia el contenido de una porción rectangular de la
pantalla definida por sus coordenadas en la memoria apuntada por el puntero buffer.
13
Se usa putimage() para visualizar una porción de pantalla contenida en memoria y
apuntada por buffer. Mediante el parámetro op se determina la forma en la que se
escribirá en pantalla pudiendo este tomar alguno de los siguientes valores:
Nombre
COPY_PUT
XOR_PUT
OR_PUT
AND_PUT
NOT_PUT
Valor
0
1
2
3
4
Significado
Sobreescrbir el destino
OR-Exclusivo con destino
OR con destino
AND con destino
Invertir la imagen fuente
El tamaño de la memoria intermedia, en bytes, para una región determinada se
proporciona por la función imagesize(). Se debe usar esta función en lugar de intentar
calcular manualmente el espacio necesario, ya que imagesize() proporciona el valor
correcto con independencia del modo de video que esté en uso. La sintaxis es la
siguiente:
unsigned far imagesize (int left, int top, int right, int bottom);
Cabe aclarar que estas funciones que manejan porciones de pantalla
directamente de la RAM de video, lo hacen de una forma similar al funcionamiento de
la memcpy() definida en mem.h, solo que ahora uno de los punteros lo prefijamos de
acuerdo al valor establecido por el hardware en uso. Esto le da cierta potencialidad a
estas funciones aunque para ello tenemos que acercarnos un poco más al nivel de
máquina.
Ejemplo: Como intento simplificado de hacer un protector de pantalla, veremos el
manejo de las funciones mencionadas en un programa que mueve una porción de
pantalla a travez de esta.
,-
,¨ [T @
Ig suL z
@
Ig suF©|
@
Ig ')kEyc6
¦
@
Ig *T
2O.EyP 3nP_ P_`/..?.? /?.Ey/?.3n/?Uz;/B.?//u..?2/?U.D /?U.3n/?zV/w.?.EAn|9/u|nw
E9/?8
@
Ig *T
2R.e7PeP Pe[/..?./?.7/?.?/?Uz;/B.?[//u..?[/?U./?U.?/?zV/wN.?.e74AB|9/u|nw
7/D8
12~c(&Y{d0
14
9}EyP78
p68
#, . ! #/
! 0
! #c` <. ! #/?8
! # ,-
. ! #/?8
9}Eyk;P7<8
9 ] 2*+2 ! An*+J;&(J9"+&(P ] ')
8
C2.= ] *T ! 2PQ= ] 2'4
PZ\u\/?8
! .?/D8
c` ;.D/?8
C.?/D8
,
.?/?8
;
2.D/?8
p
#c` <. ! #/
! 0
! #Z
. ! #/?8
12~c&Y{§ 7@Q'4Eyc(T8
9 8
9')kEy"% f<PZ 28
Q2
.D/?8
')kEy"% 5TAn
,-kEy 2.?/z;8
3n .r5tN[ C.?//D0
AzVB2@,-.'4Ey"K 5<UzV/?8
<
I? 17 .2,.z;|9/?PQ `/?8
<
C 2. `/?8
Ig. A|:8Z .?')kEyc6;Uz;/8Q B/?0
7@_ C EAB2,.
,EFE9.?//?8
7@_ C 7nAB2@,-.
,-kEF7.?//D8
p
p
p
7@H EAB 7@H|9C Ey8
7@H 7nAB 7@z; 78
Ig 7.')E9c<PQ.? }Ig`Y/? 7n/?8
# ,
. ! #/
! 0
1 } bAz;|9|98
1 c&SA:|98
12~c&Y{§98
12 ! 345667
! 8
15
9}EyP7PZ}E9PZ}78
9}<PZ E9PZ 7PQ fEyPQ 57P3nPZPQA9|98
! #Yc` PZY'4
,- 8
! 3:;
6 <.= ! >/?8
EAB. ! T 2 CU ! T IC/?WYX:U b8
7nAB. ! T [6C,U ! T /?WYX:U9ªbWYX98
3An.D 5EAB EyªbYX9/U Ey8
BAn.D 57nAB 7 b/U 78
c`C AB, .<A ,
< «(
.? EyPZ 7PZ 5EyPQ f7//?8
')
, AB, .T/?8
C ,
. EyPQ 7PQ 5E9PZ 57PQc` /?8
,
,7.'4
,- PZc PN<D< «(
I?.< «(
MNC//D8
EyA E98N7A 78
3n -.rftN[ .?//0
9 ,
.E9PN7PQc`9 PQ"%suc`MZc`¢&
0
}EAB.?2,. b/x§X9/uUa34WYªwC3nWY8
EAn*+
[email protected]AEy/?P34P ! T I2P ! T 2 ~/D8
}7nAn.D2@,-.e b/xdX9/uUWYªwNWY8
7 An*+
92..7A7/?PZP ! V P ! T [6C,¤/?8
n
pQ3n .EyAA E=q=7AA 74/D8
C ,-
.EyPN7PEy3nPN7PQc` >/?8
9 ,
.E9PN7PQ')
,2 PQ"%suc`MZc`¢&S/?8
,
,7.')
, PZc`C P<D< «(
Ig.e; «(
MNC//?8
7.c&S/?8
p
p
I?2
.')
,2 /?8
I?2
.c`C /?8
#Z
. ! #/
! 0
12 ! 345667
! 8
<
2.
,-kEy 2.?/U2,.
,E9 2.D///?8
p
<
! 3:;
6 <.= ! >/?8
C .|9PZ|9P ! V 9U ! T I2P ! T [6,-U ! T C>/?8
16

Programacion Grafica en C++ - Programación Gráfica SIS-2430

Transcripción

Documentos relacionados

Fund. De la Informática – Int. a la Programación – Int. a la Computac

DECLARACIÓN JURADA Por la presente, declaro bajo juramento

matricesA