Graficos de C

Bismarck Salvador Traña López__________________________________________UNI
Introducción a la Programación grafica en C.

Para la mejor comprensión de este tutor hemos realizado un análisis de las Funciones que
se suelen utilizar con mucha frecuencia al programar en el modo grafico de C, dando como
resultado la librería conio.h, dos.h, stdlib.h, y evidentemente graphics.h.
En este pequeño tutor solo haremos énfasis en estas librerías, puesto que al final del libro
se encuentran las demás librerías que comúnmente encontramos con frecuencia en el
programa.
Muchos libros nos marean dándonos conceptos los cuales se aprenden conforme
programando; esto no significa, que no sean importan tantees los ejercicios que aquí te
enseñamos te ayudaran a darte todo el conocimiento así como también te los daremos
conforme avancemos así que dejemos de hablar y aventurémonos en el mundo de la
programación grafica.
Lo primero que debemos saber al realizar una grafica son las dimensiones del ordenador
(Monitor) en modo texto las dimensiones de este es 25X80 esto dependiendo de la versión
de video instalada. En el modo grafico estas dimensiones cambian dependiendo del tipo de
macro de inicialización se realice(ver Macro modos). Quedando la mas común de 640X480
modo VGA.
A la hora de desarrollar un programa gráfico se debe tener en cuenta los siguientes cuatro
puntos:
1. Especificar el fichero o librería graphics.h
# include<graphics.h>
2. Inicializar el modo grafico correspondiente mediante la Función initgraph;
Initgraph(&adaptador,&modo,”dirección de los archivos bgi”);
3. Crear y manipular las figuras graficas.
/*Desarrollo del programa*/
4. Restaurar el modo de video antes de salir del programa(restaurar el modo texto)
closegraph() o restorecrtmode()
Juan Carlos Gutiérrez Barquero____________________________________________ 1

Otra de las cosas importantes que debemos saber es que Funciones contiene graphics.h
Funciones de Graphics.h
Esta librería se encuentra los prototipos de las Funciones que manipulan la parte gráfica
en el entorno de MS-DOS.
Arc getmaxy putimage

bar getmodename putpixel
bar3d getmoderange rectangle
circle getpalette registerbgidriver
cleardevice getpalettesize registerbgifont
clearviewport getpixel restorecrtmode
closegraph gettextsettings sector
detectgraph getviewsettings setactivepage
drawpoly getx setallpalette
ellipse gety setaspectratio
fillellipse graphdefaults setbkcolor
fillpoly grapherrormsg setfillpattern
floodfill graphfreemem setfillstyle
getarccoords graphgetmem setgraphbufsize
getaspectratio graphresult setgraphmode
getbkcolor imagesize setlinestyle
getcolor initgraph setpalette
getdefaultpalette installuserdriver setrgbpalette
getdrivername installuserfont settextjustify
getfillpattern line settextstyle
getfillsettings linerel setusercharsize
getgraphmode lineto setviewport
getimage moverel setvisualpage
getlinesettings moveto setwritemode
getmaxcolor outtext textheight
getmaxmode outtextxy textwidth
getmaxx pieslice
Es necesario conocer hacerca de los macros y estructuras, entre las estructuras

tenemos:
arccoordstype linesettingstype textsettingstype

fillsettingstype palettetype viewporttype
Entre los macros se encuentran:
colores errores modos

drivers fuentes put_op
enlazar línea trama
Antes de comenzar a programar en modo grafico debemos estudiar lo que son los
macros, que son instrucciones que nos ayudaran a realizar de una manera más efectiva
nuestros gráficos.

Colores :
Colores de Fondo
Constante Valor Significado

BLACK 0 Negro
BLUE 1 Azul
GREEN 2 Verde
CYAN 3 Cían
RED 4 Rojo
MAGENTA 5 Magenta
BROWN 6 Marrón
LIGHTGRAY 7 Gris Claro
DARKGRAY 8 Gris Oscuro
LIGHTBLUE 9 Azul Claro
LIGHTGREEN 10 Verde Claro
LIGHTCYAN 11 Cían Claro
LIGHTRED 12 Rojo Claro
LIGHTMAGENTA 13 Magenta Claro
YELLOW 14 Amarillo
WHITE 15 Blanco
Modo de 16 Colores

BLACK 0 Negro
BLUE 1 Azul
GREEN 2 Verde
CYAN 3 Cían
RED 4 Rojo
MAGENTA 5 Magenta
BROWN 6 Marrón
LIGHTGRAY 7 Gris Claro
DARKGRAY 8 Gris Oscuro
LIGHTBLUE 9 Azul Claro
LIGHTGREEN 10 Verde Claro
LIGHTCYAN 11 Cían Claro
LIGHTRED 12 Rojo Claro
LIGHTMAGENTA 13 Magenta Claro
YELLOW 14 Amarillo
WHITE 15 Blanco

Color del modo CGA
Número Paleta Color 1 Significado Color 2 Significado Color 3 Significado
0 CGA_LIGHT Verde Claro CGA_LIGHTRED Rojo Claro CGA_YELLOW Amarillo

GREEN
1 CGA_LIGHT Cían Claro CGA_LIGHTMAGENTA Magenta Claro CGA_WHITE Blanco
CYAN
2 CGA_GREE Verde CGA_RED Rojo CGA_BROWN Marrón
N
3 CGA_CYAN Cían CGA_MAGENTA Magenta CGA_LIGHTGRAY Gris Claro
Valor asignado: 1 2 3
Nota: Color 0 se reserva para el color de fondo y se asigna con lo función setbkcolor, pero
los demás colores son fijos. Estas constantes se usan con setcolor.
Colores para las paletas.
Constante (CGA) Valor Constante (EGA/VGA) Valor

BLACK 0 EGA_BLACK 0
BLUE 1 EGA_BLUE 1
GREEN 2 EGA_GREEEN 2
CYAN 3 EGA_CYAN 3
RED 4 EGA_RED 4
MAGENTA 5 EGA_MAGENTA 5
BROWN 6 EGA_LIGHTGRAY 7
LIGHTGRAY 7 EGA_BROWN 20
DARKGRAY 8 EGA_DARKGRAY 56
LIGHTBLUE 9 EGA_LIGHTBLUE 57
LIGHTGREEN 10 EGA_LIGHTGREEN 58
LIGHTCYAN 11 EGA_LIGHTCYAN 59
LIGHTRED 12 EGA_LIGHTRED 60
LIGHTMAGENTA 13 EGA_LIGHTMAGENTA 61
YELLOW 14 EGA_YELLOW 62
WHITE 15 EGA_WHITE 63
Nota: Estas constantes se usan con las Funciones setpalette y setallpalette.el cual
veremos en capítulos posteriores

Fuentes:
Fuentes para Texto
Constante Valor Valor

DEFAULT_FONT 0 Fuente bitmap de 8x8
TRIPLEX_FONT 1 Fuente escalable de tipo triple
SMALL_FONT 2 Fuente escalable pequeña
SANS_SERIF_FONT 3 Fuente escalable de tipo sans serif
GOTHIC_FONT 4 Fuente escalable de tipo gótico
SCRIPT_FONT 5 Fuente escalable de tipo manuscrito
SIMPLEX_FONT 6 Fuente escalable de tipo manuscrito simple
TRIPLEX_SCR_FONT 7 Fuente escalable de tipo manuscrito triple
COMPLEX_FONT 8 Fuente escalable de tipo complejo
EUROPEAN_FONT 9 Fuente escalable de tipo europeo
BOLD_FONT 10 Fuente escalable en negrita
Dirección del Texto

HORIZ_DIR 0 Texto horizontal
VERT_DIR 1 Texto vertical
Justificación de Texto en la Horizontal

LEFT_TEXT 0 Justificar a la izquierda
CENTER_TEXT 1 Centrar el texto
RIGHT_TEXT 2 Justificar a la derecha
Justificación de Texto en la Vertical

BOTTOM_TEXT 0 Justificar debajo
CENTER_TEXT 1 Centrar el texto
TOP_TEXT 2 Justificar arriba

Tramas:
Tramas predefinidas

EMPTY_FILL 0 Rellena con el color de fondo
SOLID_FILL 1 Rellena enteramente
LINE_FILL 2 Rellena con líneas horizontales: ---
LTSLASH_FILL 3 Rellena con rayas finas: ///
SLASH_FILL 4 Rellena con rayas gruesas: ///
BKSLASH_FILL 5 Rellena con rayas inversas y finas: \\\
LTBKSLASH_FILL 6 Rellena con rayas inversas y gruesas: \\\
HATCH_FILL 7 Rellena con líneas cruzadas cuadriculadamente: +++
XHATCH_FILL 8 Rellena con líneas cruzadas diagonalmente: XXXX
INTERLEAVE_FILL 9 Rellena con líneas entrelazadas
WIDE_DOT_FILL 10 Rellena con lunares bastante distanciados
CLOSE_DOT_FILL 11 Rellena con lunares poco distanciados
USER_FILL 12 Rellena con la trama definida por el usuario
Nota: Todos los tipos de tramas menos EMPTY_FILL usan el color de relleno
seleccionado; EMPTY_FILL usa el color de fondo para rellenar.
Driver:
Dispositivos Gráficos
Dispositivo/Constante Valor
DETECT 0
CGA 1
MCGA 2
EGA 3
EGA64 4
EGAMONO 5
IBM8514 6
HERCMONO 7
ATT400 8
VGA 9
PC3270 10
Líneas:
Estilos de Líneas

SOLID_LINE 0 Línea continua _______
DOTTED_LINE 1 Línea hecha con puntos ……..
CENTER_LINE 2 Línea centrada –––––––––––
DASHED_LINE 3 Línea discontinua _._._._.
USERBIT_LINE 4 Línea definida por el usuario
Nota: El grosor es definido escribiendo NORM_WIDTH para rallas normales y

THICK_WIDTH para líneas mas gruesos

Grosores para Líneas Modos de Escritura
Constante Grosor Valor Significado Constantes Valor Significado

COPY_PUT 0 Píxeles de la línea sobrescriben
los píxeles existentes
NORM_THICK 1 Grosor es de 1 píxel
XOR_PUT 1 Píxel de la pantalla son el
Resulta do de la operación
THICK_WIDTH 3 Grosor es de 3 OR de los píxeles existentes
píxeles y los de la línea
Modos:
Modos Gráficos
Dispositivo Modo/Constante Código Resolución Paleta Pagina

CGA CGAC0 0 320X200 4 Clores 1
CGAC1 1 320X200 4 Clores 1
CGAHI 4 640X200 2 Clores 1
MCGA MCGAC0 0 320X200 4 Clores 1
MCGAC1 1 320X200 4 Clores 1
MCGAMED 4 640X200 2 Clores 1
MCGAHI 5 640X480 2 Clores 1
EGA EGALO 0 640X200 16 Colores 4
EGAHI 1 640x350 16 Colores 2
EGA64 A64LO 0 640X200 16 Colores 1
EGA64HI 1 640X350 4 Colores 1
EGAMONO AMONOHI 3 640x200 2 Colores 1* / 2**
VGA VGALO 0 640X200 16 Colores 2
VGAMED 1 640x350 16 Colores 2
VGAHI 2 640X480 16 Colores 1
ATT400 ATT400C0 0 320x200 4 Colores 1
ATT400C1 1 320x200 4 Colores 1
ATT400MED 4 640x400 2 Colores 1
ATT400HI 5 640x400 2 Colores 1
HERC HERCMONOHI 0 720X348 2 Colores 2
PC3270HI 0 720X350 2 Colores 1
IBM8514LO 0 640X480 256 Colores
IBM8514HI 1 1024X768 256 Colores
Si la tarjeta es de 64 K o la tarjeta es de 256 K

Errores:
Códigos de Errores
Constante Código Significado

grOk 0 Ningún error
grNoInitGraph -1 Gráficos no iniciados
grNotDetected -2 Ningún adaptador gráfico detectado
grFileNotFound -3 Fichero de dispositivo no encontrado
grInvalidDriver -4 Fichero de dispositivo no válido
grNoLoadMem -5 No hay memoria para cargar dispositivo
grNoScanMem -6 No hay memoria para rellenar
grNoFloodMem -7 No hay memoria para usar floodfill
grFontNotFound -8 Fichero de fuente no encontrado
grNoFontMem -9 No hay memoria para cargar la fuente
grInvalidMode -10 Modo gráfico no válido
grError -11 Error gráfico
grIOerror -12 Error gráfico de Entrada/Salida
grInvalidFont -13 Fichero de fuente no válido
grInvalidFontNum -14 Número de fuente no válido
grInvalidDeviceNum -15 Número de dispositivo no válido
grInvalidVersion -18 Número de versión no válido
Put_op:
Operaciones con putimage

COPY_PUT 0 Sobrescribir los píxeles existentes
XOR_PUT 1 Operación OR Exclusivo con los píxeles
OR_PUT 2 Operación OR Inclusivo con los píxeles
AND_PUT 3 Operación AND con los píxels
NOT_PUT 4 Invertir la imagen
Nota: Estas operaciones se usan exclusivamente con la función putimage. El cual

veremos en capítulos posteriores.

Métodos de Inicialización del modo grafico.

Antes de conocer los métodos de inicialización debemos conocer la función initgraph la cual
nos permitirá realizar gráficos.
Función initgraph
void far initgraph(int far *driver, int far *modo, int far *path);
Esta función es usada para cargar o validar un dispositivo gráfico y cambiar el sistema de
vídeo a modo gráfico. La función initgraph debe ser llamada antes de cualesquier
Funciónes que generan una salida gráfica sean usadas. Existen varios valores a ser
usados para el argumento *driver. Si *driver es asignado a DETECT, ó 0, la
función detectgraph es llamada, y un dispositivo y modo gráfico apropiados son
seleccionados. Asignando a *driver cualquier otro valor predefinido inicia la carga del
dispositivo gráfico correspondiente. Existen varios valores a ser usados para el argumento
*modo. Estos valores deberían corresponder al dispositivo especificado en el argumento
*driver. El argumento *path especificad el directorio donde los dispositivos gráficos están
localizados. La función initgraph buscará el dispositivo primeramente en este directorio. Si
no es encontrado, la función buscará en el directorio de inicio. Cuando el argumento *path
es NULL, solamente el directorio de inicio es buscado.
Otra forma para evitar cargando el dispositivo desde el disco cada vez que el programa es
ejecutado es ligarlo o enlazarlo al dispositivo apropiado en un programa ejecutable.
La función initgraph no retorna ningún valor. Sin embargo, cuando la función initgraph es
llamada, el código de error interno es activado. Si la función initgraph termina con éxito, el
código es asignado un 0. Si no, el código es asignado así:
-2 grNotDetected La tarjeta gráfica no se encontró
-3 grFileNotFound El fichero del dispositivo no se encontró
-4 grInvalidDriver El fichero del dispositivo es inválido
-5 grNoLoadMem No hay suficiente memoria para cargar el dispositivo
Ejemplo:
#include <graphics.h>
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
initgraph( &driver, &modo, “C:\\TC20\\BIN” );
circle( 300, 200, 80 );
getch(); /* Pausa */
closegraph();
getch();
}
Existen diferentes métodos de inicialización pero en este pequeño tutorial trataremos dos
que suelen ser los más utilizados hoy en día.

1. Método de inicialización del modo grafico a prueba de errores.
# include<process.h>
# include <conio.h>
void main() {
int driver = VGA;
int modo = VGAHI;
int resultado;
initgraph(&driver,&modo,"c:\\tc20\\bin");
resultado=graphresult();
if(resultado!=grOk)
{
getch();
exit(0);
}
getch();
}
cuerpo del programa
2. Método de inicialización rápido del modo grafico.
void main() {
int driver = DETECT,modo;
initgraph(&driver,modo,” c:\\tc20\\bin”);
cuerpo del programa
driver: Es la dirección de la variable que contiene el código del tipo de de driver o

adaptador que tiene la computadora.
modo: Es la dirección de la variable que contiene el código del modo en que se podrá
adaptar.
c:\\tc20\\bin: Es el directorio donde se encuentra el código del manejador, puede ser

camino relativo o absoluto.
graphresult():Regresa el código error de la ultima llamada a una función grafica de turbo

c un valor de 0 significa que no hubo error.
grOk : regresa el código de error de la función graphresult().
DETECT: Dispositivo grafico de auto detección del la tarjeta de video y del modo grafico.

¿Qué son los primitivos gráficos…?

Definición.
Un primitivo gráfico es un elemento fundamental de dibujo en un paquete grafico tal como

un punto, línea, o circulo; puede ser un carácter, o puede ser una operación tal como
relleno, coloreado o trasferido de la imagen. C cuenta con 5 grupos de primitivos gráficos.
 Figuras geométricas: Dibujan las figuras de la geometría clásica: líneas,

círculos, rectángulos, arcos, polígonos etc.
 Relleno: tiene dos formas de realizarse. El primero es con polígonos, donde se

definen los vértices del polígono a ser rellenado segunda es una operación grafica
que busca algorítmicamente las fronteras de la región del relleno.
 Rasterop: Es una operación grafica que copia el área de una imagen para luego
dibujarla en cualquier región de la pantalla.
 Gráficas Matemáticas: Dibujan los primitivos barras y sectores para conseguir

dibujar las herramientas del sector.
 Texto Gráfico: Sirve para escribir texto en modo grafico, utilizando diferentes
fuentes.
 Figuras geométricas:
LINEAS.
void far line(int x1, int y1, int x2, int y2);
Esta función es usada para conectar dos puntos con una línea recta. El primer punto es
especificado por los argumentos x1 e y1. El segundo punto es especificado por los
argumentos x2 e y2. La línea se dibuja usando el estilo de línea actual, el grosor, y el color
actual. La posición del cursor gráfico no es afectada por la función line.
La función line() no retorna ningún valor.

Ejemplo:
#include <conio.h>
void main() {
int driver = EGA,modo = EGAHI;
initgraph( &driver, &modo, "c:\\tc20\\bin" );
line( 20, 40, 350, 100 );
line( 400, 30, 50, 250 );
getch();
closegraph();
}
CIRCULOS.
void far circle(int x, int y, int radio);
Esta función se utiliza para dibujar un círculo. Los argumentos x e y definen el centro del
círculo, mientras que el argumento radio define el radio del círculo. El círculo no es
rellenado pero es dibujado usando el color actual.
El grosor de la circunferencia puede ser establecido por la función setlinestyle; sin

embargo, el estilo de la línea es ignorado por la función circle.
La función circle no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
initgraph( &driver, &modo, "C:\\tc20\\BIN" );
circle( 300, 200, 80 );
closegraph();
}

RECTANGULOS.
void far rectangle(int izquierda,int superior, int derecha, int inferior);
Esta función dibujará un rectángulo sin rellenar su interior usando el color actual. La
esquina superior izquierda del rectángulo está definida por los argumentos izquierdos y
superiores. Estos argumentos corresponden a los valores x e y de la esquina superior
izquierda. Similarmente, los argumentos derecha e inferior definen la esquina inferior
derecha del rectángulo. El perímetro del rectángulo es dibujado usando el estilo y grosor
de línea actuales.
La función rectangle() no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
initgraph( &driver, &modo, "C:\\tc20\\bin" );
rectangle( 20, 20, 400, 300 );
closegraph();
}
ARCOS
void far arc(int x, int y,int comienzo_angulo, int final_angulo, int radio);
Esta función creará un arco circular. El arco tiene como centro el punto especificado por
los argumentos x e y, y es dibujado con el radio especificado: radio. El arco no está
rellanado, pero es dibujado usando el color actual. El arco comienza al ángulo
especificado por el argumento comienzo_angulo y es dibujado en la dirección contraria al
de las agujas del reloj hasta llegar al ángulo especificado por el argumento final_angulo.
La función arc usa el este (extendiéndose hacia la derecha del centro del arco en la
dirección horizontal) como su punto de 0 grados. La función setlinestyle puede usarse

para establecer el grosor del arco. La función arc, sin embargo, ignorará el argumento
trama de la función setlinestyle.
La función arc no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA,modo = EGAHI,radio;
for( radio = 25; radio < 175; radio += 25 )
arc( 320, 175, 45, 135, radio );
closegraph();
}
PIXELES.
void far putpixel(int x, int y, int color);
Esta función es usada para colocar a un píxel en una posición en particular la cual es
cuestionada por los argumentos x e y. El argumento color específico el valor del color del
píxel.
La función putpixel no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA,modo = EGAHI,t;
initgraph( &driver, &modo, “c:\\tc20\\bin” );
for( t=0; t<200; t++ )
putpixel( 100+t, 50+t, t%16 );
getch();

closegraph();
}
ELIPSES.
void far ellipse(int x, int y, int comienzo_angulo, int final_angulo, int x_radio, int y_radio);
Esta función es usada para dibujar un arco elíptico en el color actual. El arco elíptico está
centrado en el punto especificado por los argumentos x e y. Ya que el arco es elíptico el
argumento x_radio especifica el radio horizontal y el argumento y_radio especifica el radio
vertical. El arco elíptico comienza con el ángulo especificado por el argumento
comienzo_angulo y se extiende en un sentido contrario a las agujas del reloj al ángulo
especificado por el argumento final_angulo. La función ellipse considera este - el eje
horizontal a la derecha del centro del elipse - ser 0 grados. El arco elíptico es dibujado con
el grosor de línea actual como es establecido por la función setlinestyle. Sin embargo, el
estilo de línea es ignorado por la función ellipse.
La función ellipse no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
ellipse( 300, 150, 45, 225, 100, 50 );
closegraph();
}
 Funciones básicas de graphics.h.
Función setbkcolor
void far setbkcolor(int color);
Esta función es usada para asignar el color de fondo al valor del color de fondo
especificado por el argumento color. Existen varios valores para ciertos colores de fondo.

La función setbkcolor no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
setbkcolor( 4 );
circle( 300, 150, 50 );
closegraph();
getch();
}
Función getbkcolor.
int far getbkcolor(void);
Esta función es usada para obtener el valor del color de fondo actual. El color de fondo,
por defecto, es el color 0. Sin embargo, este valor puede cambiar con una llamada a la
función setbkcolor. Existen varios valores para ciertos colores de fondo.
La función getbkcolor retorna el valor del color de fondo actual.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA,modo = EGAHI,color;
setbkcolor( 4 );
circle( 300, 150, 50 );
color = getbkcolor();
closegraph();
printf( "Color de fondo: %d\n", color );
getch();
}
void far setcolor(int color)
Esta función coloca el atributo color es decir escoge un color entre 0 y 15 o su

equivalente en inglés (ver pagina 3 Modo de 16 colores) todo lo que se dibuje después de
esta instrucción tendrá el color establecido por la función setcolor el valor de esta es
función es WHITE.

Esta función no devuelve ningún valor.
Ejemplo.
# include <graphics.h>
# include <dos.h>
# include <stdlib.h>
# include <conio.h>
void main(){
int driver=DETECT,modo,i;
initgraph(&driver,&modo,"c:\\tc20\\BIN");
i=0;
do
{
setcolor(i);
circle(random(639),random(479),random(i+8));/*Random definida en stdlib*/
delay(30000); /*Detiene la ejecución del programa durante 30000 milisegundos*/
i=(i<16)?i:0;
i++;
}while(!kbhit());
}
Función cleardevices
void far cleardevice(void);
Esta función es usada para despejar una pantalla gráfica. La función cleardevice usa el
color de fondo actual, como es establecido por la función setbkcolor, para rellenar la
pantalla. La posición del cursor gráfico es la esquina superior izquierda de la pantalla -
posición (0,0) - después de que la pantalla haya sido borrado.
La función cleardevice no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int relleno, color;
relleno = 1;
color = 1;
setlinestyle( SOLID_LINE, relleno, THICK_WIDTH );
circle( 300, 200, 80 );
setbkcolor( color );
cleardevice();
setlinestyle( SOLID_LINE, relleno, THICK_WIDTH );

circle( 400, 200, 20 );

closegraph();
getch();
}
Función getmaxx
int far getmaxx(void);
Esta función es usada para obtener la coordenada máxima de la pantalla en la dirección

horizontal. Este valor suele ser la resolución horizontal máxima menos 1.
La función getmaxx retorna la coordenada máxima de la pantalla en la dirección

horizontal.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA,modo = EGAHI,x_max;
initgraph( &driver, &modo, "C:\\TC20\\BIN" );
x_max = getmaxx();
closegraph();
printf( "X máxima: %d\n", x_max );
getch();
}
Función getmaxy
int far getmaxy(void);
Esta función es usada para obtener la coordenada máxima de la pantalla en la dirección

vertical. Este valor suele ser la resolución vertical máxima menos 1.
La función getmaxy retorna la coordenada máxima de la pantalla en la dirección vertical.

Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = VGA;
int modo = EGAHI;
int x_max, y_max;
x_max = getmaxx();
y_max = getmaxy();
closegraph();

printf( "X máxima: %d\tY máxima: %d\n", x_max, y_max );

getch();
}
 Rellenos
Es el proceso de rellenar una región de la pantalla con un patrón o color. Turbo C utiliza
dos métodos para definir la región de rellenos. El primero relleno de polígonos, usa la lista
de vértices del polígono para calcular la geometría del interior, El segundo relleno es por
el método de inundación, busca desde un punto inicial llamado la semilla en todas las
direcciones para encontrar una frontera que encierre la regio. La frontera se reconoce
como el valor del píxel que tiene.
Antes de estudiar los dos métodos estudiaremos la función setfillstyle que será de gran
importancia a la hora de realizar los dos tipos de rellenado y bar que es una función
similar a rectangle.
Función bar
void far bar(int izquierda, int superior, int derecha, int inferior);
Esta función dibujará una barra rectangular y rellenada de dos dimensiones. La esquina
superior izquierda de la barra rectangular está definida por los argumentos izquierdos y
superiores. Estos argumentos corresponden a los valores x e y de la esquina superior
izquierda. Similarmente, los argumentos derecha e inferior definen la esquina inferior
derecha de la barra. La barra no tiene borde, pero es rellenada con la trama de relleno
actual y el color de relleno como es establecido por la función setlinestyle.
La función bar no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA,modo = EGAHI, x, y, color,fill;
x = 20;
y = 20;
color = 1;
fill = 1;
do {
setfillstyle( fill, color );
bar( x, y, x+40, 320 );
x += 40;
y += 10;
color = (color+1) % 16;
fill = (fill+1) % 12;
} while( x < 620 );
closegraph();

}
El patrón de relleno se define con las Funciónes setfillstyle y setfillpattern
Función setfillstyle
void far setfillstyle(int trama, int color);
Esta función es usada para seleccionar una trama predefinida y un color de relleno. El
argumento trama especifica la trama predefinida, mientras que el argumento color
especifica el color de relleno. Existen trece valores ya definidos para tramas. Sin
embargo, la trama USER_FILL (valor 12) no debería usarse para asignar una trama
definida por el usuario. En su lugar, se debería usar la función setfillpattern.
La función setfillstyle no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
initgraph( &driver, &modo, "c:\\tc20\\bin" );
setfillstyle( LTSLASH_FILL, 6 );
bar( 50, 50, 350, 300 );
closegraph();
}
LTSLASH_FILL es un estilo de relleno si desea estudiarlos se encuentran en el libro(Ver

pagina # 5 ).
Función setfillpattern
void far setfillpattern(char far *trama, int color);
Esta función es usada para seleccionar una trama de relleno definido por el usuario. El
argumento *trama apunta a una serie de ocho bytes que representa una trama de relleno
de bits de 8 x 8. Cada byte representa una fila de ocho bits, donde cada bit está
encendido o no (1 ó 0). Un bit de 0 indica que el píxel correspondiente será asignado el
color de relleno actual. Un bit de 0 indica que el píxel correspondiente no será alterado. El
argumento color especifica el color de relleno que será usado para la trama.
La función setfillpattern no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {


char trama1[8] = { 0x33, 0xEE, 0x33, 0xEE, 0x33, 0xEE, 0x33, 0xEE };
char trama2[8] = { 0x0A, 0xF0, 0xF0, 0x0A, 0x0A, 0xF0, 0xF0, 0x0A };
bar( 50, 50, 150, 150 );
setfillpattern( trama1, 9 );
bar( 160, 50, 260, 150 );
bar( 105, 160, 205, 260 );
closegraph();
}
1. Relleno por medio de un polígono.
void far fillpoly(int numpuntos, int far *puntos);
Esta función es usada para crear un polígono rellenado. El argumento numpuntos es

usado para definir el número de puntos en el polígono. Al contrario que la función
drawpoly, la función automáticamente cierra el polígono. El argumento *puntos apunta a
un array de números de longitud numpuntos multiplicado por 2.
Los dos primeros miembros del array identifica las coordenadas x e y del primer punto,
respectivamente, mientras que los dos siguientes especifican el siguiente punto, y así
sucesivamente. La función fillpoly dibuja
el perímetro del polígono con el estilo de línea y color actuales. Luego, el polígono es
rellenado con la trama de relleno y color de relleno actuales.
La función fillpoly no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA,modo = EGAHI,trama, color;
int puntos[6] = { 300, 50, 500, 300, 100, 300 };
trama = SLASH_FILL;
for(color=0;color<=15;color++)
{
setfillstyle( trama, color );
fillpoly( 3, puntos );
getch();
}
closegraph();
}

/*Este programa te muestra los diferentes colores con una misma trama trata de
modificarlo para que obtengas todas las tramas con todos los colores*/
2. Relleno por el método de inundación.
void far floodfill(int x, int y, int borde);
Esta función es usada para rellenar un área cerrado con el color de relleno y trama de
relleno actuales. Los argumentos x e y especifican el punto de comienzo para el algoritmo
de relleno. El argumento borde especifica el valor del color del borde del área. Para que la
función fillpoly Funcione como es esperado, el área a ser rellenado debe estar rodeada
por el color especificado por el argumento borde. Cuando el punto especificado por los
argumentos x e y se encuentra dentro del área a ser rellenada, el interior será rellenado.
Si se encuentra fuera del área, el exterior será rellenado.
Nota: Esta función no Funciona con el driver IBM-8514.La función floodfill no retorna
ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA,modo = EGAHI,trama, color;
int puntos[8] = { 300, 50, 500, 300, 100, 300, 300, 50 };
setcolor( 10 ); /*verde*/
drawpoly( 4, puntos );
trama = SLASH_FILL;
for(color = 0;color<=15;color++)
{
floodfill( 400, 250, 10 );
getch();
}
closegraph();
}
 Funciónes de coordenadas relativas
Entre ellas tenemos las Funciónes moveto, moverel, lineto, linerel, getx, gety.
Estudiaremos cada una de ellas para afianzar mas conocimientos.
Función moveto.
void far moveto(int x, int y);

Esta función es usada para colocar el cursor gráfico al punto especificado por los
argumentos x e y. Ya que el cursor es movido desde su posición anterior al punto
especificado por los argumentos x e y, no hay dibujo alguno.
La función moveto no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
moveto( 20, 20 );
lineto( 40, 60 );
lineto( 80, 90 );
getch();
closegraph();
}
Función lineto.
void far lineto(int x, int y);
Esta función es usada para dibujar una línea recta desde la posición actual del cursor
gráfico hasta el punto especificado por los argumentos x e y. La línea se dibuja usando el
estilo de línea actual, el grosor, y el color actual. Después de que la línea recta haya sido
dibujado, la posición del cursor gráfico es actualizado a la posición especificado por los
argumentos x e y (el punto final de la línea).
La función lineto no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA, modo = EGAHI;
moveto( 20, 20 );
lineto( 40, 60 );
lineto( 80, 90 );
getch();
closegraph();
}
Función moverel.
void far moverel(int dx, int dy);

Esta función es usada para mover la posición del cursor gráfico a una distancia relativa
como los argumentos dx y dy. El argumento dx define la distancia relativa a moverse en
la dirección horizontal. El argumento dy define la distancia relativa a moverse en la
dirección vertical. Estos valores pueden ser positivos o negativos. No se dibuja ya que el
cursor es mudado.
La función moverel no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
moveto( 20, 20 );
linerel( 20, 40 );
moverel( 50, 50 );
linerel( 40, 30 );
getch();
closegraph();
}
Función linerel.
void far linerel(int dx, int dy);
Esta función es usada para dibujar una línea recta a una distancia y dirección
predeterminadas desde la posición actual del cursor gráfico. El argumento dx especifica el
número relativo de píxels para atravesar en la dirección horizontal. El argumento dy
especifica el número relativo de píxels para atravesar en la dirección vertical. Estos
argumentos pueden ser tanto valores positivos como negativos. La línea se dibuja usando
el estilo de línea actual, el grosor, y el color actual desde la posición actual del cursor
gráfico a través de la distancia relativa especificada. Cuando la línea esté terminada, la
posición del cursor gráfico es actualizado al
último punto de la línea.
La función linerel no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
moveto( 20, 20 );
linerel( 20, 40 );
linerel( 40, 30 );
getch();
closegraph();

Función getx.
int far getx(void);
Esta función es usada para obtener la posición, en la dirección horizontal, del cursor
gráfico. El valor retornado especifica el lugar del píxel horizontal del cursor gráfico (la
coordenada x), relativo a la pantalla del usuario actual.
La función getx retorna la coordenada x del cursor gráfico.
Ejemplo:
#include <stdio.h>
void main() {
int driver = EGA,modo = EGAHI, x, y;
moveto( 300, 150 );
x = getx();
y = gety();
closegraph();
printf( "Cursor gráfico\n\nX: %d\tY: %d\n", x, y );
}
Función gety.
int far gety(void);
Esta función es usada para obtener la posición, en la dirección vertical, del cursor gráfico.
El valor retornado especifica el lugar del píxel vertical del cursor gráfico (la coordenada y),
relativo a la pantalla del usuario actual.
La función gety retorna la coordenada y del cursor gráfico.
Ejemplo:
#include <stdio.h>
void main() {
int driver = EGA,modo = EGAHI, x, y;
moveto( 300, 150 );
x = getx();
y = gety();
closegraph();
printf( "Cursor gráfico\n\nX: %d\tY: %d\n", x, y );
}

Otras funciones de la librería graphics.h.
En este capitulo describimos una a una las librerías de la librería graphics.h. Las funciones
serán explicadas mediante un orden.
Cuando sabemos como dibujar líneas, círculos, rectángulos, y otras figuras es hora de que
empieces a conocer otro tipo de funciones en las cuales no hacen mucho énfasis los
profesores como lo son las funciones bar3d, palette y otras que presentan una gran gama
de tareas de gran calidad grafica. Dejemos de hablar y comencemos ya que los puedo
aburrir.
Función bar3d
void far bar3d(int izquierda, int superior,int derecha, int inferior, int profundidad, int banderin_tapa);
Esta función creará una barra rectangular y rellenada de tres dimensiones. La esquina
superior izquierda de la barra rectangular más frontal está definida por los argumentos
izquierdos y superiores. Estos argumentos corresponden a los valores x e y de la
esquina superior izquierda del rectángulo más frontal. Similarmente, los argumentos
derecha e inferior definen la esquina inferior derecha del rectángulo más frontal. La barra
tiene borde, en todas las tres dimensiones, rellenada con el color y estilo de línea
actuales. El rectángulo más frontal es rellenado usando la trama de relleno actual y el
color de relleno como es establecido por la función setlinestyle. El argumento
banderin_tapa es usado para especificar si es o no es posible apilar varias barras
encima de cada una. Si banderin_tapa tiene un valor distinto a cero, entonces la barra
está "tapada". Si banderin_tapa tiene un valor de cero, entonces la barra no está
"tapada", permitiendo otras barras ser apiladas encima de ésta.
La función bar3d no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA,modo = EGAHI,color, relleno;
color = 10;
relleno = 11;
initgraph(&driver,&modo,"c:\\tc20\\bin");
setfillstyle( relleno, color );
bar3d( 100, 50, 300, 150, 25, 1 );
closegraph();
getch();
}

Función clearviewport
void far clearviewport(void);
Esta función es usada para rellenar la pantalla actual del usuario con el color de fondo
actual. El color de fondo puede ser establecido con la función setbkcolor. La posición del
cursor gráfico es la esquina superior izquierda de la pantalla actual del usuario. Esta
posición es (0,0) según la pantalla actual del usuario.
La función clearviewport no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int a = EGA,b = EGAHI,color;
initgraph( &a, &b, "C:\\tc20\\BIN" );
setviewport( 150, 150, 350, 350, 0 );
for( color = 0; color<16; color++ ) {
circle( 100, 100, 60 );
getch();
setbkcolor( color );
clearviewport();
}
closegraph();
}
Función closegraph
void far closegraph(void);
Esta función es usada para cerrar el sistema gráfico como es iniciada por la función
initgraph. La función closegraph libera toda la memoria usada por el sistema gráfico y
luego restaura el modo de vídeo al modo de texto que estaba en uso anteriormente a la
llamada a la función initgraph.
La función closegraph no retorna ningún valor.

Ejemplo:
#include <conio.h>
void main() {
initgraph( &driver, &modo, "C:\\tc20\\BIN”);
circle( 300, 200, 80 );
closegraph();

getch();
}
Función detectgraph
void far detectgraph(int far *driver, int far *modo);
Esta función es usada para detectar el adaptador gráfico y el modo óptimo para usar con
el sistema en uso. Si la función detectgraph no puede detectar ningún dispositivo gráfico,
el argumento *driver es asignado grNotDetected (-2). Una llamada a graphresult resultará
en un valor de retorno de -2, o grNotDetected. Existen varios valores que indican los
diferentes dispositivos gráficos que pueden ser usados por el argumento *driver. Un valor
de 0, o DETECT, inicia la Funciónalidad de auto detección, el cual determina el driver
óptimo a usar. Para cada dispositivo existen varios valores que indican los diferentes
modos gráficos que pueden ser usados por el argumento *modo. Sin embargo, si el
argumento *driver es asignado el valor de 0, o DETECT, el argumento *modo es
automáticamente establecido al modo de resolución mas alto para el driver.
La función detectgraph no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver, modo;
detectgraph( &driver, &modo, );
circle( 300, 200, 80 );
closegraph();
printf( "Driver: %d\tModo: %d\n\n", driver, modo );
getch();
}
Función drawpoly
void far drawpoly(int numpuntos, int far *puntos);
Esta función es usada para crear un polígono con un número especificado de puntos. El
argumento numpuntos es usado para definir el número de puntos en el polígono. Para la
función drawpoly, el número de puntos debe ser el número actual de puntos más 1 para
poder crear un polígono cerrado. En otras palabras, el primer punto debe ser igual al último
punto. El argumento *puntos apunta a un array de números de longitud numpuntos
multiplicado por 2. Los dos primeros miembros del array identifica las coordenadas x e y
del primer punto, respectivamente, mientras que los dos siguientes especifican el siguiente
punto, y así sucesivamente. La función drawpoly dibuja el perímetro del polígono con el
estilo de línea y color actuales, pero no rellena el polígono.
La función drawpoly no retorna ningún valor.

Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int puntos[8] = { 300, 50, 500, 300, 100, 300, 300, 50 };
drawpoly( 4, puntos );
closegraph();
getch();
}
Función fillellipse
void far fillellipse(int x, int y,int x_radio, int y_radio);
Esta función es usada para dibujar y rellenar una elipse. El centro de la elipse es
especificado por los argumentos x e y. El argumento x_radio especifica el radio horizontal
y el argumento y_radio especifica el radio vertical de la elipse. La elipse es dibujado con
el perímetro en el color actual y rellenada con el color de relleno y la trama de relleno
actuales.
La función fillellipse no retorna ningún valor.
Ejemplo:
#include <conio.h>
void inicializar(void);
void main() {
int trama, color;
inicializar();
trama = SOLID_FILL;
color = 4;
fillellipse( 300, 150, 100, 50 );
closegraph();
}
void inicializar(void)
{
initgraph( &driver, &modo, "C:\\tc20\\BIn" );
}

Función getarccords
void far getarccoords(struct arccoordstype far *coordenadas_arco);
Esta función es usada para recoger las coordenadas del centro, y los puntos del comienzo
y final de la última llamada con éxito a la función arc. El argumento *coordenadas_arco
apunta a la estructura de tipo arccoordstype que guarda la información recogida. La
sintaxis de la estructura arccoordstype es:
struct arccoordstype {
int x, y;
int xstart, ystart;
int xend, yend;
};
Los miembros x e y definen el centro del arco. Los miembros xstart e ystart definen las
coordenadas x e y del punto de comienzo del arco. Similarmente, los miembros xend e
yend definen las coordenadas x e y del punto de final del arco.
La función getarccoords no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI,radio;
struct arccoordstype info_arco;
for( radio=25; radio<=100; radio+=25 ) {
arc( 300, 150, 45, 315, radio );
getarccoords( &info_arco );
moveto( info_arco.xstart, info_arco.ystart );
lineto( info_arco.xend, info_arco.yend );
}
closegraph();
getch();
}
Función getaspectratio
void far getaspectratio(int far *x_proporcion,int far *y_proporcion);
Esta función es usada para obtener la proporción anchura-altura del modo gráfico actual.
La proporción anchura-altura puede definirse como la proporción de la anchura del píxel
del modo gráfico y la altura del píxel. Esta proporción, usando los modos gráficos
existentes, es siempre menor o igual que 1. El valor para determinar la proporción

anchura-altura con respecto al eje horizontal es retornado en el argumento

*x_proporcion. Similarmente, el valor para el eje vertical es retornado en el argumento
*y_proporcion. El argumento *y_proporcion es asignado 10000, el cual es retornado
cuando se llama a la función getaspectratio. El argumento *x_proporcion es casi siempre
menor que el valor de *y_proporcion. Esto es debido al hecho de que la mayoría de los
modos gráficos tiene píxeles más altos que anchos. La única excepción es en los modos
de VGA que produce píxeles cuadrados; es decir, x_proporcion = y_proporcion.
La función getaspectratio no retorna ningún valor, directamente.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int x_proporcion, y_proporcion;
getaspectratio( &x_proporcion, &y_proporcion );
circle( 300, 150, 50 );
closegraph();
printf( "Proporción anchura-altura.\nFactor x: %d\tFactor y: %d\n",
x_proporcion, y_proporcion );
getch();
}
Función getcolor
int far getcolor(void);
Esta función obtiene el valor del color actual. El color actual es el color usado para dibujar
líneas, arcos, etc.. Este color no es el mismo que el color de relleno. El valor del color
obtenido es interpretado según el modo que esté en uso. Existen varios valores para
ciertos colores de fondo.
La función getcolor retorna el valor del color actual.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI,color;
initgraph( &driver, &modo, "C:\\Tc20\\BIN" );
setcolor( 4 );
circle( 300, 150, 50 );
color = getcolor();

closegraph();
printf( "Color del perímetro: %d\n", color );
getch();
}
Función getdefaultpalette
struct palettetype far *getdefaultpalette(void);
Esta función es usada para obtener una estructura que define la paleta según el
dispositivo en la inicialización - esto es, cuando se llama a initgraph. La estructura
palettetype se define de la siguiente manera:
#define MAXCOLORS 15
struct palettetype {
unsigned char size;
signed char colors[MAXCOLORS+1];
}
El campo size indica el tamaño de la paleta. El campo colors contiene los valores
numéricos que representan los colores que ofrece el dispositivo en su paleta de colores.
La función getdefaultpalette retorna un puntero a una estructura del tipo palettetype.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
struct palettetype *palette = NULL;
int i;
palette = getpalettetype();
circle( 300, 150, 50 );
closegraph();
printf( "Paleta\n\nTamaño: %d\nColores: %d",
palette->size, palette->colors[0] );
for( i=1; i<palette->size; i++ )
printf( ", %d", palette->colors[i] );
printf( "\n" );
getch();
}

Función getdrivename
char *far getdrivername(void);
Esta función es usada para obtener una cadena de caracteres que contiene el nombre del
dispositivo gráfico actual. Esta función debería ser llamada después de que un dispositivo
haya sido definido e inicializado – esto es, después de llamar a initgraph.
La función getdrivername retorna una cadena de caracteres conteniendo el nombre del

dispositivo gráfico.
Ejemplo:
#include <conio.h>
#include <stdio.h>
#include <string.h>
void main() {
char *nombre;
strcpy( nombre, getdrivername() );
circle( 300, 150, 50 );
closegraph();
printf( "Nombre del dispositivo gráfico: %s\n", nombre );
getch();}
Función getfillpattern
void far getfillpattern(char far *trama);
Esta función es usada para obtener una trama de relleno definido por el usuario, como es
definida por la función setfillpattern, y la guarda en memoria. El argumento *trama es un
puntero a una serie de ocho bytes que representa una trama de relleno de bits de 8 x 8.
Cada byte representa una fila de ocho bits, donde cada bit está encendido o no (1 ó 0).
Un bit de 0 indica que el píxel correspondiente será asignado el color de relleno actual. Un
bit de 0 indica que el píxel correspondiente no será alterado.
La función getfillpattern no retorna ningún valor, directamente.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
char trama1[8] = { 0x33, 0xEE, 0x33, 0xEE, 0x33, 0xEE, 0x33, 0xEE };

char trama2[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
getfillpattern( trama2 );
bar( 50, 50, 150, 150 );
bar( 160, 50, 260, 150 );
bar( 105, 160, 205, 260 );
closegraph();
getch();
}
Función getfillsettings
void far getfillsettings(struct fillsettingstype far *info);
Esta función es usada para obtener la información de tramas de relleno. El argumento

*info apunta a una estructura de tipo fillsettingstype, el cual es actualizado cuando se
llama a la función getfillsettings. La estructura es:
struct fillsettingstype {
int pattern;
int color;
};
El campo pattern es la trama y el campo color es el color de relleno de la trama.
Existen trece valores ya definidos para tramas.
La función getfillsettings no retorna ningún valor, directamente.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
struct fillsettingstype info;
getfillsettings( &info );
bar( 50, 50, 350, 300 );
closegraph();
printf( "Trama de relleno: %d\tColor de relleno: %d\n", info.pattern, info.color );
getch();
}

Función getgraphmode
int far getgraphmode(void);
Esta función es usada para obtener el valor del modo gráfico actual. El dispositivo actual
debe ser considerado cuando se interprete el valor de retorno. Esta función sólo debería
ser llamada después de que el sistema gráfico haya sido inicializado con la función
initgraph. Existen varios valores para los modos de cada dispositivo.
La función getgraphmode retorna el modo gráfico como es establecido por initgraph o

setgraphmode.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA, modo = EGAHI,modo;
modo = getgraphmode();
bar( 50, 50, 350, 300 );
closegraph();
printf( "Modo gráfico: %d\n", modo );
getch();
}
Función getlinesettings
void far getlinesettings(struct linesettingstype far *info);
Esta función obtiene la información actual para las líneas. Esta información es guardada
en una estructura de tipo linesettingstype que es apuntado por el argumento *info. El
estilo de línea, trama, y grosor actuales son guardados en esta estructura. La sintaxis
para la estructura linesettingstype:
struct linesettingstype {
int linestyle;
unsigned upattern;
int thickness;
}
El campo linestyle es el estilo de la línea recta. El campo upattern es la trama de la línea

del usuario solamente cuando el campo linestyle es igual a USERBIT_LINE, ó 4. Cuando
esto sea el caso, el miembro upattern contiene una trama de línea definido por el usuario
de 16 bits. Un bit 1 en esta trama indica que el píxel correspondiente será asignado el
color actual. Un bit 0 indica que el píxel correspondiente no será alterado. El campo

thickness es el grosor de la línea. Existen varios valores para los diferentes estilos y
grosores de líneas rectas.
La función getlinesettings no retorna ningún valor, directamente.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
struct linesettingstype info;
setlinestyle( DOTTED_LINE, 0xFF33, THICK_WIDTH );
circle( 350, 250, 50 );
getlinesettings( &info );
closegraph();
printf( "Líneas rectas.\nEstilo: %d\tTrama: %X\tGrosor: %d\n",
info.linestyle, info.upattern, info.thickness );
getch();
}
Función getmaxcolor
int far getmaxcolor(void);
Esta función es usada para obtener el valor más alto de color en la paleta actual. La
paleta en uso depende del dispositivo y modo inicializados. Para los modos de 16 colores,
el valor de retorno es 15. Similarmente, para los modos de dos colores, el valor de retorno
es 1.
La función getmaxcolor retorna el valor máximo del color en la paleta en uso.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver =EGA,modo =EGAH,color_max;
color_max = getmaxcolor();
closegraph();
printf( "Color m ximo: %d\n", color_max );
getch();
}

Función getmodename
char *far getmodename(int num_modo);
Esta función es usada para obtener el nombre del modo gráfico especificado por el
argumento num_modo.
La función getmodename retorna el nombre del modo gráfico que está contenido en todos
los dispositivos gráficos.
Ejemplo:
#include <conio.h>
#include <stdio.h>
#include <string.h>
void main() {
int driver = IBM8514;
int modo = IBM8514HI,i;
char *nombre;
int num_modo;
initgraph( &driver, &modo,"C:\\TC20\\BIN");
num_modo = getgraphmode();
strcpy(nombre,getmodename(num_modo));
closegraph();
for(i=0;nombre[i];i++)
printf("%c",nombre[i]);
getch();
}
Función getmoderange
void far getmoderange(int driver, int far *modo_bajo, int far *modo_alto);
Esta función es usada para obtener los valores altos y bajos del modo gráfico del
dispositivo especificado por el argumento driver. El valor más bajo del modo es retornado
en *modo_bajo, y el valor más alto del modo es retornado en *modo_alto. Si el
dispositivo especificado es inválido, el valor de -1 es retornado en ambos argumentos:
*modo_bajo y *modo_alto. Sin embargo, si el argumento driver es asignado -1, los
modos alto y bajo del dispositivo actual son retornados.
La función getmoderange no retorna ningún valor, directamente.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {

int driver = EGA;

int modo = EGAHI;
int modo_bajo, modo_alto;
getmoderange( driver, &modo_bajo, &modo_alto );
closegraph();
printf( "Alcance de modos, de %d á %d\n", modo_bajo, modo_alto );
getch();
}
Función getpalette
void far getpalette(struct palettetype far *paleta);
Esta función es usada para obtener la información de la paleta actual. El argumento

*paleta apunta a una estructura del tipo palettetype donde la información de la paleta es
guardada. La estructura palettetype se define de la siguiente manera:
unsigned char size;
}
El campo size indica el número de colores en la paleta. El campo colors contiene los
valores numéricos que representan los colores que ofrece el dispositivo en su paleta de
colores.
La función getpalette no retorna ningún valor, directamente.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI,i;
struct palettetype palette;
getpalette( &palette );
closegraph();
printf( "\t\t\t\t\tPaleta\n\nTama¤o: %d\n",palette.size);
printf("Colores: %d,",palette.colors[0] );
for( i=1; i<palette.size; i++ )
printf( "%d, ", palette.colors[i] );
printf( "\n" );
getch();
}

Función getpalettesize
int far getpalettesize(void);
Esta función es usada para obtener el número de entradas de paleta válidas para la
paleta actual, considerando el modo gráfico en uso.
La función getpalettesize retorna el número de colores en la paleta actual. Para modos de

16 colores, la función getpalettesize retorna 16.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int num_colores;
num_colores = getpalettesize();
closegraph();
printf( "Paleta\n\nNúmero de colores: %d\n", num_colores );
getch();
}
Función getpixel
unsigned far getpixel(int x, int y);
Esta función es usada para obtener el valor del color del píxel especificado por los
argumentos x e y. Estos argumentos especifican las coordenadas de la pantalla del píxel
a ser evaluado. Cuando se evalúa el valor del color retornado, el modo gráfico en uso
debe ser considerado. Existen varios valores para describir colores.
La función getpixel retorna el número del color del píxel especificado.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA, modo = EGAHI, x, y, color;
x = 300;
y = 100;
setfillstyle( SOLID_FILL, 2 );

fillellipse( 300, 160, 50, 150 );

color = getpixel( x, y );
getch();
closegraph();
printf( "Colores\n\nEl color del píxel (%d,%d): %d\n", x, y, color );
getch();
}
Función gettextsettings
void far gettextsettings(struct textsettingstype far *info);
Esta función es usada para obtener información acerca de la fuente gráfica actual. Esta
información es guardada en una estructura de tipo textsettingstype, la cual es apuntada
por el argumento *info. Esta estructura contiene información de la fuente actual en uso, la
orientación del texto, el tamaño del carácter, y la justificación horizontal y vertical. La
síntaxis de la estructura textsettingstype es la siguiente:
struct textsettingstype {
int font;
int direction;
int charsize;
int horiz;
int vert;
};
Existen varios valores para describir el tipo, la orientación, y justificación de fuentes.
La función gettextsettings no retorna ningún valor.
Ejemplo:
# include<conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
struct textsettingstype info;
gettextsettings( &info );
closegraph();
printf( "Texto\n\nFuente: %d\tSentido: %d\tTamaño: %d\n""Justificación:\nHorizontal: %d,
Vertical: %d\n",
info.font, info.direction, info.charsize, info.horiz, info.vert);
getch();
}
Función getviewsettings
void far getviewsettings(struct viewporttype far *info);

Esta función es usada para obtener información acerca del área gráfica actual. Esta
información es guardada en una estructura de tipo viewporttype, la cual es apuntada por
el argumento *info. Esta estructura contiene información acerca de las esquinas superior
izquierda e inferior derecha, también como el banderín de recorte del área gráfica. La
síntaxis de la estructura viewporttype es la siguiente:
struct viewporttype {
int left, top;
int right, bottom;
int clip;
};
La función getviewsettings no retorna ningún valor, directamente.
Ejemplo:
# include<conio.h>
#include <stdio.h>
void main() {
int driver = VGA, modo = VGAHI;
struct viewporttype info;
getviewsettings( &info );
closegraph();
printf( "\t\t\t\tPantalla\n\nIzquierda: %d\tSuperior: %d\tDerecha: %d\t"
"Inferior: %d\tBander¢n: %d\n",
info.left, info.top, info.right, info.bottom, info.clip );
getch();
}
Función graphdefaults
void far graphdefaults(void);
Esta función es usada para reiniciar todos los datos gráficos a sus valores originales, o
por defecto. La función graphdefaults reinicia la pantalla del usuario para que cubra la
pantalla entera, mueve el cursor a la posición (0,0), y reinicia la paleta actual a sus colores
por defecto. También reinicia el color de fondo y el actual a sus valores por defecto,
reinicia el estilo y trama de relleno a sus valores por defecto, y reinicia la fuente y
justificación de texto.
La función graphdefaults no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = VGA;

int modo = VGAHI;

setcolor( 4 );
setviewport( 250, 150, 350, 250, 1 );
graphdefaults();
circle( 300, 200, 50 );
getch();
closegraph();
getch();
}
Función grapherrormsg
char *far grapherrormsg(int codigo_error);
Esta función es usada para obtener una cadena de caracteres conteniendo el mensaje de
error para un código de error especificado. El argumento codigo_error específica el valor
del código de error. La función graphresult debe ser usada para obtener el código de error
usado para el argumento codigo_error.
La función grapherrormsg retorna una cadena de caracteres.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int codigo_error;
char *mensaje_error;
setgraphmode( 40 ); /* Creamos un ERROR */
codigo_error = graphresult();
strcpy( mensaje_error, grapherrormsg( codigo_error ) );
closegraph();
printf( "ERROR: \"%s\" (%d)\n", mensaje_error, codigo_error );
getch();
}
Función graphfreemem
void far _graphfreemem(void far *ptr, unsigned tamanyo);
Esta función es usada por la librería gráfica para desadjudicar memoria previamente
reservada mediante una llamada a la función _graphgetmem. Esta función es llamada por
la librería gráfica cuando se quiere liberar memoria. Por defecto, la función simplemente
llama a free, pero se puede controlar la administración de memoria de la librería gráfica.
La forma de hacer esto es simplemente creando la definición de la función, con el mismo
prototipo mostrado aquí.

La función _graphfreemem no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
void far _graphfreemem( void far *ptr, unsigned tamanyo ) {
printf( "__graphfreemem ha sido llamado para "
"desadjudicar %d bytes en memoria\n" );
printf( "para el montón (heap) interno\n", tamanyo );
printf( "Pulse cualquier tecla...\n\n" );
getch();
free( ptr );
}
void far * far _graphgetmem( unsigned tamanyo ) {
printf( "__graphgetmem ha sido llamado para "
"adjudicar %d bytes en memoria\n" );
getch();
return malloc( tamanyo );
}
void main() {
circle( 200, 100, 50 );
getch();
closegraph();
getch();
}
Función graphgetmem
void far * far _graphgetmem(unsigned tamanyo);
Esta función es usada por la librería gráfica para adjudicar memoria gráfica para búferes
internos, dispositivos gráficos, y fuentes. Esta función tiene como intención ser llamada
por la librería gráfica cuando se quiere adjudicar memoria. Por defecto, la función
simplemente llama a malloc, pero se puede controlar la administración de memoria de la
librería gráfica. La forma de hacer esto es simplemente creando la definición
de la función, con el mismo prototipo mostrado aquí.
La función _graphgetmem no retorna ningún valor.
Ejemplo:
#include <conio.h>

#include <stdio.h>
#include <stdlib.h>
void far _graphfreemem( void far *ptr, unsigned tamanyo ) {
printf( "__graphfreemem ha sido llamado para "
"desadjudicar %d bytes en memoria\n" );
getch();
free( ptr );
}
void far * far _graphgetmem( unsigned tamanyo ) {
printf( "__graphgetmem ha sido llamado para "
"adjudicar %d bytes en memoria\n" );
getch();
return malloc( tamanyo );
}
void main() {
circle( 200, 100, 50 );
getch();
closegraph();
getch();
}
Función graphresult
int far graphresult(void);
Esta función obtiene y retorna el código de error para la última llamada sin éxito. Además,
reinicia el nivel de error a 0, o grOk. Existen varios valores de códigos de error.
La función graphresult retorna el código de error de la última llamada gráfica sin éxito.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int codigo_error;
char *mensaje_error;
setgraphmode( 40 ); /* Creamos un ERROR debe de ser 0 o 1*/
codigo_error = graphresult();
strcpy( mensaje_error, grapherrormsg( codigo_error ) );
closegraph();

printf( "ERROR: \"%s\" (%d)\n", mensaje_error, codigo_error );

getch();
}
Función installuserdriver
int far installuserdriver(char far *nombre, int huge (*detectar)(void));
Esta función permite al usuario añadir dispositivos adicionales de otras compañías o

grupos a la tabla interna BGI de los dispositivos. El argumento *nombre define el nombre
del fichero nuevo del dispositivo .BGI. El parámetro *detectar es un puntero a una función
opcional para autodetectar que puede ser o no ser provisto con el dispositivo nuevo. La
función de autodetectación espera no recibir ningún parámetro y retorna un valor entero.
La función installuserdriver retorna el parámetro del número del dispositivo que

hubiese sido pasado a la función initgraph para seleccionar un dispositivo nuevo.
Ejemplo:
/* Este programa no Funcionará, ya que se

necesitaría otra tarjeta gráfica
desconocida por las librerías gráficas de BGI.
Esto sólo es para poner un ejemplo.*/
#include <conio.h>
int huge detectarSMGGA( void ) {
int driver, modo, modo_sugerirdo=0;
detectgraph( &driver, &modo );
if( SMGGA == driver ) return modo_sugerido;
return grError;
}
void main() {
int driver, modo;
/* Intentamos instalar nuestra tarjeta gráfica:
** Súper Mega Guay Graphics Array (SMGGA)
** Ya sé que suena muy cursi, pero esto sólo es un ejemplo :)
*/
driver = installuserdriver( "SMGGA", detectarSMGGA );
/* Forzamos a que use nuestra función para autodetectar */
driver = DETECT;
closegraph();
getch();
}
Función installuserfont
int far installuserfont(char far *nombre);

Esta función carga un fichero de fuente escalable que no está provisto con el sistema BGI.
El parámetro *nombre especifica el nombre del fichero fuente a cargar, en el directorio de
inicio. El sistema gráfico puede tener hasta veinte fuentes instaladas a la vez.
La función installuserfont retorna el número de identificación de la fuente que es usada

para seccionar la fuente nueva a través de la función settextstyle. Si la tabla interna de
fuentes está llena, un valor de -11 (grError) es retornado, indicando un error.
Ejemplo
/* Este programa no Funcionará, ya que se

* necesitaría tener una fuente nueva
* y desconocida por las librerías gráficas de BGI.
* Esto sólo es para poner un ejemplo.
*/
#include<stdio.h>
# include<conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int fuente_SMCF;
initgraph( &driver, &modo,"C:\\TC20\\BIN" );
/* Intentamos instalar nuestra fuente nueva:
** Súper Mega Chula Fuente (SMCF)
** Ya sé que suena muy cursi, pero esto sólo es un ejemplo :)
*/
if( (fuente_SMGF = installuserfont( "SMGF.CHR" )) != grError ){
settextstyle( fuente_SMGF, HORIZ_DIR, 4 );
printf("Instalación completada");getch();}
else{
settextstyle( DEFAULT_FONT, HORIZ_DIR, 4 );
printf("Error de al instalar la aplicación");getch();}
closegraph();
getch();
}
Función kbhit
int kbhit(void);
Revisa si se ha presionado una tecla. Cualesquier pulsadas disponibles pueden ser

recogidas con las Funciones getch o getche.
La función kbhit retorna 0 si no se ha registrado una pulsada de tecla; si lo fue, entonces

el valor retornado es distinto a cero.
Veremos el uso de esta función en el modo grafico; para utilizar esta función se tiene que
declarar la cabecera conio.h

Ejemplo:
#include <conio.h>
# include <dos.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI,i;
setcolor(BLUE);
i=1;
do{ delay(30000);
rectangle(10+i,10,100+i,100);
setfillstyle(i,BLUE);
floodfill(20,20,BLUE);
i++;
}while(!kbhit());
}
Función outtext
void far outtext(char far *cadena_texto);
Esta función es usada para mostrar una cadena de caracteres. El argumento

*cadena_texto define la cadena de texto a ser mostrado. La cadena es mostrado donde
está el cursor gráfico actualmente usando el color actual y fuente, dirección, valores, y
justificaciones de texto. La posición del cursor permanece sin ser cambiado al
menos que la justificación horizontal actual es LEFT_TEXT y la orientación del texto es
HORIZ_DIR. Cuando esto sea el caso, la posición del cursor es colocada horizontalmente
a la anchura del píxel de la cadena de texto. Además, cuando se use la fuente por
defecto, cualquier texto que se extiende a fuera del área gráfica actual es truncado.
Aunque la función outtext está diseñada para texto sin formato, texto con formato puede
ser mostrada a través del uso de un búfer de caracteres y la función sprintf.
La función outtext no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
char mensaje[40];
char nombre[25];
printf( "Escribe tu nombre: " );

scanf( "%s", nombre );

sprintf( mensaje, "Hola %s!", nombre );
outtext( mensaje );
outtextxy( 300, 150, mensaje );
getch();
closegraph();
getch();
}
Función outtextxy
void far outtextxy(int x, int y, char far *cadena_texto);
Esta función es usada para mostrar una cadena de caracteres. El argumento

*cadena_texto define la cadena de texto a ser mostrado. La cadena es mostrada en la
posición descrita por los argumentos x e y usando el color actual y fuente, dirección,
valores, y justificaciones de texto. Cuando se use la fuente por defecto, cualquier texto
que se extiende fuera del área gráfica actual es truncado. Aunque la función outtextxy
está diseñada para texto sin formato, texto con formato puede ser mostrada a través del
uso de un búfer de caracteres y la función sprintf.
La función outtextxy no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
char mensaje[40];
char nombre[25];
outtext( mensaje );
getch();
closegraph();
getch();
}
Función pieslice
void far pieslice(int x, int y,int comienzo_angulo, int final_angulo, int radio);
Esta función es usada para dibujar y rellenar un una cuña circular. La cuña circular está
centrada en el punto especificado por los argumentos x e y. La porción circular de la cuña

comienza con el ángulo especificado por el argumento comienzo_angulo y se extiende

en un sentido contrario a las agujas del reloj al ángulo especificado por el argumento
final_angulo. La función pieslice considera este – el eje horizontal a la derecha del centro
– como su punto de referencia de 0 grados. El perímetro de la cuña es dibujado con el
color actual y es rellenado con la trama y color de relleno actual.
La función pieslice no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
pieslice( 300, 150, 45, 225, 50 );
closegraph();
getch();
}
Función registerbgidriver
int registerbgidriver(void (*driver)(void));
Esta función es usada para cargar y registrar un dispositivo gráfico. El argumento *driver
apunta a un dispositivo. Un fichero de dispositivo registrado puede ser tanto cargado
desde el disco o convertido en un formato .OBJ y ligado (o enlazado) dentro del
programa. Registrando el dispositivo de esta manera, el fichero .EXE no depende de un
fichero externo de dispositivo para poder ejecutarse.
La función registerbgidriver retorna número del dispositivo cuando tiene éxito. Un código
de error, un número negativo, es retornado si el dispositivo especificado es inválido.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
registerbgidriver(IBM8514LO);
rectangle( 20, 20, 400, 300 );
closegraph();
getch();
}

Función registerbgifont
int registerbgifont(void (*fuente)(void));
Esta función es usada para informar al sistema que la fuente apuntada por el argumento
*fuente fue incluida durante el enlazo. Un fichero de fuente registrado ha de ser
convertido en un fichero objeto .OBJ y ligado (o enlazado) dentro del programa.
Registrando la fuente de esta manera, el fichero .EXE no depende de un fichero externo
de fuentes para poder ejecutarse.
Nota: La fuente de defecto es la única que está disponible en el programa, ya que forma
parte del sistema gráfico; no es necesario ligarlo al programa.
La función registerbgifont retorna número del dispositivo cuando tiene éxito. Un código de
error, un número negativo, es retornado si el dispositivo especificado es inválido.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
registerbgifont(1);
initgraph( &driver, &modo,"C:\\TC20\\BIN" );
outtext( "Esto es una prueba con la fuente \"Sans Serif\"" );
closegraph();
getch();
}
Función restorecrtmode
void far restorecrtmode(void);
Esta función es usada para reiniciar el modo gráfico del vídeo al modo en uso anterior a la
inicialización del sistema gráfico. Esta función suele ser usada en conjunción con la
función setgraphmode para cambiar entre ambos modos de texto y de gráficos.
La función restorecrtmode no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;

int modo = EGAHI;

outtext( "Esto es una prueba para cambiar entre modo gráfico..." );
getch();
restorecrtmode();
printf( "...y en modo texto.\nPulsa una tecla para volver\n" );
getch();
setgraphmode( modo );
rectangle( 200, 100, 400, 250 );
closegraph();
getch();
}
Función sector
void far sector(int x, int y, int comienzo_angulo, int final_angulo, int x_radio, int y_radio);
Esta función es usada para dibujar y rellenar la parte de una elipse. El centro de la cuña
elíptica es especificado por los argumentos x e y. El argumento x_radio especifica el
radio horizontal y el argumento y_radio especifica el radio vertical de la cuña elíptica. La
cuña elíptica comienza al ángulo especificado por el argumento comienzo_angulo y es
dibujado en la dirección contraria al de las agujas del reloj hasta llegar al ángulo
especificado por el argumento final_angulo. La cuña elíptica es dibujado con el perímetro
en el color actual y rellenada con el color de relleno y la trama de relleno actuales.
La función sector no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
sector( 300, 150, 45, -45, 150, 50 );
closegraph();
getch();
}
Función setactivepage
void far setactivepage(int pagina);
Esta función es usada para especificar un número de página que representa una sección
de memoria del vídeo donde todos los datos gráficos para mostrar son enviados. Está
sección de memoria se denomina una página activa. El argumento pagina específica el
número de la página activa. Para usar esta función con eficacia, el adaptador de vídeo
usado debe ser EGA o VGA y tener suficiente memoria para soportar múltiples páginas

para gráficos. Esta función es usada con la función setvisualpage para dibujar páginas no
visuales y para crear animación.
La función setactivepage no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int visual=1;
printf( "Instrucciones:\nPulsa el espacio para cambiar de "
"página, cualquier otra tecla para salir\n" );
printf( "(Pulsa cualquier tecla para entrar en modo gráfico)\n" );
getch();
setactivepage( 0 );
sector( 300, 150, 45, 315, 150, 50 );
setactivepage( 1 );
sector( 300, 150, 90, 270, 150, 50 );
while( getch() == ' ' ) {
setvisualpage( visual );
visual = 0==visual ? 1 : 0;
}
closegraph();
getch();
}
Función setallpalette
void far setallpalette(struct palettetype far *paleta);
Esta función es usada para asignar la paleta actual a la paleta definida en la estructura del
tipo palettetype que es apuntado por el argumento *paleta. Todos los colores de la paleta
actual son asignados a aquéllos definidos en la estructura palettetype. La síntaxis de la
estructura palettetype es:
unsigned char size;
}
El campo size indica el número de colores de la paleta actual. El campo colors es un

array que contiene los valores numéricos que representan los colores que ofrece el

dispositivo en su paleta de colores. Si la entrada de cualquier elemento del array es -1, el

valor del color de ese elemento no cambiará.
Nota: Recuerda que todos los cambios hechos a la paleta tiene un efecto visual inmediato
y que la función setallpalette no debería usarse con el dispositivo IBM-8514.
La función setallpalette no retorna ningún valor; sin embargo, si los valores pasados son
inválidos, entonces la función graphresult retorna grError (-11) y la paleta no es alterada.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int size, temp, i, y=0;
size = palette.size;
for( i=0; i<size; i++ ) {
y += 30;
setcolor( palette.colors[i] );
line( 20, y, 520, y );
}
for( i=0; i<size/2; i++ ) {
temp = palette.colors[i];
palette.colors[i] = palette.colors[size-1-i];
palette.colors[size-1-i] = temp;
}
setallpalette( &palette );
closegraph();
getch();
}
Función setaspectratio
void far setaspectratio(int x_proporcion, int y_proporcion);
Esta función es usada para modificar la proporción anchura-altura del modo gráfico actual.
La proporción anchura-altura puede definirse como la proporción de la anchura del píxel
del modo gráfico y la altura del píxel. Esta proporción es usada por el sistema gráfico para
calcular círculos y arcos. Por ello, alterando la proporción anchura-altura afectará la
visualización de estas Funciones. La función getaspectratio puede ser usada para obtener
las opciones por defecto del modo actual anteriormente a ser modificados.
La función setaspectratio no retorna ningún valor.

Ejemplo:
#include <conio.h>
void main() {
int driver = EGA, modo = EGAHI,x_proporcion, y_proporcion;
getaspectratio( &x_proporcion, &y_proporcion );
circle( 300, 150, 50 );
setaspectratio( 2*x_proporcion, y_proporcion );
circle( 300, 150, 50 );
closegraph();
getch();
}
Función setgraphbufsize
unsigned far setgraphbufsize(unsigned bufer_tam);
Esta función es usada para cambiar el tamaño del búfer gráfico interno como es asignado
por la función initgraph cuando el sistema gráfico es inicializado. El búfer gráfico es usado
por varias Funciones gráficos; por ello, se debería tener un mayor cuidado cuando se
altera este búfer del tamaño por defecto de 4096. La función setgraphbufsize se debería
llamar antes de llamar a la función initgraph.
La función setgraphbufsize retorna el tamaño anterior del búfer gráfico interno.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int buf_inicial, buf_nuevo=10000;
buf_inicial = setgraphbufsize( buf_nuevo );
closegraph();
printf( "Búfer inicial: %d\tBúfer nuevo: %d\n", buf_inicial, buf_nuevo );
getch();
}
Función setgraphmode
void far setgraphmode(int modo);

Esta función es usada para seleccionar el modo gráfico actual pero solamente cuando el
sistema gráfico haya sido inicializado con la función initgraph. El argumento modo define
el modo a usar según el dispositivo actual. Además de seleccionar un nuevo modo, la
función setgraphmode despeja la pantalla y reinicia todas las opciones gráficas a sus

valores por defecto. Esta función suele usarse conjuntamente con restorecrtmode para
cambiar entre modos gráficos y de texto.
La función setgraphmode no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
outtext( "Esto es una prueba para cambiar entre modo gráfico..." );
getch();
restorecrtmode();
printf( "...y en modo texto.\nPulsa una tecla para volver\n" );
getch();
setgraphmode( modo );
rectangle( 200, 100, 400, 250 );
closegraph();
getch();
}
Función setlinestyle
void far setlinestyle(int estilo,unsigned trama, int grosor);
Esta función es usada para definir las características de líneas para líneas rectas.
El argumento estilo específica la trama de línea predefinida para su uso. El argumento
trama es una trama de 16 bits que describe el estilo de línea cuando el argumento estilo
es USERBIT_LINE, ó 4. Un bit 1 en esta trama indica que el píxel correspondiente será
asignado el color actual. Un bit 0 indica que el píxel correspondiente no será alterado. El
argumento grosor define el grosor de la línea. Existen varios valores para los diferentes
estilos y grosores de líneas rectas.
La función setlinestyle no retorna ningún valor; sin embargo, si un argumento es inválido,

entonces la función graphresult retorna grError (11).
Ejemplo:
#include <conio.h>
void main() {
setlinestyle( DOTTED_LINE, 0, THICK_WIDTH );
line( 200, 300, 400, 50 );
closegraph();

getch();
}
Función setpalette
void far setpalette(int num_paleta, int color);
Esta función es usada para modificar una sola entrada en la paleta actual. El argumento
num_paleta especifica el miembro de la paleta a cambiar. El argumento color especifica
el nuevo valor de color para el miembro de la paleta. Existen varios valores para los
colores dependiendo del dispositivo.
y que la función setpalette no debería usarse con el dispositivo IBM-8514.
La función setpalette no retorna ningún valor; sin embargo, si los valores pasados son
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int size, temp, i, y=0;
y += 30;
line( 20, y, 520, y );
}
for( i=0; i<size/2; i++ ) {
temp = palette.colors[i];
setpalette( i, palette.colors[size-1-i] );
setpalette( size-1-i, temp );
}
closegraph();
getch();
}
Función setrgbpalette
void far setrgbpalette(int num_paleta,int rojo, int verde, int azul);
Esta función es para usarse con los dispositivos de IBM 8514 y VGA. El argumento
num_paleta especifica el miembro de la paleta a ser modificado. Para la IBM 8514 (y

para el modo de 256K de la VGA), el intervalo de la paleta es de 0 á 255. Para los modos
de VGA, el intervalo es de 0 á 15. Los argumentos rojo, verde, y azul especifican la
intensidad del color para el miembro de la paleta. De cada byte (de cada argumento) sólo
los seis bits más significativos son cargados en la paleta. Por razones de compatibilidad
con otros adaptadores gráficos de IBM, el dispositivo BGI define las primeras dieciséis
entradas a la paleta de la IBM 8514 a los colores por defecto de la EGA/VGA.
y que la función setrgbpalette no debería usarse con el dispositivo IBM-8514.
La función setrgbpalette no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int size, i, y=0;
y += 30;
line( 20, y, 520, y );
}
for( i=0; i<size; i++ )
setrgbpalette( i, 2*i+33, 42, 63-4*i ); /* Tonos de naranja y azul */
closegraph();
getch();
}
Función settextjustify
void far settextjustify(int horizontal, int vertical);
Esta función es usada para especificar el método en el cual el texto es colocado en la

pantalla con relación a la posición del cursor. El argumento horizontal define la
justificación horizontal, mientras que el argumento vertical indica la justificación vertical.
Existen varios valores y constantes para las justificaciones.
La función settextjustify no retorna ningún valor; sin embargo, si los valores pasados son
Ejemplo:

#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
settextjustify( RIGHT_TEXT, BOTTOM_TEXT );
moveto(300, 200);
outtext( "(RIGHT_TEXT, BOTTOM_TEXT)" );
settextjustify( RIGHT_TEXT, TOP_TEXT );
moveto(300, 200);
outtext( "(RIGHT_TEXT, TOP_TEXT)" );
settextjustify( LEFT_TEXT, BOTTOM_TEXT );
moveto(300, 200);
outtext( "(LEFT_TEXT, BOTTOM_TEXT)" );
settextjustify( LEFT_TEXT, TOP_TEXT );
moveto(300, 200);
outtext( "(LEFT_TEXT, TOP_TEXT)" );
setcolor( 1 );
line( 300, 200, 300, 100 );
setcolor( 2 );
line( 300, 200, 300, 300 );
setcolor( 3 );
line( 300, 200, 100, 200 );
setcolor( 4 );
line( 300, 200, 500, 200 );
getch();
closegraph();
getch();
}
Función settextstyle
void far settextstyle(int fuente,int orientacion, int tam_caracter);
Esta función es usada para especificar las características para la salida de texto con
fuente. El argumento fuente especifica la fuente registrada a usar. La fuente ha de estar
registrada para resultados predecibles; es decir, usa registerbgifont antes de usar esta
función. El argumento orientacion especifica la orientación en que el texto ha de ser
mostrado. La orientación por defecto es HORIZ_DIR. El argumento tam_caracter define l
factor por el cual la fuente actual será multiplicada. Un valor distinto a 0 para el argumento
tam_caracter puede ser usado con fuentes escalables o de bitmap. Sin embargo, un
valor distinto a 0 para el argumento tam_caracter, el cual selecciona el tamaño del
carácter definido por el usuario usando la función setusercharsize, solamente Funciona
con fuentes escalables. El argumento tam_caracter puede agrandar el tamaño de la
fuente hasta 10 veces su tamaño normal. Existen varios valores y constantes para las
justificaciones.
La función settextstyle no retorna ningún valor.

Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
char mensaje[40];
char nombre[25];
/* Esta fuente ha de ser enlazada antes de poder registrarla
registerbgifont( sansserif_font );
*/
settextstyle( DEFAULT_FONT, 0, 2 );
settextstyle( DEFAULT_FONT, 1, 2 );
settextstyle( SANS_SERIF_FONT, 1, 3 );
getch();
closegraph();
getch();
}
Función setusercharsize
void far setusercharsize(int x_dividendo, int x_divisor,int y_dividendo, int y_divisor);
Esta función extablece las características de fuentes escalables. Para que esta función
afecte el tamaño del carácter, el argumento tam_caracter de la función settextstyle debe
ser 0. La anchura del carácter se establece con los argumentos x_dividendo y x_divisor
que representan la proporción. Similarmente, los argumentos y_dividendo e y_divisor
especifican la altura del carácter.
La función setusercharsize no retorna ningún valor.

Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
char mensaje[40];
char nombre[25];


setusercharsize( 1, 4, 1, 2 ); /* 25% de ancho; 50% de alto */
setusercharsize( 1, 2, 3, 4 ); /* 50% de ancho; 75% de alto */
getch();
closegraph();
getch();
}
Función setviewport
void far setviewport(int izquierda, int superior,int derecha, int inferior, int recorte_banderin);
Esta función es usada para definir el área gráfico. La esquina superior izquierda del área
gráfica está definida por los argumentos izquierda y superior. Estos argumentos
corresponden a los valores x e y de la esquina superior izquierda. Similarmente, los
argumentos derecha e inferior definen la esquina inferior derecha del área gráfica. El
argumento recorte_banderin define si los datos para la salida gráfica serán recortados
por el borde del área gráfico. Un valor de 0 para recorte_banderin indica que los datos
de salida no serán recortados, mientras que un valor distinto a 0 indica que los datos
serán recortados. Cuando el área gráfica es inicializada, la posición del cursor será
mudado a la posición (0,0) (la esquina superior izquierda). Todos los datos de salida
después de que el área gráfica haya sido inicializada serán con relación a este punto. El
área gráfica por defecto cubre la pantalla entera.
La función setviewport no retorna ningún valor; sin embargo, si los valores pasados son
inválidos, entonces la función graphresult retorna grError (-11) y el área gráfica no será
alterada.
Ejemplo:
#include <conio.h>
void main() {
lineto( 100, 100 );
outtextxy( 15, 5, "Inicial" );
getch();
setviewport( 250, 200, 450, 300, 0 );
setcolor( 9 );
lineto( 100, 100 );
outtextxy( 15, 5, "Nueva" );
moveto( 0, 0 );

lineto( -50, -20 ); /* Fuera del área */

getch();
setviewport( 250, 200, 450, 300, 1 );
setcolor( 4 );
moveto( 120, 40 );
lineto( 150, -20 ); /* Fuera del área */
outtextxy( 25, 15, "Con recorte" );
closegraph();
getch();
}
Función setvisualpage
void far setvisualpage(int pagina);
Esta función es usada para establecer la página visual como es especificado por el
argumento pagina. Una página es una sección de memoria donde se guarda la
información del vídeo. Cuando se usa con un sistema (EGA o VGA) con suficiente
memoria de vídeo para soportar múltiples páginas de gráficos, la función setvisualpage
(junto con la función setactivepage) permite al programador crear gráficos en páginas
escondidas y pasar de página entre las que se han definido con información gráfica. Esto
es la base para crear animación.
La función setvisualpage no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int visual=1;
printf( "Instrucciones:\nPulsa el espacio para cambiar de página, cualquier otra tecla para
salir\n" );
printf( "(Pulsa cualquier tecla para entrar en modo gráfico)\n" );
getch();
setactivepage( 0 );
sector( 300, 150, 45, 315, 150, 50 );
setactivepage( 1 );
sector( 300, 150, 90, 270, 150, 50 );
while( getch() == ' ' ) {
setvisualpage( visual );
visual = 0==visual ? 1 : 0;
}
closegraph();

getch();
}
Función setwritemode
void far setwritemode(int modo);
Esta función es usada para establecer el modo lógico de escritura para líneas rectas. El
argumento modo especifica el modo de escritura, el cual determina la interacción entre
valores de píxeles existentes y los valores de píxeles en la línea. Existen dos valores para
los modos de escritura.
La función setwritemode no retorna ningún valor.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
bar( 50, 50, 500, 300 );
setwritemode( COPY_PUT );
setcolor( 10 );
line( 20, 60, 220, 100 );
setwritemode( XOR_PUT );
line( 20, 80, 220, 120 );
getch();
closegraph();
getch();
}
Función textheight
int far textheight(char far *texto);
Esta función es usada para determinar la altura, en píxeles, de la cadena de texto

especificada por el argumento *texto. La altura del texto se determina usando la fuente
actual y el tamaño del carácter.
La función textheight retorna la altura, en píxeles, del texto especificado por el argumento.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;

int modo = EGAHI;

int anchura, altura;
char mensaje[5] = "Hola";

outtextxy(10,10,mensaje);
anchura = textwidth( mensaje );
altura = textheight( mensaje );
getch();
closegraph();
printf( "El mensaje: \"%s\" tiene de anchura: %d y altura: %d\n", mensaje,
anchura, altura );
printf( "Pulsa una tecla para continuar...\n" );
getch();
}
Función textwidth
int far textwidth(char far *texto);
Esta función es usada para determinar la anchura, en píxeles, de la cadena de texto

especificada por el argumento *texto. La anchura del texto se determina usando la fuente
actual y el tamaño del carácter.
La función textwidth retorna la anchura, en píxeles, del texto especificado por el

argumento.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver = EGA;
int modo = EGAHI;
int anchura, altura;
char mensaje[5] = "Hola";

anchura = textwidth( mensaje );
altura = textheight( mensaje );
getch();
closegraph();
printf( "El mensaje: \"%s\" tiene de anchura: %d y altura: %d\n", mensaje,
anchura, altura );
printf( "Pulsa una tecla para continuar...\n" );
getch();
}

Estructuras del modo gráfico.
Estructura arccoordstype
struct arccoordstype {
int x, y;
int xstart, ystart;
int xend, yend;
};
Los miembros x e y definen el centro del arco. Los miembros xstart e ystart definen las
coordenadas x e y del punto de comienzo del arco. Similarmente, los miembros xend e yend
definen las coordenadas x e y del punto de final del arco.
Esta estructura se usa como parámetro en la función getarccoords, que se usa para recoger las
coordenadas del centro, y los puntos del comienzo y final de la última llamada con éxito a la
función arc.
Ejemplo:
#include <conio.h>
void main() {
int driver = EGA,modo = EGAHI,radio;
struct arccoordstype info_arco;
for( radio=25; radio<=100; radio+=25 ) {
arc( 300, 150, 45, 315, radio );
getarccoords( &info_arco );
moveto( info_arco.xstart, info_arco.ystart );
lineto( info_arco.xend, info_arco.yend );
}
closegraph();
}
Estructura fillsettingstype
struct fillsettingstype {
int pattern;
int color;
};
Esta estructura se usa para obtener la información de tramas de relleno, mediante getfillsettings.
El campo pattern es la trama y el campo color es el color de relleno de la trama. Existen trece
valores ya definidos para tramas.

Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int gdriver = EGA,gmodo = EGAHI;
struct fillsettingstype info;
initgraph( &gdriver, &gmodo, "C:\\tc20\\BIN" );
getfillsettings( &info );
bar( 50, 50, 350, 300 );
closegraph();
printf( "Trama de relleno: %d\tColor de relleno: %d\n",
info.pattern, info.color );
getch();
}
Estructura linesettingstype.
struct linesettingstype {
int linestyle;
unsigned upattern;
int thickness;
}
Esta estructura se usa para obtener la información actual para las líneas mediante la función
getlinesettings. El campo linestyle es el estilo de la línea recta. El campo upattern es la trama
de la línea del usuario solamente cuando el campo linestyle es igual a USERBIT_LINE, ó 4.
Cuando esto sea el caso, el miembro upattern contiene una trama de línea definido por el
usuario de 16 bits. Un bit 1 en esta trama indica que el píxel correspondiente será asignado el
color actual. Un bit 0 indica que el píxel correspondiente no será alterado. El campo thickness
es el grosor de la línea.
Existen varios valores para los diferentes estilos y grosores de líneas rectas.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int gdriver = EGA;
int gmodo = EGAHI;
struct linesettingstype info;
initgraph( &gdriver, &gmodo, "C:\\tc20\\BIN" );
setlinestyle( DOTTED_LINE, 0xFF33, THICK_WIDTH );
circle( 350, 250, 50 );

getlinesettings( &info );
closegraph();
printf( "Líneas rectas.\nEstilo: %d\tTrama: %X\tGrosor: %d\n",info.linestyle, info.upattern,
info.thickness );
getch();
}
Estructura palettetype
unsigned char size;
};
Esta estructura se usa para obtener una los datos que definen la paleta según cada dispositivo.
El campo size indica el tamaño de la paleta. El campo colors contiene los valores numéricos
que representan los colores que ofrece el dispositivo en su paleta de colores.
Ejemplo:
#include <conio.h>
#include <stdio.h&t;
void main() {
int driver = EGA,modo = EGAHI,i;
struct palettetype *palette = NULL;
palette = getpalettetype();
circle( 300, 150, 50 );
closegraph();
printf( "Paleta\n\nTamaño: %d\nColores: %d",
palette->size, palette->colors[0] );
for( i=1; i<palette->size; i++ )
printf( ", %d", palette->colors[i] );
printf( "\n" );
getch();
}
Estructura textsettingstype
struct textsettingstype {
int font;
int direction;
int charsize;
int horiz;
int vert;
};

Esta estructura se usa para obtener información acerca de la fuente gráfica actual mediante la
función getextsettings. Esta estructura contiene información de la fuente actual en uso, la
orientación del texto, el tamaño del carácter, y la justificación horizontal y vertical.
Existen varios valores para describir el tipo, la orientación, y justificación de fuentes.
Ejemplo:
#include <stdio.h>
void main() {
struct textsettingstype info;
gettextsettings( &info );
closegraph();
printf( "Texto\n\nFuente: %d\tSentido: %d\tTamaño: %d\n"
"Justificación:\nHorizontal: %d, Vertical: %d\n",
info.font, info.direction, info.charsize, info.horiz, info.vert);
getch();
}
Estructura viewporttype
int left, top;
int right, bottom;
int clip;
};
Esta estructura se usa para obtener información acerca del área gráfica actual mediante la
función getviewsettings. Esta estructura contiene información acerca de las esquinas superior
izquierda e inferior derecha, también como el banderín de recorte del área gráfica.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver =IBM8514LO,modo=IBM8514HI;
closegraph();
printf( "Pantalla\n\nIzquierda: %d\tSuperior: %d\tDerecha: %d\t"
"Inferior: %d\tBanderín: %d\n",
info.left, info.top, info.right, info.bottom, info.clip);
getch();
}

Estructura time
int left, top;
int right, bottom;
int clip;
};
Esta estructura se usa para obtener información acerca del área gráfica actual mediante la
función getviewsettings. Esta estructura contiene información acerca de las esquinas superior
izquierda e inferior derecha, también como el banderín de recorte del área gráfica.
Ejemplo:
#include <conio.h>
#include <stdio.h>
void main() {
int driver =IBM8514LO,modo=IBM8514HI;
closegraph();
printf( "Pantalla\n\nIzquierda: %d\tSuperior: %d\tDerecha: %d\t"
"Inferior: %d\tBanderín: %d\n",
info.left, info.top, info.right, info.bottom, info.clip);
getch();
}
 Funciones de Rasterop.
Las funciones del rasterop, son auellas que realizar la accion de mover una imagen ya
sea transportando una imagen o copiandola.
Las funciones pertenecientes al rasterop son:
1. imagesize
2. malloc
3. getimage
4. putimage
Las cuatro complementan la operación de mover una imagen almacenándola en una

variable temporal de tipo buffer.
Procederemos a explicar cada una de ellas para realizar buestros ejercicios de

movimiento.

Función imagesize
unsigned far imagesize(int izquierda,int superior, int derecha, int inferior);
Esta función es usada para determinar el tamaño del búfer necesitado para almacenar
una imagen con la función getimage. Los argumentos izquierda y superior definen las
coordenadas x e y de la esquina superior izquierda de la imagen rectangular.
Similarmente, los argumentos derecha y inferior definen las coordenadas x e y de la
esquina inferior derecha de la imagen rectangular.
La función imagesize retorna el número actual de bytes necesarios, si el tamaño requerido

es menor que 64 Kb menos 1 byte. Si esto no es el caso, el valor retornado es 0xFFFF, ó
-1.
Ejemplo:
#include <conio.h>
#include <stdlib.h>
void main() {
int driver = EGA;
int modo = EGAHI;
void *imagen;
int imagentam;
initgraph( &driver, &modo, “C:\\tc20\\BIN” );
setfillstyle( SLASH_FILL, 5 );
bar( 50, 50, 350, 300 );
imagentam = imagesize( 50, 50, 100, 100 );
closegraph();
getch();
}
/*En este ejercicio solo calculamos el tamaño de la imagen*/
Función malloc
void *malloc(size_t size)
Función definida en conio.h. El tamaño está en bytes. Regresa un puntero(indicador)al

bloque recientemente asignado, o Nulo (NULL) si no existe suficiente espacio en nuevo
bloque. Si el tamaño==0, este regresa un Nulo(NULL) .
Talvez no comprenda lo que quiera dar a entender pero ala hora del ejercicio lo
entenderán.
Ejemplo:
#include <conio.h>
#include <stdlib.h>
void main() {

int driver = EGA;

int modo = EGAHI;
void *imagen;
int imagentam;
bar( 50, 50, 350, 300 );
imagen = malloc(imagesize( 50, 50, 100, 100 ));
free( imagen );
closegraph();
getch();
}
En este ejemplo calculamos en tamaño de la imagen y el número de bytes necesarios

para contenerla
Función getimage
void far getimage(int izquierda, int superior,int derecha, int inferior, void far *imagen);
Esta función es usada para guardar una porción rectangular de la pantalla para un uso
posterior. La esquina superior izquierda del área rectangular que ha de ser guardada está
definida por los argumentos izquierda y superior. Estos argumentos representan las
coordenades x e y de la esquina superior izquierda, respectivamente. Los argumentos
derecha e inferior definen la esquina inferior derecha de la imagen rectangular. Estos
argumentos definen las coordenades x e y de la esquina inferior derecha,
respectivamente. El argumento *image apunta al búfer de memoria donde la imagen está
guardada.
La función getimage no retorna ningún valor, directamente.
Ejemplo:
#include <conio.h>
#include <stdlib.h>
void main() {
int driver = EGA;
int modo = EGAHI;
void *imagen;
int imagentam;
bar( 50, 50, 350, 300 );
imagen = malloc( imagentam );
getimage( 50, 50, 100, 100, imagen );
free( imagen );
getch();
}

/*En este ejemplo solo conseguimos el tamaño de la imagen y guardamos la imagen en

un buffer*/
Función putimage
void far putimage(int izquierda , int superior, void far *image, int acción);
Esta función coloca una imagen que fue previamente guardada con la función getimage
en la pantalla. La esquina superior izquierda donde será colocada la imagen está definida
por los argumentos izquierda y superior. Estos argumentos representan las coordenadas
x e y de la esquina superior izquierda, respectivamente. El argumento *image apunta al
búfer de memoria donde la imagen está guardada. La imagen se coloca en la pantalla con
la acción definida en el argumento acción. Los valores y consonantes usados por el
argumento accion se describen a continuación ya que pudieron haberlos olvidado:

COPY_PUT 0 Sobrescribir los píxeles existentes
XOR_PUT 1 Operación OR Exclusivo con los píxeles
OR_PUT 2 Operación OR Inclusivo con los píxeles
AND_PUT 3 Operación AND con los píxels
NOT_PUT 4 Invertir la imagen
La función putimage no retorna ningún valor.
Ejemplo:
#include <conio.h>
#include <stdlib.h>
void main() {
int driver = EGA,modo = EGAHI, imagentam;
void *imagen;
bar( 50, 50, 350, 300 );
imagen = malloc( imagentam );
getimage( 50, 50, 100, 100, imagen );
putimage( 400, 50, imagen, COPY_PUT );
getch();
putimage( 400, 110, imagen, COPY_PUT );
closegraph();
free( imagen );
getch();
}
Este es el pequeño ejemplo del rasterop

Otros ejemplo de Rasterop.
1. Un círculo que realiza un movimiento iliptico.
# include <conio.h>
# include <math.h>
# include <dos.h>
void cuerpo(void);
void main(void)
{
inicializar();
cuerpo();
}
{
int drive=DETECT,modo;
initgraph(&drive,&modo,"c:\\tc20\\bin");
}
void cuerpo()
{
double x,y;
while(!kbhit())
{
x=-180;
while(x<=180 && !kbhit())
{
y=sqrt(15000*(1-((x*x)/32400)));
circle(x+310,240-y,20);
delay(15000);
x+=1;
cleardevice();
}
x=180;
while(x>=-180 && !kbhit())
{
y=-1*sqrt(15000*(1-((x*x)/32400)));
circle(x+310,240-y,20);
delay(15000);
x-=1;
cleardevice();
}
}

getch();
}
Realice un programa que muestre el movimiento de la tierra alrededor de la tierra y que

mustre los meses del año conforme valla avanzando la image.
# include <conio.h>
# include <stdio.h>
# include <math.h>
# include <dos.h>
# include <process.h>
void main()
{
float y2,y1,x,x2;
void far *buffer;
system("cls");
inicializar();
buffer=malloc(imagesize(0,20,20,20));
do
{
outtextxy(150,50,"MOVIMIENTO DE ROTACION DE LA TIERRA al rededor del sol");
x2=-300;
while(x2<=300 && !kbhit())
{
putpixel(random(639),random(480),WHITE);
putpixel(random(639),random(480),YELLOW);
if((x2>=-300)&&(x2<-200))
{
rectangle(480,440,600,460);
setfillstyle(1,BLUE);
floodfill(485,450,WHITE);
outtextxy(500,450,"Enero");
}
else
{
if((x2>=-200)&&(x2<-100))
{
setcolor(BLUE);outtextxy(500,450,"Enero");
setcolor(RED);
rectangle(480,440,600,460);
setfillstyle(1,GREEN);
floodfill(485,450,BLUE);
outtextxy(500,450,"Febrero");
}
else
{

if((x2>=-100)&&(x2<0))
{
setcolor(YELLOW);
rectangle(480,440,600,460);
floodfill(485,450,YELLOW);
outtextxy(500,450,"Marzo");
}
else
{
if((x2>=0)&&(x2<100))
{
setcolor(GREEN);
rectangle(480,440,600,460);
floodfill(485,450,GREEN);
outtextxy(500,450,"Abril");
}
else
{
if((x2>=100)&&(x2<200))
{
setcolor(CYAN);
rectangle(480,440,600,460);
floodfill(485,450,CYAN);
outtextxy(500,450,"Mayo");
}
else
{
if((x2>=200)&&(x2<299))
{
setcolor(MAGENTA);
rectangle(480,440,600,460);
floodfill(485,450,MAGENTA);
outtextxy(500,450,"Junio");
}
}
}
}
}
}
setcolor(WHITE);
y2=sqrt((1-((x2*x2)/90000.00))*23850.00);
circle(310+x2,240-y2,10);
getimage(310+x2-10,240-y2-10,310+x2+10,240-y2+10,buffer);
delay(20000);
putimage(310+x2-10,240-y2-10,buffer,XOR_PUT);
circle(310,240,30);
setfillstyle(1,YELLOW);

setcolor(WHITE);
x2+=2;
}
free(buffer);
delay(30000);
x=300;
while(x>=-300 && !kbhit())
{
putpixel(random(639),random(480),WHITE);
putpixel(random(639),random(480),YELLOW);
if((x<=300)&&(x>200))
{
setcolor(RED);
rectangle(480,440,600,460);
floodfill(485,450,RED);
outtextxy(500,450,"Julio");
}
else
{
if((x2<=200)&&(x>100))
{
setcolor(LIGHTGRAY);
rectangle(480,440,600,460);
floodfill(485,450,LIGHTGRAY);
outtextxy(501,450,"Agosto");
}
else
{
if((x<=100)&&(x>0))
{
setcolor(YELLOW);
rectangle(480,440,600,460);
outtextxy(500,450,"Septiembre");
}
else
{
if((x<=0)&&(x>-100))
{
setcolor(GREEN);
rectangle(480,440,600,460);
floodfill(485,450,GREEN);
outtextxy(500,450,"Octubre");
}
else
{

if((x<=-100)&&(x>-200))
{
setcolor(CYAN);
rectangle(480,440,600,460);
floodfill(485,450,CYAN);
outtextxy(500,450,"Noviembre");
}
else
{
if((x<=-200)&&(x>-300))
{
setcolor(MAGENTA);
rectangle(480,440,600,460);
floodfill(485,450,MAGENTA);
outtextxy(500,450,"Diciembre");
}
}
}
}
}
}
setcolor(WHITE);
y1=(sqrt((1-((x*x)/90000.00))*23850.00))*-1;
circle(310+x,240-y1,10);
getimage(310+x-10,240-y1-10,310+x+10,240-y1+10,buffer);
delay(20000);
putimage(310+x-10,240-y1-10,buffer,XOR_PUT);
circle(310,240,30);
setfillstyle(1,YELLOW);
setcolor(WHITE);
x-=2;
}
free(buffer);
delay(2000);
}while(!kbhit());
}
/***********************INICIALIZAR***************************/
{
int drive=DETECT,modo;
initgraph(&drive,&modo,"c:\\tc20\\bin");
}

Existen otras maneras mas sencillas de hacerlo, que te parece si te doy una idea???
Declara un arreglo unidimensional donde escribiras los meses y hay un for que inicie en 1
y termine en 12 dentro de ese for llama a una funcion que es bottom_fond donde
dibujaras un rectangulo que se pintará siempre de azul pero su color frontera seran las i
recomendación (pasarle parámetros a la funcion para ahorrar códigodentro de ese misno
for llama al arreglo bidimensional imprimiendo en las coordenadas del rectangulo y los
demas cálculos son los mismos.
Funciones mas utilizadas en <graphics.h> de <stdlib.h>

La función atoi
int atoi(const char *s);
El macro atoi() convierte una cadena a su valor entero. Retorna el valor convertido de la
cadena leída. Si el valor no puede ser convertido el valor de retorno es 0. Observación: es
usada para convertir cadenas que contengas valores numéricas a fin de que estos valores
puedan ser computados.
Ejemplo
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
void main(void)
{
char *string="545";
long int valor_entero;
clrscr();
valor_entero=atoi(string);
printf("La cadena es %s, el valor entero correspondiente es %d\n",string,valor_entero);
getch();
}
La función itoa
int itoa(int value, char *string, int radix);
La función itoa convierte un entero a cadena, recibe los siguientes parámetros:

int value = es el valor que vas a convertir
char *string = es una arreglo de caracteres o un puntero que apunte a char, aquí se
colocará el valor entero convertido.
int radix = quiere decir el sistema en el que está el valor entero, ejemplo para enteros
decimales debe ser 10, para enteros hexadecimale debe ser 16, para octales debe ser 8.
Esta función es comúnmente usada con outtextxy(), en el siguiente ejemplo deseo
mostrar en pantalla gráfica el valor de una variable entera para lo cual tengo que
convertirla a cadena.

Ejemplo
#include <conio.h>
#include <stdlib.h>
void main(void)
{
char *stringx,*stringy;
int x=150,y=150;
int adaptador=DETECT,modo;
initgraph(&adaptador,&modo,"c:\\tc20\\bin");
cleardevice();
itoa(x,stringx,10);
itoa(y,stringy,10);
outtextxy(150,130,"LOS VALORES DE X e Y SON:");
outtextxy(150,150,"x="); outtextxy(170,150,stringx);
outtextxy(150,160,"y="); outtextxy(170,160,stringy);
getch();
}
Funciones rand y random
int rand(void); int random(int valor_final);
Las funciones rand() y random() son similares, ambas devuelve un valor seudo-aleatorio,
la primera no recibe parámetros y el rango del valores está entre 0 y RAND_MAX este
usualmente es 32767, el rango de valores para random() esta entre 0 y (valor_final – 1).
El ejemplo siguiente simulara una cantidad de estrellas:
#include <conio.h>
#include <stdlib.h>
void main(void)
{
while(!kbhit())
{
putpixel(rand(),rand(),random(16));
}
}
Otra manera de realizar programas en modo grafico con gran efectiidad es utilizando la
librería mouse.h; esta función no esta definida dentro de la ayuda de tc20 pero esta dentro
del archivo BGI o include veremos cada una de las funciones asi como también como las
funciones contenidas dentro de ella.

Funciones de la librería Mouse.h

Todos las librerias aqui explicadas aparecen en la carpeta include de tc20.paracomenzar
tenemos:
La función mver
Void mver (void)
La función mver muestra el puntero del ratón no es necesario enviar ningún parámetro.
La función mver no retorna ningún valor.
Ejemplo
#include<graphics.h>
#include<conio.h>
#include<mouse.h>
void main(){
initgraph(&adaptador,&modo,"c:\\tc20\\BIN");
do{
mver();
}while(!kbhit());
closegraph();
getch();
}
La función mocultar
void mocultar (void)
Esta función oculta el puntero del ratón no recibe ni retorna ningún valor.
Ejemplo:
#include<conio.h>
#include<mouse.h>
void main(){
do{
mver();
mocultar()
}while(!kbhit());
closegraph();
getch();
} Al utilizar estas dos funciones obtenemos un efecto del ratón muy vistoso.

La función mtest.
int mtest (void)
Esta función sirve para testear el ratón en esta no es necesario enviar ningún parametro
retorna: 0 si no esta instalado el ratón, y n si el número de botones del ratón.
La funcion mtest retorna un entero
Ejemplo:
#include<conio.h>
#include<mouse.h>
void main(){
do{
mver();
mtest();
}while(!kbhit());
closegraph();
getch();
}
La función mxpos
int mxpos (int modo)
Dice la posición de la coordenada x en la cual se encuentra el ratón. Es necesario

enviarunvalor para especificar el modo en cual sera usado.
1 es para modo gráfico.

8 es para modo texto
La función mxpos regresa la posición horizontal de un entero que seria la posición del
ratón en x.
Ejemplo
#include <conio.h>
#include <mouse.h>
#include <stdlib.h>
void main(void)
{
int x,y;
char *strx, *stry;
setbkcolor(BLUE);

while(!kbhit())
{
setfillstyle(SOLID_FILL,BLUE);
mver();
x=mxpos(1);
y=mypos(1);
itoa(x,strx,10);
itoa(y,stry,10);
outtextxy(100,100,strx);
outtextxy(100,120,stry);
if(x!=mxpos(1)||y!=mypos(1))
{
setcolor(BLUE);
setcolor(WHITE);}
}
}
La función mypos
int mypos (int modo)
Dice la posición de la coordenada y en la cual se encuentra el ratón. Es necesario

enviarunvalor para especificar el modo en cual sera usado.
1 es para modo gráfico.

8 es para modo texto
La función mypos regresa la posición horizontal de un entero que seria la posición del
ratón en y.
Ejemplo
#include <conio.h>
#include <mouse.h>
#include <stdlib.h>
void main(void)
{
int x,y;
char *strx, *stry;
setbkcolor(BLUE);
while(!kbhit())
{
setfillstyle(SOLID_FILL,BLUE);
mver();
x=mxpos(1);
y=mypos(1);

itoa(x,strx,10);
itoa(y,stry,10);
if(x!=mxpos(1)||y!=mypos(1))
{
setcolor(BLUE);
setcolor(WHITE);}
}
}
La función msituar
void msituar(int modo, int x, int y)
Esta función permite situar al curcor en una posición específica para su utilización es
necesario enviar tres parámetros modo, x,y.
Modo: 1 para modo gráfico.

8 para modo texto.
X: posición horizontal.
Y: posición vertical.
La función no retorna ningún valor.
Ejemplo
#include<conio.h>
#include<mouse.h>
void main(){
msituar(1,310,240); /*Coloca el cursor en el centro de la pantalla*/
do{
mver();
}while(!kbhit());
closegraph();
getch();
}

La función mclick
int mclick(void)
Nos dice si se ha pulsado un boton del Mouse, no es necesario enviar un parámetro.
Retorna 0 si no es presionado ningún botón.

1 si se presionó el botón izquierdo del Mouse.
2. si se presionó el botón derecho del Mouse.
Ejemplo
#include<stdlib.h>
#include<conio.h>
#include<mouse.h>
void main(){
int adaptador=DETECT,modo,x,y;
do{
mver();
x=mxpos(1);
y=mypos(1);
if(mclick()==1)
{
setcolor(GREEN);
outtextxy(x+30,y,"Diste un click izquierdo");
}
if(mclick()==2)
{
setcolor(RED);
outtextxy(x+30,y,"Diste un click derecho");
}
delay(10000);
setcolor(BLACK);
outtextxy(x+30,y,"Diste un click izquierdo");
outtextxy(x+30,y,"Diste un click derecho");
}while(!kbhit());
closegraph();
getch();
}
La función mlimit
void mlimit(int modo, int x1, int y1, int x2, int y2)
Esta función limita el espacio de movilización del cursor (ratón), en esta función es
necesario enviar cinco parámetros modo,x1,y1,x2,y2.


8 para modo texto.
X1: límite de arriba.

Y1: límite ablajo.
X2: limite de abajo
Y2: límite de la derecha
Estas coordenadas formarán un rectángulo el cual sera el limite hasta donde podra llegar
el ratón.
Ejemplo
#include<conio.h>
#include<mouse.h>
void main(){
do{ outtextxy(100,50,"Dibuj‚ el rect ngulo para que observaran el limite");
rectangle(100,100,500,400);
mlimit(1,100,100,500,400);
mver();
}while(!kbhit());
closegraph();
getch();
}
La función minlimit
int minlimit(int modo,int x1,int y1,int x2,int y2)
Esta función verifica si el ratón se encuentra en un área determinada para la

implementación de ésta función es necesario enviar cinco parámetros.

8 para modo texto.
X1: límite de arriba.

Y1: límite ablajo.
X2: limite de abajo
Y2: límite de la derecha
Retorna 1 si esta en esa area en caso contrario regresará 0 (cero).

Ejemplo
#include<conio.h>
#include<mouse.h>
void main(){
setbkcolor(BLUE);
do{ setcolor(WHITE);
outtextxy(210,105,"pasa el mouse por encima del bot¢n y veras el efecto");
mver();
rectangle(100,100,200,120);
if(minlimit(1,100,100,200,120)==1)
{
outtextxy(310,240,"Haz pulsado el rat¢n por encima del bot¢n");
delay(30000);
setcolor(BLACK);
outtextxy(310,240,"Haz pulsado el rat¢n por encima del bot¢n");
}
}while(!kbhit());
closegraph();
getch();
}
Ejemplos de la de la VGA.
/*Este programa te muestra las figuras geometricas*/
# include<stdio.h>
# include <dos.h>
# include<stdlib.h>
# include<conio.h>
void cuadro(void);
void main(void)
{
inicializar();
cuadro();
restorecrtmode();
}
{
int adaptor=DETECT,modo,codigo;

printf("desea seguir viendo los graficos");

initgraph(&adaptor,&modo,"c:\\tc20\\bin");
if((codigo=graphresult())!=0)
{
printf("%s",grapherrormsg(codigo));
exit(1);
}
}
void cuadro(void)
{
int paginas=1;
int i=155,j=120; /*i=izquierda arriba eje x jes igual eje y*/
int q=465,w=120; /* t= derecha arriba eje x k es igual eje y*/
int t=155,k=360; /*q= izquierda abajo eje x w es igual eje y */
int a=465,s=360; /*a= derecha abajo eje x s igual eje y*/
int pentagono[]={55,340, 105,410, 205,410, 255,340, 155,270, 55,340};
int hexagono[]={365,360, 415,410, 515,410, 565,360, 515,310, 415,310, 365,360};
while(paginas<=4)
{
system("cls");
setbkcolor(WHITE);
setlinestyle(SOLID_LINE,15,THICK_WIDTH);
setcolor(8);
rectangle(1,1,getmaxx()-1,getmaxy()-1);
line(310,0,310,480);
line(0,240,640,240);
setcolor(9);
setlinestyle(SOLID_LINE,15,NORM_WIDTH);
if(paginas>=1&&paginas<=2)
{
settextstyle(SMALL_FONT,HORIZ_DIR,4);
outtextxy(400,460,"Presione enter para ver las sig. graficas");
}
else
{
outtextxy(370,460,"Fin de presentacion Presione enter para Salir");
}
if(paginas==1)
{
/***************triangulo1**************************/
outtextxy(i-60,j-90,"Triangulo Rectangulo");
outtextxy(i-67,j-20,"h");
outtextxy(i,j+40,"b");
outtextxy(i-5,j+70,"S=(b x h)/2");
outtextxy(i-60,j-90,"Tri ngulo rectangulo");
line(i-60,j-60,i-60,j+40);
line(i-60,j+40,i+100,j+40);
line(i+100,j+40,i-60,j-60);

/******************triangulo2****************************/
/* q eje x w eje y*/
outtextxy(q-100,w-90,"Triangulo Rectangulo 3 lados diferentes");

outtextxy(q-57,w-20,"h");
outtextxy(q-20,w+40,"a");
outtextxy(q+10,w-30,"b");
outtextxy(q-80,w-30,"c");
outtextxy(q-45,w+60,"S=-\/ p(p-a)(p-b)(p-c)'");
line(q-15,w+60,q+110,w+60);
outtextxy(q-30,w+75,"P=(a+b+c)/2");
/*outtextxy(q-5,w+70,"(b x h)/2");*/
setlinestyle(DOTTED_LINE,3,NORM_WIDTH);
line(q-50,w-60,q-50,w+40);
line(q-50,w+40,q+80,w+40);
line(q+80,w+40,q-50,w-60);
line(q-50,w+40,q-100,w+40);
line(q-100,w+40,q-50,w-60);
/*******************triangulo escaleno*****************************/
/*t es eje x k es eje y*/
outtextxy(t-60,k-90,"Triangulo Escaleno");
outtextxy(t-67,k-20,"h");
outtextxy(t,k+40,"b");
outtextxy(t-5,k+70,"S=(b x h)/2");
line(t-60,k-60,t-25,k+40); /*line que corta al triangulo o cat opu*/
line(t-25,k+40,t+100,k+40); /*cat ady.*/
line(t+100,k+40,t-60,k-60); /*hipoten.*/
line(a+20,s-60,a+20,s+40); /*Triangulo isosceles*/
line(t-60,k-60,t-60,k+40);
line(t-60,k+40,t+100,k+40);
/*********************triangulo isosceles***************************/
outtextxy(a-40,s-90,"Triangulo Isosceles");
outtextxy(a+10,s-20,"h");
outtextxy(a+10,s+40,"b");
outtextxy(a-5,s+70,"S=(b x h)/2");
line(a+20,s-60,a-60,s+40); /*cat opt.*/
line(a-60,s+40,a+100,s+40); /*cat ady*/
line(a+100,s+40,a+20,s-60); /*hip*/
getch();
}
if(paginas==2)

{
/********************Rectangulo******************/
line(i-45,j-25,i+65,j-25);
line(i-60,j+25,i+50,j+25);
line(i-45,j-25,i-60,j+25);
line(i+65,j-25,i+50,j+25);
line(i-45,j-25,i-45,j+25); /*altura*/
outtextxy(i-25,j-90,"Rectangulo");
outtextxy(i-52,j,"h");
outtextxy(i,j+30,"b");
outtextxy(i-35,j+60,"S=b x h");
/*****************************Rombo***********************/
line(t-90,k,t+90,k);
line(t,k-60,t,k+60);
line(t-90,k,t,k-60);
line(t,k-60,t+90,k);
line(t,k+60,t+90,k);
line(t-90,k,t,k+60);
rectangle(t-90,k,t+90,k+70);
line(t,k-60,t+120,k-60);
line(t+120,k-60,t+120,k+60);
line(t+120,k+60,t,k+60);
line(q-60,w-45,q-60,w+45);
outtextxy(t-25,k-90,"Rombo");
outtextxy(t-45,k,"D");
outtextxy(i+3,k+30,"d");
outtextxy(t-35,k+75,"S=(D * d)/2");
/*****************************Trapecio******************************/
line(q-60,w-45,q+60,w-45);
line(q-85,w+45,q+90,w+45);
line(q-85,w+45,q-60,w-45);
line(q+90,w+45,q+60,w-45);
outtextxy(q-25,w-90,"Trapecio");
outtextxy(q-52,w,"h");
outtextxy(q,w+50,"B");
outtextxy(q,w-60,"b");
outtextxy(q-35,w+60,"S=((B + b)* h)/2");
/*************************Pol¡gono*****************************/
line(a-60,s,a+100,s);
line(a+100,s,a+70,s+45);
line(a+70,s+45,a-60,s);
line(a+100,s,a+40,s-60);
line(a+40,s-60,a-60,s);
line(a+40,s-60,a-40,s-40);

line(a-60,s,a-40,s-40);
outtextxy(a-25,s-90,"Poligono");
outtextxy(a-30,s-40,"S1");
outtextxy(a+25,s-30,"S2");
outtextxy(a+30,s+10,"S3");
outtextxy(a-35,s+60,"S= S1 + S2 + S3");
getch();
}
if(paginas==3)
{
/*********************tri ngulo equilatero*********************/
line(i-60,j+55,i+20,j-85); /*cat*/
line(i+100,j+55,i+20,j-85); /*cat*/
line(i-60,j+55,i+100,j+55); /*base*/
outtextxy(i-25,j-100,"Triangulo equilatero");
line(i+20,j-85,i+20,j+55);
outtextxy(i+25,i-30,"h");
outtextxy(i+30,i+20,"b");
outtextxy(i-35,i+55,"S= (b * h)/2");
/*******************************cuadrado***********************/
rectangle(q-50,w-50,q+50,w+50);
outtextxy(q-25,w-100,"Cuadrado");
outtextxy(q,w+50,"b");
outtextxy(q-35,w+65,"S= b * b");
/****************************pent gono***********************/
fillpoly(5,pentagono);
outtextxy(t-25,k-110,"Pent gono");
line(t,k-20,t,k+50);
outtextxy(t+10,k+10,"a");
outtextxy(t-35,k+65,"S=(P * a)/2");
/*************Exagono o poligono regular*******************/
fillpoly(6,hexagono);
outtextxy(a-65,s-100,"Hex gono o poligono regular");

/*setfillstyle(LINE_FILL,GREEN);
floodfill(370,460,BLUE);*/
line(a,s,a,s+50);
outtextxy(a+10,s+10,"a");
outtextxy(a-35,s+65,"S=(P * a)/2");
getch();
}
if(paginas>4)
exit(1);
paginas=paginas+1;
}
clrscr();}
Este programa te simula un paisaje nocturno con algunas efectos de estrellas.

# include <conio.h>
# include <dos.h>
# include <process.h>
# define WHITE 15
void marco(int *,int *,int *,int *,int *);
void estrellas(int *,int *);
void ambiente(void);
void ambientedos(void);
void montana(void);
void cometas(void);
void main()
{
/*INICIALIZAR EL MODO GRAFICO DE MANERA RAPIDA*/
int a=DETECT,b;
int x1=0,y1=0,x2=640,y2=480,color=6;
int y=0, x=0;
initgraph(&a,&b,"c:\\tc20\\bin");
system("cls");
ambiente();
ambientedos();
marco(&x1,&y1,&x2,&y2,&color);
estrellas(&x,&y);
montana();
cometas();
getch();
}
void ambiente(void)
{
int x=50,y=480;
setbkcolor(BLUE);
rectangle(0,0,639,479);
moveto(x,y);
lineto(100,450);
lineto(150,400);
lineto(210,370);
lineto(0,370);
setfillstyle(SOLID_FILL,GREEN);
}
void ambientedos(void)
{

setcolor(BROWN);
moveto(105,370);
lineto(125,350);
lineto(155,365);
lineto(155,360);
lineto(125,345);
lineto(55,345);
lineto(22,370);
lineto(105,370);
setfillstyle(6,BROWN);
floodfill(50,350,BROWN);
setcolor(BROWN);
rectangle(30,365,110,400);
setfillstyle(SOLID_FILL,BROWN);
line(150,362,150,382.5); /*linea lateral | */

line(110,400,150,382.5); /*union de la linea lateral con la casa*/
setfillstyle(SOLID_FILL,BROWN);
setcolor(RED);
line(130,367,140,364); /*ventana arriba --*/
line(130,377,140,374); /*ventana abajo __*/
line(130,367,130,377); /*lado derecha | */
line(140,364,140,374); /*lado izquierdo | */
setfillstyle(SOLID_FILL,MAGENTA);
line(112,398,112,378); /*puerta arriba*/

line(112,378,120,374); /*puerta lado izquierdo*/
line(120,374,120.5,395); /*puerta lado derecho*/
line(112,397,120.5,394); /*puerta abajo*/
setfillstyle(SOLID_FILL,MAGENTA);
line(110,365,110,400);
setcolor(YELLOW);
arc(310,300,90,270,30);
ellipse(310,300,90,270,05,30);
setfillstyle(SOLID_FILL,YELLOW);
}
void marco(int *x1,int *y1,int *x2,int *y2,int *color)

{
setbkcolor(BLUE);

setcolor(*color);
rectangle(*x1,*y1,*x2,*y2);
}
void estrellas(int *x,int *y)

{
int i,px=*x,py=*y,color,t;
setcolor(YELLOW);
arc(310,180,90,270,30);
ellipse(310,180,90,270,05,30);
setfillstyle(SOLID_FILL,YELLOW);
color=getcolor();
t=1;
for(i=0;i<=400;i++)
{
montana();
setcolor(GREEN);
putpixel(px,py,color);
putpixel(px+10,py+50,WHITE);
px=(rand()%640);
py=(rand()%200);
if(i>=230)
continue;
else
{
putpixel(310,(480-t)-12,RED);
putpixel(310,(480-t)-9,YELLOW);
putpixel(310,(480-t),BLUE);
putpixel(t+1,100,RED);
putpixel(t-5,100,YELLOW);
putpixel(t-11,100,BLUE);
t+=3;
}
delay(4000);
}
}
void montana()
{
line(0,250,494,250); /*linea del lago superior */
line(480,250,560,200); /*monta¤a / */
line(560,200,639,250); /* monta¤a \ */
line(480,250,639,250); /* monta¤a ___ */

setfillstyle(SOLID_FILL,LIGHTGREEN);
}
void cometas(void)
{
int i,t;
do
{
t=1;
for(i=0;i<=450;i++)
{
if(i>=230)
continue;
else
{
putpixel(t+7,80,YELLOW);
putpixel(t+1,80,BLUE);
putpixel(t+7,100,YELLOW);
putpixel(t+1,100,BLUE);
if((t+1)>=292 && (t+1)<=317)

{
}
else
{
}
t+=3;
}
delay(2000);
}
t=0;
}while(!kbhit());
}
Este programa dibuja con el Mouse.
#include <mouse.h>

#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#define ESC 27
void main()
{
int a=DETECT,b;
int posx,posy,h,z=0;
setcolor(YELLOW);
outtextxy(10,10,"a) click izq sostenido para dibujar ");
outtextxy(10,20,"b) click izq dibuja una linea desde la pos. anterior hasta la nueva pos.");
outtextxy(10,30,"c) presionar una vez click der indica que se escogera un nuevo punto
donde");
outtextxy(10,40," empezara a dibujar el click debe ser fuera del dibujo en caso contrario
");
outtextxy(10,50," se borrara");
outtextxy(10,60,"d) click der sostenido para borrar");
outtextxy(10,70,"e) presiona una tecla para salir o click si no has empezado ha dibujar");
outtextxy(10,420,"Hecho por:");
settextstyle(4,0,1);
outtextxy(10,430," Bismarck Salvador Tra¤a L¢pez");
outtextxy(10+textwidth("Hecho por: "),450,"Juan Carlos Guti‚rrez Barquero");
while(mclick()!=1)
{
setcolor(WHITE);
mver();
posx=mxpos(1);
posy=mypos(1);
}
while(!kbhit())
{
setcolor(WHITE);
mlimit(1,100,100,getmaxx()-100,getmaxy()-100);
mver();
mocultar();
if(mclick()==1)
{
if(z==1)
{
z=0;
posx=mxpos(1);
posy=mypos(1);
}
line(posx,posy,mxpos(1),mypos(1));
posx=mxpos(1);
posy=mypos(1);
}

else if(mclick()==2)
{
z=1;
setcolor(BLACK);
for(h=0;h<=20;h++)
circle(mxpos(1),mypos(1),h);
floodfill(mxpos(1),mypos(1),BLACK);
}
mlimit(1,100,100,getmaxx()-100,getmaxy()-100);
}
clrscr();
}
Este programa muestra el movimiento de una pelota.
# include<stdio.h>
# include <dos.h>
# include<conio.h>
void juego_visual(void);
void fondo_de_la_pantalla(void);
void mover(void);
void main(void)
{
inicializar();
juego_visual();
cleardevice();
fondo_de_la_pantalla();
mover();
getch();
restorecrtmode();
}
{
int adaptor=DETECT,modo,codigo;
printf("desea seguir viendo los graficos");
initgraph(&adaptor,&modo,"c:\\tc20\\bin");
if((codigo=graphresult())!=0)
{
printf("%s",grapherrormsg(codigo));
exit(1);
}
}
void juego_visual(void)

{
int i;
setbkcolor(BLUE);
setcolor(YELLOW);
outtextxy(5,5,"Cargando programa de movimiento grafico");
rectangle(21,20,450,30);
sleep(1);
for(i=11;i<=430;i++)
{
bar(10+i,20,20+i,30);
delay(5000);
if(i==430)
{
moveto(480,400);
outtext("programa Cargado");
}
}
sleep(1);
}
void mover(void)
{
void far *buffer;
int i;
setcolor(WHITE);
buffer=malloc(imagesize(127,98,172,143));
/*rectangle(127,98,172,143);*/
i=100;
while(!kbhit())
{
ala: circle(127+i,180,20);
getimage(107+i,160,147+i,200,buffer);
sleep(1);
putimage(107+i,160,buffer,XOR_PUT);
i+=10;
if(i==300)
{
i=100;
goto ala;
}
}
free( buffer);
}
void fondo_de_la_pantalla(void)
{
setbkcolor(BLUE);
setcolor(LIGHTBLUE);

rectangle(6,5,634,20);
setfillstyle(SOLID_FILL,LIGHTGRAY);
setcolor(BLUE);
rectangle(5,5,100,20);
setcolor(RED);
outtextxy(8,11,"N");
setcolor(BLACK);
outtextxy(17,11,"uevo Juego");
setcolor(BLUE);
rectangle(110,5,160,20);
setcolor(RED);
outtextxy(116,11,"S");
setcolor(BLACK);
outtextxy(124,11,"alir");
}
Modo 13h 320x200().
 Introducción.
Cuando aparecieron los primeros computadores existía una memoria de solo 640 Kb
(memoria convencional) y el procesador que dominaba en aquella época era el 8086 y
8088 el cual podía direccionar hasta 1 Mb de memoria, ya que el microprocesador era de
16 bits. Añadieron a este diferentes áreas de memoria, para la BIOS, el video, cartuchos
ROM, etc.
Hoy en día la configuración de todo PC está organizada en bloques de 64 kb.
Organización de la memoria de un PC
A000: corresponde a la memoria de la pantalla en los modos gráficos de las tarjetas EGA
y VGA.
B000: Es para las tarjetas de video monocromo MDA y Hercules. También sirve para la
tarjeta CGA. Se utiliza como alojamiento de los modos alfanuméricos.
C000: Se depositan algunas rutinas BIOS, que no forman parte del núcleo original de
esta.
D000: Para cartuchos ROM. No se suele utilizar.
E000: Igual que D000.
F000: Aquí se guardan todas la rutinas (funciones) de la ROM-BIOS.

El Procesador .
Para hacer la programación del sistema, hay que conocer algunos conceptos que juegan
un papel importante, términos como por ejemplo los registros, a los que hay que
conocer si se quieren manejar las interrupciones, ya sean a nivel DOS o BIOS.
Los registros .
Los registros son muy importantes para el ordenador, sirven para ayudar al
funcionamiento de las instrucciones. Una definición un poco más acertada, sería decir
que los registros son como variables internas con las que el computador realiza
operaciones, y lleva el control de los programas.
El tamaño de estos registros en un 286 es de 16 bits, pero a partir del 386 estos registros
son de 32 bits. Cada uno de estos registros se divide en dos partes de 8 bits cada una
(esto es así, por que el DOS trabaja en modo Real, y no puede direccionar más de 16
bits). Por ejemplo, el registro AX, se divide en AH y AL (H de High y L de Low). Podemos
distinguir cinco tipos de registros diferentes:
Registros Generales: Hay cuatro: AX, BX, CX, y DX. Son unos registros de 16 bits que
se usan como almacenamiento temporal, para realizar operaciones aritméticas, cada uno
de estos se divide en dos partes, la parte alta (AH), y la baja (AL), donde H significa High
y L de Low. Tienen un propósito general para el programador.
Registros de dirección (Puntero / Indice): SP, BP, SI y DI. Los utilizamos para formar
direcciones de 20 bits, junto con los registros de segmento CS, DS, SS, y ES.
Registros de segmento: CS, DS, SS y ES. Con ellos referenciamos direcciones de
memoria.
Registro de Puntero de Instrucción: IP (Instruction Pointer). Este lo usa el PC para

“acordarse” en que punto se ha quedado a partir de la base CS. Va cambiando su valor
cada vez que saltamos a un punto del programa.
Registro de Bandera (Flag): Sirve para saber el estado y tener el control del procesador.
Con este registro podremos saber, si por ejemplo después de una suma, el valor excede
de 65535 y por tanto no cabe en 16 bits. Estos bits, que pueden valer 0 o 1, indican varias
cosas según su valor.
Las interrupciones .
Las interrupciones, tal y como indica su nombre, tienen como función interrumpir en medio
de un procedimiento, ejecutar un trozo de código y continuar con lo que se estaba
haciendo. De esta manera la CPU se ahorra de ir preguntado todo el rato a los diferentes
periféricos si “necesitan” su ayuda (polling). Hay de varios tipos, las que son ejecutadas
por el hardware, las del Sistema Operativo y las iniciadas por el sistema (BIOS). Dentro
de estas hay las enmascarable, y las no enmascarables (NMI).
El B.I.O.S ( Basic Input Output System) tiene una serie de interrupciones, para que
cuando utilicemos alguna de ellas sepamos donde se encuentra. Para eso utilizaremos

una tabla que nos servirá de “índice” para así obtener la dirección de la rutina. Esta tabla
se aloja en la parte más baja de la memoria, es decir, en 0000:0000, y tiene una longitud
de 256 entrada de 4bytes cada una; 2 bytes de dirección (segmento) y 2 bytes de
desplazamiento (offset), o sea, 1 kb en total.
El Bios dispone de las funciones principales que necesita un programa para la

comunicación con el hardware del PC y los dispositivos conectados a él.
Hay rutinas de todas clases. Su función más importante, es que permite usar a los
programas diferentes periféricos independientemente de las características del hardware.
Esto nos ahorra mucho tiempo a la hora de programar para diferentes periféricos. O sea,
que el Bios es un sistema de comunicación estándar.
A continuación describiré todas las interrupciones de la BIOS y su finalidad de la 00H a la

1BH, pero aunque hay más, no serán comentadas ya que es de uso de la BIOS.
INTERRUPCION 00H: División entre cero.
INTERRUPCION 01H: Un solo paso.
INTERRUPCION 02H: Interrupción no enmascarable.
INTERRUPCION 03H: Punto de ruptura.
INTERRUPCION 04H: Desbordamiento.
INTERRUPCION 05H: Imprime pantalla.
INTERRUPCION 08H: Sistema del cronómetro.
INTERRUPCION 09H: Interrupción del teclado.
INTERRUPCION 0BH y INTERRUPCION 0CH: Estas dos son para el Control de

Dispositivo Serial.
INTERRUPCION 0DH y INTERRUPCION 0FH: Estas son para el Control del Dispositivo
Paralelo.
INTERRUPCION 0EH: Control disco flexible.
INTERRUPCION 10H: Servicios de video.
INTERRUPCION 11H: Obtener equipo instalado. Determinación equipo.
INTERRUPCION 13H: Obtención tamaño memoria.
INTERRUPCION 14H: Comunicaciones i/o.
INTERRUPCION 15H: Servicios sistema.
INTERRUPCION 16H: Entrada teclado.

INTERRUPCION 17H: Salida impresora.
INTERRUPCION 18H: Entrada basic de rom.
INTERRUPCION 19H: Cargador de arranque.
INTERRUPCION 1AH: Lee y pone hora.
INTERRUPCION 1BH: Tomar control en interrupción del teclado.
Estas son las interrupciones del BIOS, pero hay más, las del sistema operativo, MS-DOS
en nuestro caso. Cada interrupción se divide en funciones, que son los diferentes
servicios a los que tenemos acceso. Para llamar a una interrupción utilizamos los
registros, donde en AX indicaremos por norma general el número de interrupción, y en los
demás registros los parámetros.
La Programación del Sistema
A la hora de programar una aplicación, la forma de tratar la información, ordenarla, y

representarla es siempre igual para todos los computadores, los algoritmos utilizados no
varían, los podemos describir de forma muy general. Pero lo que sí varía y que depende
del sistema, es la forma en la que se debe tratar la información que entra en un programa
y la forma en la que sale, esto sí es realmente la programación de sistemas, en la que se
deben conocer como acceder al teclado, pantalla, impresora, archivos, etc.
Una de las cosas mas importantes en este tipo de programación es el acceso al

hardware. Debemos saber por donde nos movemos si queremos que nuestra aplicación
funcione correctamente.
Aunque la programación de sistemas esté tan fuertemente ligada al hardware, no

significa que tengamos que rompernos la cabeza para poner un "¡Hola!" en pantalla,
tenemos unas ayudas que nos simplifican mucho la vida. Esto es las funciones de el BIOS
y del Sistemas Operativo. Estas rutinas (interrupciones) nos ahorrará mucho trabajo, ya
que cada uno de estos servicios, conlleva más tiempo mediante la programación directa
al hardware.
Resumiendo, tenemos que las diferentes capas a la que una aplicación puede acceder
son tres:
Para decidirnos por uno de los tres, se tendrá que pensar en el objetivo de la aplicación
que se está desarrollando: si es un juego se tendrá que ir directo al hardware del
computador, por que si se hace mediante rutinas BIOS, el juego quedará demasiado
lento. Esto no quiere decir que las rutinas de la BIOS sean lentas de por si, lo que
pasa es que son “universales” y llevan muchos tipos de comprobaciones. Por otro lado, si
lo que se quiere es hacer una aplicación en modo texto, simplemente usaremos las
funciones que nos pone a disposición nuestro lenguaje de programación favorito.
 Capitulo I. Inicialización del modo gráfico.
Introducción.

La pantalla de nuestro computador puede funcionar en dos modos, modo texto

(o alfanumérico) en el que se representan caracteres, y en modo gráfico, en el cual
además de caracteres se pueden representar imágenes.
Cuando hablamos de modos gráficos, la unidad representable es el pixel. Un pixel (un

punto) es la unidad mínima de información que podemos representar en pantalla. El
elemento que determina tanto la resolución como la cantidad de colores que podemos
representar, es el adaptador. Cada adaptador tiene unas características determinadas,
que hace que la forma de programar sea distinta para cada uno. La diferencia
fundamental es la manera de gestionar la memoria. La información de un pixel, se
almacena en código binario. Esta información hace referencia al color y atributos
especiales.
Los registros de las tarjetas constituyen el dispositivo de Entrada/Salida (E/S) de más bajo
nivel de los adaptadores gráficos. Es en ellos donde se almacena la información relativa a
como debe el computador representar los datos en la pantalla. Están conectados a
puertos de E/S que los hacen accesibles, permitiendo su modificación y lectura. Una
tarjeta de video esta formada por varios controladores hardware integrados en una misma
placa. Cada uno de estos controladores tiene a su vez una serie de registros asociados. A
la hora de programar las tarjetas gráficas, tendremos que acceder a estos registros, para
lo cual se emplea un índice de puerto o index port.
Un mismo controlador puede controlar más de un registro, por lo que la finalidad de este
índice es señalar cuál de todos los registros es el que se modificará. El modo de acceder
a cada controlador es distinto, la forma de leer o escribir en los registros será diferente en
cada caso.
La aparición de la tarjeta de video VGA (Video Graphic Array) como en el año 1987, hizo
que se convirtiera en un estándar de los computadores IBM y compatibles.
La VGA tiene una resolución máxima de 640x480 pixeles y puede mostrar

simultáneamente un máximo de 256 colores. Esta resolución es muy alta comparada con
las antiguas tarjetas CGA y EGA.
Lamentablemente para usar los 256 colores solo se puede usar una resolución de
320x200 pixeles. Este modo de vídeo es el conocido Modo 13h, en el cual se han
programado la mayoría de los juegos, demos, aplicaciones gráficas, etc. Este modo es
uno de los más usados en la programación gráfica, debido a su facilidad de uso y rapidez.
Las tarjetas VGA tienen normalmente un mínimo de 256 Kb, estando la memoria dividida
en 4 segmentos o planos. Existe un bit, que puede estar a 1 o 0. En el primer caso (bit a
1) hablamos de modos lineales, limitados a un plano. Cuando el bit está a 0, fuerza a usar
los cuatro planos, por lo que estamos en el caso de los modos denominados planares.
Este bit se denomina CHAIN-4, porque encadena los cuatro planos. La denominación
chained (modos lineales) y unchained (modos planares), hacen referencia al estado de
este bit, indicando que esta a 1 o 0, respectivamente. Los registros de estas tarjetas
pueden ser, de lectura, de escritura, o de lectura/escritura.
Las tarjetas SVGA tienen cada una de ellas su conjunto de registros. El inconveniente que
presentan estas tarjetas, es que aparecen problemas de compatibilidad. No estaremos
seguros de que todos nuestros programas que desarrollemos funcionen correctamente

con todas las tarjetas. Este problema se puede evitar si nos limitamos a utilizar el conjunto
de registros de la VGA, con los que la SVGA son perfectamente compatibles.
Entrando al modo 13h .
El nombre 13h viene del parámetro que hay que pasarle a la interrupción 10h para iniciar
este modo. Esta ultima es un interrupción software que facilita al programador tomar el
control del hardware de un PC. La interrupción 10h esta encargado de dar los servicios de
video.
Ahora para iniciar el modo de video 13h debemos usar la función 00h de la interrupción
10h, y para esto se les pasa unos parámetros.
Qué significa todo esto, lo que sucede es que cada interrupción posee varias funciones y
a su vez cada función también puede tener sub-funciones. En este caso nosotros
queremos iniciar un nuevo modo de video, para esto utilizamos la función 00h de la
interrupción 10h, la cual esta encargada de activar modos de video específicos.
En este caso en el registro de 8 bits AL se le pasa el valor 00h y en el otro registro

(también de 8 bits) se coloca el modo de video a inicializar. A continuación podrás ver los
distintos modos de video, que soporta la tarjeta VGA.
Como podemos ver en la tabla el Modo 13h es uno de los que tiene menor resolución de
los modos gráficos, pero es el que tiene mayor número de colores. Nosotros utilizaremos
dos modos, el 13h y el 03h, este último los usaremos por la sencilla razón, de que cuando
se termina un programa gráfico, se debe regresar nuevamente al modo texto, en este
caso al modo 03h que es el que tienen por defecto todos los PC al ser encendidos. Este
modo texto es de 80x25 y con 16 colores.
Existen modos superiores al 13h, pero estos pertenecen a tarjetas Super VGA o
superiores.
El modo de video que utilizaremos se compone de 320 pixeles horizontales por 200
pixeles verticales, teniendo un total de 64000 pixeles. (320x200=64000)
Después de haber visto todo la teoria necesaria, podremos crear nuestra primera rutina
en lenguaje C para inicializar el modo 13h. Al iniciarse el modo 13h, los registros de la
VGA se programan automáticamente con las características propias de este modo.
Cuando se inicia este modo la memoria de video, en este caso los 64 Kb se limpian, es
decir todos tienen el color 0 (negro). Acuérdense de incluir la cabecera <dos.h> para
utilizar la función int86 y la union REGS.
La turina para incluir este modo sería:
void Modo13h(void)
{
union REGS r;
r.h.ah=0;
r.h.al=0x13;
int86(0x10, &r, &r);
}

Lo que hemos hecho con esta función es simplemente llamar a la interrupción 10h con los
parámetros necesarios para iniciar el modo 13h.
Otra rutina que nos será de mucha utilidad será la que regresa al modo texto, esta función
es similar al anterior, la única diferencia es que al registro AL se le debe pasar el valor
03h.
Podríamos crear una función general para que realice los cambios de modos de video,
esto quedaría así:
void SetMode(char mode)

{
union REGS r;
r.h.ah=0;
r.h.al=mode;
int86(0x10, &r, &r);
}
Otra manera seria:
void SetMCGA(void)
{
_AX=0x0013 ;
geninterrupt(0x10) ;
}
Para volver al modo texto usamos la misma interrupción 10h, sólo que el servicio 03h :
void SetText(void)
{
_AX=0x0003 ;
}
y crear dos constantes con la directiva #define, es decir:
#define TEXTO 0x03

#define GRAFICO 0x13
de esta manera para iniciar el modo 13h, llamaríamos a la función SetMode de la

siguiente forma SetMode(GRAFICO); y para volver al modo texto simplemente:
SetMode(TEXTO);
Veamos de la primera forma:
#include <dos.h> para la funcion int86()

# include <stdio.h> para la funcion printf()
#include <conio.h> para la funcion getch()

void Modo13h(void)
{
union REGS r;
r.h.ah=0;
r.h.al=0x13;
int86(0x10, &r, &r);
}
void ModoTexto(void)
{
union REGS r;
r.h.ah=0;
r.h.al=0x03;
int86(0x10, &r, &r);
void main(void)
{
Modo13h();
printf("Inicializacion correcta\npresione una tecla para volver\n al modo grafico");
getch();
ModoTexto();
printf("Regreso a modo VGA");
getch();
}
De la segunda manera seria:
#include <dos.h> para la funcion int86()

# include <stdio.h> para la funcion printf()
#include <conio.h> para la funcion getch()
unsigned char *DIR_VGA=(unsigned char *) MK_FP(0xA000, 0);
void Modo13h(void)
{
_AX=0x0013 ;
}
{
_AX=0x0003 ;
}
void main(void)
{
Modo13h();
printf("Inicializacion correcta\npresione una tecla para volver\n al modo grafico");

getch();
ModoTexto();
printf("Regreso a modo VGA");
getch();
Un Ejemplo:
Este es un ejemplo sencillo elaborado en el modo 13h (320*200) a 256 colores

que realiza el efecto del fuego. El programa fue compilado con Turbo C
Nota.- El programa debe ser compilado con alguno de estos modelos:

COMPACT,LARGE o HUGE para que pueda funcionar correctamente.
#include <dos.h> para MK_FP,poke,ouportb,geninterrupt

#include <stdlib.h> para random()
#include <conio.h> para kbhit()
typedef unsigned char byte;

byte far* Video= (byte far*)MK_FP(0xA000,0x000);
void Setrgbpalette(byte c,byte r,byte g,byte b)

{
outportb(0x3c8,c);
outportb(0x3c9,r);
outportb(0x3c9,g);
outportb(0x3c9,b);
}
void Modo13h(void)
{
_AL=0x13;
_AH=0;
geninterrupt(0x10);
}
{
_AL=0x03;
_AH=0;
geninterrupt(0x10);
}
void main(void)
{
int x,y,c;
Modo13h();
for(x=1;x<=32;x++){

Setrgbpalette(x,x*2-1,0,0);
Setrgbpalette(x+32,63,x*2-1,0);
Setrgbpalette(x+64,63,63,x*2-1);
Setrgbpalette(x+96,63,63,63);
}
do{
x=0;
do{
y=60;
do{
c=(Video[(y<<8)+(y<<6)+x]+Video[(y<<8)+(y<<6)+x+2]+
Video[(y<<8)+(y<<6)+x-2]+Video[(y+2)*320+x+2])/4;
if(c!=0) c--;
poke(0xA000,(y-2)*320+x,(c<<8)+c);
poke(0xA000,(y-1)*320+x,(c<<8)+c);
y+=2;
}while(y<202);
y-=2;
Video[(y<<8)+(y<<6)+x]=random(2)*160;
x+=2;
}while(x<=320);
}while(!kbhit());
ModoTexto();
}
Ya vimos un ejemplo en el modo13h y que les parecio el efecto del fuego bonito no pero
que dirian si les digo que hay otro metodo de inicializacion que puede darle mas realce a
sus programas,!No es broma ¡, si quieren saber un poco aquí les va:
Se lla modo XGA
Para poder ver estos ejemplos debes de tener intalada las librería que esta incluida en el
tc20 que te obsequiamos
Modo grafico con resolucion de 1024x768x256

(1024 pixeles horizontales, 768 verticales, 256 colores)
Antes que nada debes copiar el archivo Svga256.bgi ,que es un controlador para graficos,
a la carpeta bin de TC20.
Luego tienes que poner dentro del main la siguiente instrucción:
installuserdriver(“Svga256”,DetectVGA256);
“Svga256” es nombre del dispositivo debes omitir la extensión .bgi
DetectVGA256 es una función que debes declarar anteriormente como:
int huge DetectVGA256()
{
return 4;
}
y luego puedes llamar a la funcion initgraph() para empezar a trabajar en modo grafico,
para esta resolucion no estan disponibles las funciones setbkcolor(), ni cleardevice().
Aquí tienes el ejemplo completo:

#include<conio.h>

{ /* 0 = 320x200x256 modo CGA 320(horizontal) con 200(vertical) pixeles(puntos) en
256colores
1 = 640x400x256 modo ATT400
2 = 640x480x256 modo VGA
3 = 800x600x256 modo SVGA
4 = 1024x768x256; modo XGA
Todos son los modos graficos estandar */
return 4;
}
void main()
{ int modo = DETECT, tarj,TIPOLETRA;
int color=0,x=180,y=50;
/*/Instalamos el driver SVGA.bgi para acceder a 256 colores*/

installuserdriver("Svga256",DetectVGA256);
/*Instalamos en nuestro proyecto el tipo de letra*/

TIPOLETRA = installuserfont("LITT.CHR");
/*Iniciamos el modo grafico*/
initgraph(&modo,&tarj,"");
setfillstyle(SOLID_FILL,WHITE); /*elegimos el color de relleno para

dibujar una barra */
bar(0 , 0, 1028, 768); /*y asi simulamos que hemos elegido un color
de fondo*/
/*No se pueden utilizar los comandos cleardevice ni setbkcolor.*/
setcolor(7);
while(color<256)
{ rectangle(x ,y ,x + 40, y + 40);
setfillstyle(SOLID_FILL,color);
bar(x + 1, y + 1, x + 39, y + 39);
x = x + 40;
color++;
if((color%16==0)&&(color!=0))
{ x = 180; y = y + 40;
}
}
settextstyle(TIPOLETRA,0,9); /*usamos el tipo de letra*/
setcolor(41); /*usamos el color numero 18, un gris oscuro*/
outtextxy(40,10,"Prueba de Inicializacion del modo XGA 1024x768
pixeles");
settextstyle(TIPOLETRA,0,6);
setcolor(BLACK);

outtextxy(12,690,"Como ves ahora si puedes usar el color negro en tus

aplicaciones y usar una mayor resolucion: 1024x768");
settextstyle(TIPOLETRA,0,7);
setcolor(55);
outtextxy(425,740,"Huacho - Peru");
getch();
closegraph();
}
Ahora si quieren ver un programa funcionando a qui lo tienen
Programa que carga imágenes .bmp en modo 1024x768:
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <dos.h>
#include <mouse.h>
#define VAR 0
#define INVALIDO -1
#define FALLA 0
#define EXITO 1
#define KB_ESC 27
/* MACROS PARA LAS FUNCIONES GRAFICAS */
#define SEG_VIDEO 0xA000
#define M320x200 0x13
#define MTexto 0x3
struct cabecera {
char ident[2];
unsigned long int tam;
char reservado[4];
unsigned long int offset;
};
struct info_general {
unsigned long int tam_cabecera;
unsigned long int anchura; /* en pixels */
unsigned long int altura; /* en pixels */
int planos;
int tam_pixel; /* tama¤o en bits de cada pixel */
unsigned long int compresion;
unsigned long int tam_imagen; /* en bytes */
unsigned long int h_resolution;
unsigned long int v_resolution;
unsigned long int num_color; /* numero de colores utilizados */
unsigned long int color_imp; /* numeros de colores importantes */
};

struct valor_rgb {
unsigned char azul;
unsigned char verde;
unsigned char rojo;
unsigned char reservado;
};
void modo_video(unsigned char modo);

void setpal(char col,char r,char g,char b);
/*void putpixel(unsigned int x, unsigned int y, unsigned char color);*/
/*-------------------------------------------------------------------------*/
char verifica(char *fname);
void mostrar_pal(void);
void carga(void);
void menu(void);
void presentacion(void);
void info_general(void);
void paleta(void);
void mostrar_imagen(void);
void cambiar_pal(struct valor_rgb *pal);
void despedida(void);
struct cabecera bmp_cab;

struct info_general bmp_info;
struct valor_rgb *rgb;
FILE *f;
char fname[50];
int main()
{
presentacion();
fclose(f);
free(rgb); /* liberamos la memoria utilizada */
return 0;
}
void carga(void)
{
register int i;
/* leemos la cabecera del archivo */

fread( &bmp_cab, sizeof(struct cabecera), 1, f);
/* leemos la informacion general del archivo */
fread( &bmp_info, sizeof(struct info_general), 1, f);
/*leemos todos los colores que existen en la imagen */

if (!bmp_info.num_color) /* si se usan todos los colores */

bmp_info.num_color = 1 << bmp_info.tam_pixel; /* calculamos dependiendo del numero

de bits que ocupa cada pixel */
/* reservamos memoria dinamica para la tabla de colores RGB */

rgb = (struct valor_rgb *) malloc (bmp_info.num_color * sizeof(struct valor_rgb));
fread(rgb, bmp_info.num_color * sizeof(struct valor_rgb), 1, f);

}
void presentacion(void)
{
char control;
clrscr();
printf("%55s","---VISUALIZADOR DE IMAGENES BMP---");

printf("\n\n\n Introduzca el nombre y ruta de ser necesario");
printf("\n ARCHIVO: ");
gets(fname);
if (!fname[0])
exit(0);
control = verifica(fname);
if (control == FALLA)
{
printf("\n ERROR FATAL: el archivo no existe o esta protegido...");
exit(1);
}
if (control == INVALIDO)
{
printf("\n ERROR FATAL: el archivo no es un BMP valido... ");
exit(1);
}
/* llamamos al menu principal */

menu();
}
char verifica(char *fname)

{
f = fopen(fname,"rb");
if (!f)
return (FALLA);
carga(); /* leemos y almacenamos del archivo */
/* comprobamos que sea un archivo valido BMP */

if (bmp_cab.ident[0] == 'B' && bmp_cab.ident[1] == 'M')
return (EXITO);

else
return (INVALIDO);
void menu(void)
{
char opcion;
for (;;)
{
clrscr();
printf("\n\n (1) INFORMACION GENERAL DEL ARCHIVO");
printf("\n\n (2) PALETA DE COLORES USADAS");
printf("\n\n (3) MOSTRAR PALETA");
printf("\n\n (4) VISUALIZAR IMAGEN");
printf("\n\n (5) SALIR");
printf("\n\n OPCION: ");
opcion = getche();
switch (opcion)
{
case '1': info_general(); break;
case '2': paleta(); break;
case '3': mostrar_pal(); break;
case '4': mostrar_imagen(); break;
case '5': despedida();
}
} /* termina bucle for(;;) */
}
void info_general(void)
{
clrscr();
printf("%35s%s>\n","<",fname);
printf("\n Tama¤o del archivo: %ld bytes",bmp_cab.tam);
printf("\n Offset del archivo: %ld",bmp_cab.offset);
printf("\n Tama¤o de la cabecera: %d bytes",bmp_info.tam_cabecera);
printf("\n Anchura: %d pixels",bmp_info.anchura);
printf("\n Altura: %d pixels",bmp_info.altura);
printf("\n Numero de planos: %d",bmp_info.planos);
printf("\n Numero de bits por pixel: %d bits",bmp_info.tam_pixel);
printf("\n Compresion: %d ",bmp_info.compresion);
printf("\n Tama¤o de la imagen: %ld bytes",bmp_info.tam_imagen);
printf("\n Resolucion horizontal: %d pixels/metros",bmp_info.h_resolution);
printf("\n Resolucion vertical: %d pixels/metros",bmp_info.v_resolution);
printf("\n Numero de colores utilizados: %d colores",bmp_info.num_color);
printf("\n Numero de colores importantes: %d colores",bmp_info.color_imp);
printf("\n\n\n PRESIONE CUALQUIER TECLA PARA CONTINUAR...");

getch();
}
void cambiar_pal(struct valor_rgb *pal)

{
register int i;
for (i = 0; i < 256; i++)

setpal( i, pal[i-VAR].rojo / 4, pal[i-VAR].verde / 4, pal[i-VAR].azul / 4);
}
void paleta(void)
{
register int i,j;
char opcion;
clrscr();
printf("\n %10s %10s %10s %10s\n\n","Color","Rojo","Verde","Azul");

for (i = 0, j = 1; i <= (bmp_info.num_color); i++, j++)
{
if (j == 20 || i == (bmp_info.num_color) )
{
j = 0;
i--;
gotoxy(1,25);
printf(" Presione [ESC] para salir o cualquier tecla para continuar....");
opcion = getch();
if (opcion == KB_ESC)
break;
if (i+1 == (bmp_info.num_color))
break;
clrscr();
printf("\n %10s %10s %10s %10s\n\n","Color","Rojo","Verde","Azul");
continue;
}
printf("\n %10d %10d %10d %10d", i, rgb[i].rojo, rgb[i].verde, rgb[i].azul);
}
}
void mostrar_imagen(void)
{
register int x,y;
char *linea;
int resto;
unsigned long int posicion;
posicion = ftell(f); /* tomamos la posicion del puntero del archivo */

modo_video(M320x200);
mver();
cambiar_pal(rgb);
/* reservamos memoria suficiente para albergar una linea de pixeles */

linea = (char *) malloc (bmp_info.anchura);
/* calculamos la cantidad de bytes necesario que sumado con la anchura

sea un multiplo de cuatro */
resto = (4 * ((bmp_info.anchura + 3) >> 2)) - bmp_info.anchura;
for (y = bmp_info.altura - 1; y >= 0; y--)

{
fread(linea, bmp_info.anchura, 1, f);
for (x = 0; x < bmp_info.anchura; x++)
putpixel(x,y,linea[x]);
fseek(f, resto, SEEK_CUR);
}
getch();
fseek(f, posicion, SEEK_SET); /* restauramos la posicion inicial del puntero */
modo_video(MTexto);
}
void mostrar_pal(void)
{
register int i,j;
modo_video(M320x200);
cambiar_pal(rgb);
for (i = 0; i < 256; i++)

for (j = 0; j <= 50; j++)
putpixel(i,j,i);
getch();
modo_video(MTexto);
}
void despedida(void)
{
clrscr();
gotoxy(20,13);
printf("ESPERO QUE HAYA DISFRUTADO DEL PROGRAMA...");
getch();
exit(0);
}

/* ----FUNCIONES GRAFICAS ESCRITAS EN ENSAMBLADOR PARA SU MAYOR

RAPIDEZ---- */

{
return 4;
}
void modo_video()
{
int a=DETECT,b;
installuserdriver("Svga256",DetectVGA256);
/* union REGS r;
r.h.ah=0;
r.h.al=0x13;
int86(0x10,&r,&r);*/
}
/*void putpixel(unsigned int x, unsigned int y, unsigned char color)

{
unsigned char *vga=(unsigned char *) MK_FP(0xA000, 0);
asm {
push ax
push bx
push di
push es
mov ax,SEG_VIDEO
mov es,ax
mov bx,[y]
mov di,bx
shl bx,8
shl di,6
add di,bx
add di,[x]
mov bl,[color]
mov es:[di],bl
pop es
pop di
pop bx
pop ax
}
memset(vga+x+(y*320),color,1);
}*/
void setpal(char col,char r,char g,char b)

{

/*asm {
mov dx,03c8h;
mov al,col;
out dx,al;
mov dx,03c9h;
mov al,r;
out dx,al;
mov al,g;
out dx,al;
mov al,b;
out dx,al;
} */
outportb(0x3c8,col);
outportb(0x3c9,r);
outportb(0x3c9,g);
outportb(0x3c9,b);
}
Ahora un Ejemplo de la utilización de las estructuras este programa se llama reloj

analogo muestra la hora del sistema.
#include <stdio.h>
#include <dos.h>
#include <math.h>
#include <conio.h>
#include <stdio.h>
void main(void)
{
struct time tiempo;
int a=DETECT,b;
int radio=180;
int seg,min,w,h;
float angulmin, anguloseg, angulhora,hora;
char mensaje[20];
int xseg, yseg, xmin, ymin, xhora, yhora;
circle(310,240,238);
h=0;
for(w=0;w<=60;w++){
if(h%5==0)
setcolor(RED);
else
setcolor(WHITE);
outtextxy(310+sin(6*h*(3.141592/180))*225,240-cos(h*(3.141592/180)*6)*225,"*");
h+=1;
}

settextstyle(1,0,2);
outtextxy(300,20,"12");
outtextxy(520,230,"3");
outtextxy(310,433,"6");
outtextxy(100,230,"9");
do{
gettime(&tiempo);
seg=tiempo.ti_sec;
min=tiempo.ti_min;
hora=tiempo.ti_hour;
if(hora>12)
hora-=12;
hora+=(min/60);
anguloseg=((seg-15)/(3*3.14159));
angulmin=((min-15)/(3*3.14159));
angulhora=((hora*5-15)/(3*3.14159));
setcolor(WHITE);
circle(310,240,8);
rectangle(240,390,360,420);
sprintf(mensaje,"%2.0f: %2.0d: %2.0d",hora,tiempo.ti_min,tiempo.ti_sec);
xseg = 310 + radio * cos(anguloseg);

yseg = 240 + radio * sin(anguloseg);
xmin = 310 + 120 * cos(angulmin);
ymin = 240 + 120 * sin(angulmin);
xhora= 310 + 90 * cos(angulhora);
yhora= 240 + 90 * sin(angulhora);
setcolor(WHITE);
line(310,240,xseg,yseg);
setcolor(GREEN);
line(310,240,xmin,ymin);
setcolor(RED);
line(310,240,xhora,yhora);
sleep(1);
setcolor(BLACK);
line(310,240,xseg,yseg);
line(310,240,xmin,ymin);
line(310,240,xhora,yhora);
} while(!kbhit());
}

Ahora aremos un efecto que talvez les guste y lo estudien con detenimiento ya que
merece mucha atención.
Primero guarda estas lineas de codigo en un programa de C con el nombre TECLA.C
#define ARRIBA 72
#define ABAJO 80
#define DERECHA 77
#define IZQUIERDA 75
#define ESC 27
#define ENTER 13
Ahora en otro programa copia este codigo y te sorprenderas de ver lo que hace
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <dos.h>
#include <conio.h>
#include "tecla.c" //es para el manejo del teclado
float A,B,TAM=15,fi= -M_PI/7,teta= -M_PI/7,pro_X,pro_Y;

/*
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Definicion de funciones º
º º
ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ¼
*/
void IniciarGraficos();
void xyz();
void ProyectaPunto(float ,float ,float);
void Objeto();
void instrucciones();
/*****************************************************************/
/*
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ ProyectaPunto ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Funcion: Localiza un punto en la pantalla 3D º
º º
*/
void ProyectaPunto(float x, float y, float z)
{
pro_X = y*cos(teta) + x*sin(teta);
pro_Y = z*cos(fi) + x*cos(teta)*sin(fi) - y*sin(fi)*sin(teta);
}
/*
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ IniciarGraficos ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Funcion: Inicializa el modo grafico º
º º

*/
void IniciarGraficos()
{
int Tarjeta=VGA,Modo=VGAHI;
initgraph(&Tarjeta,&Modo,"");
if(graphresult()!=grOk){
printf("\nSi perdiste el archivo EGAVGA.BGI no podes correr el programa :(
asi que buscalo el C:\\tc\\bgi");
getch();
exit(0);
}
}
/*
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ Main ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Funcion: Main. º
º º
*/
void main()
{
IniciarGraficos();
A=getmaxx()/2,B=getmaxy()/2;
xyz();
Objeto();
closegraph();
}
/*
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ xyz ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Funcion: Dibuja Lineas de Guia en las coordenadas X,Y,Z º
º º
*/
void xyz()
{
float X0,Y0,X,Y,z,tam=3;
int x,y;
setcolor(8);
ProyectaPunto(0,0,0);X0 = pro_X,Y0 = pro_Y;
ProyectaPunto(tam,0,0);X = pro_X,Y = pro_Y;
line(A + X0*TAM,B - Y0*TAM,A + X*TAM,B - Y*TAM);
x=A + X*TAM,y=B - Y*TAM;
setcolor(8);
outtextxy(x,y,"x");
setcolor(8);
ProyectaPunto(0,tam,0);X = pro_X,Y = pro_Y;


x= A + X*TAM,y=B - Y*TAM;
setcolor(8);
outtextxy(x,y,"y");
setcolor(8);
ProyectaPunto(0,0,tam);X = pro_X,Y = pro_Y;
setcolor(8);
outtextxy(x,y,"z");
ProyectaPunto(0,10,0);X=pro_X,Y = pro_Y;
setcolor(RED);
outtextxy(x,y,"JDZx");
setcolor(8);
}
/*
ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ Objeto ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»
º Funcion: Dibuja un objeto 3D º
º º
*/
void Objeto()
{
float angulo=-M_PI/100.0;
float AA[8],BB[8],CC[12],estrellas[2],EE[8],FF[8],
xa1=3,ya1=-3,za1=-3,xa2=-3,ya2=-3,za2=-3,
xa3=-3,ya3=-3,za3=3,xa4=3,ya4=-3,za4=3,
xb1=3,yb1=3,zb1=-3,xb2=-3,yb2=3,zb2=-3,
xb3=-3,yb3=3,zb3=3,xb4=3,yb4=3,zb4=3;
float x,y;
unsigned char tecla;
int fo;
do{
ProyectaPunto(xa1,ya1,za1);AA[0]=pro_X,AA[1]=pro_Y;
ProyectaPunto(xa2,ya2,za2);AA[2] = pro_X,AA[3] = pro_Y;
/*-------------------------------------------*/
ProyectaPunto(xb1,yb1,zb1);BB[0]=pro_X,BB[1]=pro_Y;
ProyectaPunto(xb2,yb2,zb2);BB[2] = pro_X,BB[3] = pro_Y;
ProyectaPunto(5,8,0);CC[0]=pro_X,CC[1]=pro_Y;
ProyectaPunto(-4,-8,0);CC[4]=pro_X,CC[5]=pro_Y;
ProyectaPunto(5,-5,3);CC[6]=pro_X,CC[7]=pro_Y;
ProyectaPunto(10,5,-1);CC[8]=pro_X,CC[9]=pro_Y;
ProyectaPunto(0,0,0);CC[10]=pro_X,CC[11]=pro_Y;
setcolor(1);

circle(A + CC[0]*TAM,B - CC[1]*TAM,TAM*0.52);

setcolor(2);
setcolor(3);
setcolor(4);
setcolor(YELLOW);
/*-----------------------*/
ProyectaPunto(5,0,2);estrellas[0] = pro_X,estrellas[1] = pro_Y;
putpixel(A + estrellas[0]*TAM,B - estrellas[1]*TAM,7);
ProyectaPunto(-15-0.2,5,-2);estrellas[0] = pro_X,estrellas[1] = pro_Y;

setcolor(8);
circle(A + estrellas[0]*TAM,B - estrellas[1]*TAM,TAM*0.2);
ProyectaPunto(-10,-3,-2);estrellas[0] = pro_X,estrellas[1] = pro_Y;

ProyectaPunto(-10,-3,-2);estrellas[0] = pro_X,estrellas[1] = pro_Y;
putpixel(B + estrellas[1]*TAM,A - estrellas[1]*TAM,7);
ProyectaPunto(-5,3,-2);estrellas[0] = pro_X,estrellas[1] = pro_Y;
ProyectaPunto(10,-3,-2);estrellas[0] = pro_X,estrellas[1] = pro_Y;
xyz();
line(A + AA[0]*TAM,B - AA[1]*TAM,A + AA[2]*TAM,B - AA[3]*TAM);

line(A + AA[0]*TAM,B - AA[1]*TAM,A + BB[0]*TAM,B - BB[1]*TAM);

line(A + BB[0]*TAM,B - BB[1]*TAM,A + BB[2]*TAM,B - BB[3]*TAM);

tecla=IZQUIERDA;
if(kbhit())
{
tecla=getch();
}
setfillstyle(1,0);

switch(tecla)
{
case DERECHA:teta-=angulo;break;
case IZQUIERDA:teta+=angulo;break;
case ABAJO:fi+=angulo;break;
case ARRIBA:fi-=angulo;break;
case 122:if(TAM>0)TAM-=0.2;break;
case 120:if(TAM<30)TAM+=0.2;break;
}/*endcase*/
if(!kbhit()){delay(50);}
bar(0,0,getmaxx(),getmaxy());
}while(tecla!=ESC);
}
/*Ahora un juego de la serpientes este es un programa que encontre en Internet, no se

quien es el autor, le hice algunos cambios */
#include<stdlib.h>
# include <dos.h>
#include<stdio.h>
#include<conio.h>
#define clear; clrscr();

#define colorfondo 0
#define colorcabeza 4
#define c 1
#define bordear 40
#define bordeab 460 /*acotamos la parte valida de pantalla*/
#define bordeiz 20
#define bordede 620
void Inicio(void);
void Salir(void);
void Juego(void);
void Avanza(void);
void Crece(void);
void Libera(void);
void Pinta_serpiente(void);
void Pinta_rapido(void);
int Choque(void);
void Pinta_pantalla(void);
int Es_punto(int x,int y);
void Lee_record(void);
void Escribe_record(void);

struct bola{
int x;
int y; /*La serp no es mas que una lista doble de puntos con su x y su y*/
struct bola *sig,*ant;
};
int m,v,vel,tarj,modo,puntos,max,punt[9]={90,80,70,60,50,40,30,20,10};
int longitud=0,radio=5,xa,ya,superado=0; /*No hay mas remedio que usar todas estas
globales*/
struct bola *cabeza,*indice,*ultimo; /*Para la lista*/
void main(void)
{
detectgraph(&tarj,&modo);/*comprueba el hw y detecta la tarjeta a usar*/
Inicio();
Juego();
}
void Inicio(void)
{
int i;
clear;
textcolor(14);
for (i=1; i<81; i++)
{
gotoxy(i,9);
cprintf ("Ä");
}
textcolor(1);
gotoxy(34,1); cprintf (" Û Û");
gotoxy(34,2); cprintf (" Û ÛÛ ÛÛ Û");
gotoxy(34,3); cprintf (" ÛÛÛÛÛ ÛÛÛÛÛ");
gotoxy(34,4); cprintf ("ÛÛ ÛÛÛ ÛÛÛ ÛÛ");
gotoxy(34,5); cprintf ("ÛÛ ÛÛÛÛÛÛÛ ÛÛ");
gotoxy(33,6); cprintf ("ÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ");
gotoxy(33,7); cprintf ("ÛÛÛÛÛÛÛÛÛÛÛÛÛÛÛ");
gotoxy(34,8); cprintf ("ÛÛÛÛÛÛÛÛÛÛÛÛÛ");
gotoxy(38,9); cprintf ("Û");gotoxy(42,9); cprintf("Û");
textcolor(4);
gotoxy(40,1); cprintf("Û");gotoxy(40,2); cprintf("Û");
gotoxy(39,7); cprintf("O");gotoxy(41,7); cprintf("O");

textcolor(9);
gotoxy(31,10); cprintf ("ÛÛÛ Û Û ÛÛÛ ÛÛÛ ÛÛÛ");
gotoxy(31,11); cprintf ("Û Û Û Û Û Û Û Û");
gotoxy(31,12); cprintf ("Û ÛÛÛ ÛÛÛ Û Û ÛÛÛ");
gotoxy(31,13); cprintf ("Û Û Û Û Û Û Û Û");
gotoxy(31,14); cprintf ("ÛÛÛ Û Û Û Û ÛÛÛ ÛÛÛ");
textcolor(15);
gotoxy(29,16); cprintf ("Dise¤ado por Abdul Ruiz");
gotoxy(31,17); cprintf ("CopyRight (c) 2002");
getch();
gotoxy(29,19); cprintf("Espera, por favor...");
delay(5500);
clear;
cprintf("TECLAS:\n\n\r");
cprintf(" -(Ar) 5(Ar)\n\r");
cprintf("MOVIMIENTOS o en el t.num.\n\r");
cprintf(" <Ä(Izq) (Ab) Ä>(Der) 1(Izq) 2(Ab) 3(Der)\n\r");
cprintf("Pausa: P\n\r");
cprintf("Salir: S\n\n\r");
cprintf("Si utilizas el teclado numerico, asegurate de que este activado\n\n\n\r");
cprintf("Pulsa una tecla para empezar");
getch();
sleep(5);
clear;
cprintf ("Dime el nivel de dificultad 1(Minima)...9(Maxima): ");
do{ scanf("%d",&m); }while(m<1 || m>9);
switch(m)
{
case 1:v=9;break;case 2:v=8;break;case 3:v=7;break;case 4:v=6;break;case
5:v=5;break;
case 6:v=4;break;case 7:v=3;break;case 8:v=2;break;case 9:v=1;break;
}
}
void Juego(void)
{
int obj=0;/*Para saber si hay algo de comida en la pantalla*/
int mov=radio*2;
char t,a;/*La tecla pulsada y la anterior*/
char pito=7;
int x2,y2;
initgraph(&tarj,&modo,"c:\\tc20\\bin");/*iniciamos modo grafico*/

setbkcolor(colorfondo);/*configuramos los colores del juego*/
setcolor(colorfondo);
setfillstyle(1,c);

Lee_record();
t=77;/*ponemos una tecla (para que empiece yendo hacia la derecha)*/
superado=0;
vel=v*300;
Crece(); /*creamos la cabeza*/

cabeza->x=bordeiz+radio; /*la colocamos*/
cabeza->y=bordeab-radio;
Crece(); /*ponemos otras dos bolitas de cuerpo*/
Crece();
Pinta_pantalla();
gotoxy(35,15);
printf("ADELANTE");
delay(10000);
cleardevice();
do
{
/*si no hay objeto, cogemos una pos aleatoria*/
if(obj==0)
{
do{
do{
x2=(((rand()%((bordede/(radio*2))-1)+1))*radio*2)-radio;
}while(x2>bordede-radio || x2<bordeiz+radio);
do{
y2=(((rand()%((bordeab/(radio*2))-1)+1))*radio*2)-radio;
}while(y2>bordeab-radio || y2<bordear+radio);
}while(Es_punto(x2,y2));
obj=1;
/*si se pulsa una tecla*/

if(kbhit())
{
a=t; /*se guarda la anterior*/
t=getch(); /* y se coge*/
}
if(Choque())
{
printf("%c",pito); /*si se choca, pierde*/
Salir();
}

Pinta_pantalla();
if(obj==1) /*si hay objeto, lo pintamos de otro color*/

{
setfillstyle(1,12);
fillellipse(x2,y2,radio-2,radio-2);
setfillstyle(1,c);
}
switch(t) /*evalua la tecla*/

{
case 72:
case '5':
Avanza();
cabeza->y=cabeza->y-mov;
break; /*arriba */
case 75:
case '1':
Avanza();
cabeza->x=cabeza->x-mov;
break; /*izquierda */
case 77:
case '3':
Avanza();
cabeza->x=cabeza->x+mov;
break; /*derecha */
case 80:
case '2':
Avanza();
cabeza->y=cabeza->y+mov;
break; /*abajo*/
case 's':
case 'S':
/*si quiere salir, liberamos mem, cerramos el modo grafico y exit*/
Libera();
closegraph();
Escribe_record();
exit(2);
break;
case 'p':/*pausa*/

cleardevice();
Pinta_serpiente();
gotoxy(37,15);
printf("Pausa");
t=getch();
cleardevice();
Pinta_serpiente();
break;
/*si la tecla pulsada no hace nada, volvemos a poner la enterior*/

default: t=a;
}
/*si se pasa por encima del objeto, se borra y se crece*/

if(cabeza->x==x2 && cabeza->y==y2)
{
puntos+=punt[v-1];
obj=0;
printf("%c",pito);
switch(m)
{
case 1: Crece(); break;
case 2:
case 3: Crece();Crece();break;
case 4:
case 5: Crece();Crece();Crece();break;
case 6:
case 7:
case 8: Crece();Crece();Crece();Crece();Crece();break;
case 9:
Crece();Crece();Crece();Crece();Crece();Crece();break;
}
}
/*cuantas mas bolas tenga que dibujar el ordenador, mas se*/

/*ralentiza el juego, esto lo contrarestamos disminuyendo el delay*/
/*cada 30 bolitas(lo he calculado a ojo)
if((longitud)/(i*30)<0)
{
vel-=15;
i++;
}*/
delay(vel);
if(puntos>max)
{

max=puntos;
superado=1;
}
}while(1);
}
void Salir(void)
{
char opc;
/*no hace falta comentar nada*/
if(superado!=0)
{
Escribe_record();
gotoxy(11,10);
printf(" Puntuacion maxima conseguida, eres el mejor, felicidades");
}
gotoxy(11,15);
printf("Estas muerto, lo siento (R)Reintentar,(I)Reiniciar,(S)Salir");
do{
opc=toupper(getch()); }while(opc!='R' && opc!='I' && opc!='S');
puntos=0;
switch (opc)
{
case 'R':
Libera();
Juego();
break;
case 'I':
closegraph();
Libera();
Inicio();
Juego();
break;
case 'S':
closegraph();
Libera();
exit(1);
break;
}
}
void Avanza(void)
{
indice=ultimo;

xa=ultimo->x;
ya=ultimo->y;
/*nos quedamos con la posicion de la cola*/
/*corremos cada bola a la pos de la bola anterior*/

while(indice!=cabeza)
{
indice->x=indice->ant->x;
indice->y=indice->ant->y;
indice=indice->ant;
}
}
void Pinta_serpiente(void)
{
int i=0;
indice=cabeza;
setfillstyle(1,colorcabeza);
fillellipse(indice->x,indice->y,radio,radio);
setfillstyle(1,c);
i++;
indice=indice->sig;
/*sin comentarios*/
while(i<longitud)
{
fillellipse(indice->x,indice->y,radio,radio);
i++;
indice=indice->sig;
/*Como hemos comprobado en anteriores versiones, al pintar la serpiente entera*/

/*, si esta media mucho, se ralentizaba el juego mogollon, y sabemos que, al pintar*/
/*una bola y moverla, se queda su estela pintada, no?, co¤o pues pintemos solo*/
/*la primera, segunda y ultima bolita, y asi, mida lo que mida la serpiente,*/
/*solo pintaremos 3 bolas, y no se ralentiza casi nada.*/
void Pinta_rapido(void)
{
setfillstyle(1,colorcabeza);
fillellipse(cabeza->x,cabeza->y,radio,radio);
setfillstyle(1,c);
fillellipse(cabeza->sig->x,cabeza->sig->y,radio,radio);
fillellipse(ultimo->x,ultimo->y,radio,radio);

int Choque(void)
{
indice=cabeza->sig;
/*si la cabeza esta en la pos de alguna bola o sale de los limites,

devolvemos un 1*/
while(indice!=NULL)
{
if(cabeza->x==indice->x && cabeza->y==indice->y) return 1;
if((cabeza->y<bordear+radio)||(cabeza->x<bordeiz+radio)||(cabeza-
>x>bordede-radio)||(cabeza->y>bordeab-radio)) return 1;
indice=indice->sig;
}
return 0;
}
void Crece(void)
{
struct bola *este;
este=malloc(sizeof(struct bola));
/*pues eso, se a¤ade una struct bola al final de la lista*/
if(cabeza==NULL)
{
ultimo=cabeza=este;
cabeza->ant=NULL;
ultimo->sig=NULL;
cabeza->x=bordeiz+radio;
cabeza->y=bordeab-radio;
}
else
{
ultimo->sig=este;
este->ant=ultimo;
ultimo=este;
ultimo->sig=NULL;
este->x=-100;
este->y=-100;
}
indice=ultimo;
longitud++;
}

void Libera(void)
{
struct bola *aux;
indice=cabeza;
/*no hace falta comentario*/
cabeza=ultimo=NULL;
while(indice!=ultimo)
{
aux=indice;
indice=indice->sig;
free(aux);
}
aux=indice;
free(aux);
longitud=0;
}
void Pinta_pantalla(void)
{
gotoxy(1,1);
printf(" Serpiente v1 Desarrollado por Abdul Ruiz Chaos\n\r");
gotoxy(10,2);
printf("Nivel : %1d Punt.Max. : %4d Puntuacion :%4d Longitud
:%4d",m,max,puntos,longitud);
Pinta_rapido(); /* dibujamos la serp */
/*"borramos" la ultima bola*/

/*este metodo es mas util, porque usando un cleardevice(), la
pantalla vibraba mucho*/
setfillstyle(1,colorfondo);
fillellipse(xa,ya,radio,radio);
setfillstyle(1,c);
/* dibujamos los bordes de la pantalla */

setcolor(15);
rectangle(bordeiz-1,bordear-1,bordede+1,bordeab+1);
setcolor(0);
}
int Es_punto(int x,int y)

{
indice=cabeza->sig;

while(indice!=NULL)
{
if(x==indice->x && y==indice->y) return 1;
indice=indice->sig;
}
return 0;
}
void Lee_record(void)
{
FILE *arch;
if((arch=fopen("chaos.ars","rb"))!=NULL)
{
fread(&max,1,sizeof(int),arch);
if(puntos>max)
{
max=puntos;
}
fclose(arch);
}
else
{
max=puntos;
}
}
void Escribe_record(void)
{
FILE *arch;
arch=fopen("chaos.ars","wb");
fwrite(&max,1,sizeof(int),arch);
fclose(arch);
}

1 Introducción a la Geometría Computacional
1.1. Historia de la Geometría Computacional
La Geometría fue estudiada desde la antigua Grecia y Egipto. Constituían una

herramienta muy importante para resolver problemas prácticos. El primer
algoritmo que pueda considerarse completo es la construcción Euclídea, porque
fue el primero que satisfizo todos los requerimientos: es correcto, no ambiguo
y tiene un final. Este algoritmo además da una colección de instrucciones y
reglas, posee un conjunto de primitivas asociadas.
Ya en 1902 se describió un conjunto de pasos para contar como realizar sobre

papel una serie de primitivas Euclídeas. Se hablaba por entonces ya del
término complejidad, no computacional pero sí de dificultad para medir la
complicación de su realización. Se puede decir que fue una aproximación a lo
que entendemos hoy por .complejidad temporal.. No se hablaba del problema
en función del conjunto de entrada, pero sí intentaban reducirse el número de
pasos a realizar para resolver un problema. Poco a poco se fueron dando
cuenta de que todo problema posee un esfuerzo mínimo de realización, lo que
nosotros llamamos .complejidad del algoritmo..
Ya en 1672 se demostró que cualquier construcción que pudiera realizarse sólo

con regla y compás podría hacerse usando sólo compás. El concepto de línea
se amplió pasando a ser el lugar geométrico compuesto por la unión de los
puntos de corte de dos arcos realizados con un compás.
La Geometría ha tenido momentos de especial realce, por ejemplo el

crecimiento del análisis real, la Geometría métrica y la teoría de la convexidad,
han supuesto las herramientas matem áticas para el diseño de algoritmos
rápidos. Por un lado la distancia es un tema esencial en conceptos geométricos
y la teoría de la convexidad es analizada para obtener propiedades globales.
La Geometría Algorítmica está basada en caracterizaciones de objetos

geométricos en términos de propiedades de subconjuntos finitos. Un
tratamiento algorítmico implica eliminar el término infinito. Hoy día la
Geometría Computacional se utiliza como herramienta básica, no sólo en
disciplinas inmediatamente relacionadas con la Geometría. A partir de finales
de los años 60 y 70, el incremento del uso de la computadoras en
investigación y desarrollo, propicia usar estas máquinas para resolver
problemas clásicos que siempre fueron resueltos a base de reglas y compás.
Pero la memoria de las máquinas y el tiempo de ejecución de éstas, la mayoría

de las veces compartido, exigió de pronto el conseguir métodos que no sólo
funcionaran, sino que intentaran optimizar al máximo dos recuerdos muy
importantes, sobre todo por aquel entonces: la memoria y el tiempo de CPU.
Hoy por hoy a pesar de utilizar máquinas más potentes, también se plantea en

muchas ocasiones incrementar el número de datos a procesar, por lo que hoy

sigue siendo un problema a resolver.
Algunas aplicaciones donde la Geometría Computacional es necesaria es la

Informática Gráfica, Robótica, Sistemas de Información Geográficos, etc. El
término nace en 1975 por Shamos y desde entonces los trabajos y los
estudios en esta disciplina han ido creciendo de forma espectacular.
1.2. Eficiencia de los algoritmos
Existen distintas formas de medir algoritmos o de clasificarlos. Un algoritmo

fácil de entender, codificar y depurar es preferible a otro que realice lo mismo
pero que no cumpla estas carácter ísticas. Algo similar ocurre con respecto a la
eficiencia; un algoritmo es eficiente cuando usa adecuadamente los recursos
del ordenador y lo hace con la mayor rapidez posible. Los recursos son siempre
referidos al tiempo de ejecución y al tiempo de CPU que necesita para
ejecutarse.
Para optar por escribir un tipo de algoritmo que cumpla con las
especificaciones anteriores tambi én es necesario saber cuantas veces va a
ejecutarse dicho algoritmo y con qué cantidad de datos. Así, un algoritmo poco
eficiente con pocos datos es preferible utilizarlo a otro que necesite gran
cantidad de tiempo en diseñarse. Por el contrario es beneficioso en muchas
ocasiones realizar un buen diseño a pesar de utilizar gran cantidad de esfuerzo
y emplear estructuras de datos complejas, si se consigue finalmente un
método de resolución que realice buenos tiempos de ejecución para entradas
grandes de datos. Por otra parte, cuando nuestro algoritmo pretende resolver
un problema clásico, como puede ser en Geometría Computacional, se da por
supuesto que tiene que ser eficiente con grantes cantidades de datos y además
hay que suponer que dicho algoritmo va a ser ampliamente utilizado.
Por tanto, nuestro propósito es no sólo entender y utilizar algoritmos que

funcionen en Geometría Computacional sino que también sean eficientes. Para
medir dicha eficiencia, hay que tener en cuenta ciertos parámetros:
 Dependencia de los datos de entrada del programa.

 Calidad del código que genera el compilador en el programa objeto.
 Las instrucciones y arquitectura de las computadoras.
 Tiempo de ejecución de dicho programa.
Como entrar en detalles de compiladores diferentes y de distintas arquitecturas

es muy amplio y además es absolutamente cambiante, basta decir que cuanto
más rápido mejor. Lo que haremos será estudiar los algoritmos en función de
la entrada, básicamente de su tamaño, y además en la complejidad o tiempo
que emplea el algoritmo para su ejecución. Obviamente un algoritmo, o
programa puesto que se está ejecutando, va a ser más rápido si tiene que
procesar diez datos que si tiene que realizar lo mismo con una entrada de
tamaño cien.

Vamos a denominar T(n) al tiempo de ejecución de un programa con tamaño

n. Para no especi ficar el tiempo en segundos, puesto que depende
excesivamente de la máquina empleada, se usará una función expresada en
términos de n. Por ejemplo, T(n) = cn2, siendo c una constante.
En muchas ocasiones es necesario referirse al tiempo de ejecución esperado

del algoritmo en el peor de los casos para una entrada de tamaño n. De esta
forma se puede acotar el problema con una cota superior que nos permita
conocer el margen en el que nos podemos mover. El caso medio también
puede ser interesante en casos donde se conozca que el peor caso se produce
con una probabilidad muy pequeña.
Cuando decimos que el tiempo de ejecución T(n) de un programa es O(n2)

significa que existen constantes enteras positivas c tales que T(n) fi cn2. Por
tanto es lo que llamamos cota superior que nos identifica el peor caso. En el
caso genérico decimos que T(n) es O( f (n)). También existen cotas inferiores
para hablar del tiempo de ejecución. Es una cota inferior o lo que es lo mismo:
el algoritmo se ejecutará al menos en el tiempo que la función g(n) indica. Se
dice que T(n) es (g(n)) cuando existe una constante c tal que T(n) fi cg(n).
Cuanto menor sea la representación gráfica de la función f (n), más rápido se

ejecutará el algoritmo para un conjunto de entrada de tamaño dado. Pero esto
no siempre es verdadero para todo n, es decir, en ocasiones el tiempo de
ejecución se refiere a grandes cantidades de información y por tanto, n tiende
a infinito. Así O(n2) es mejor que O(n3); O(n) es mejor que O(n2) pero peor
que O(nlogn). Por ejemplo un programa con tiempo O(100n) es más lento para
n menor que 20 que otro que se ejecute en tiempo O(5n2). En algoritmos
típicos de Geometría Computacional lo que se busca sobre todo son
ejecuciones en tiempo lineal O(n), o en O(nlog n).
A menos que un algoritmo tenga una velocidad de crecimiento baja, O(n) o

O(nlogn), un crecimiento modesto en la rapidez de la computadora no infiuirá
gran cosa en el tamaño del problema.
A pesar de todo lo expuesto anteriormente, si un algoritmo va a ser utilizado

pocas veces, el costo de escritura de una algoritmo eficiente puede que no
merezca la pena. Tampoco es necesario si siempre va a recibir un conjunto de
entrada pequeño. En algunas ocasiones un algoritmo puede permitirse el lujo
de ser algo más lento si a cambio es más didáctico. Por otro lado, si la
eficiencia a nivel de tiempo en CPU implica un alto coste en cantidad de
almacenamiento o porque se encuentre en dispositivos de memoria masiva.
Por último, en algoritmos numéricos es tan importante la precisión de los
cálculos como la eficiencia de éstos.
Para calcular la eficiencia de un algoritmo hay que tener en cuenta ciertos

casos:

 Si T1(n) y T2(n) son tiempos de ejecución de dos fragmentos de

programa, el tiempo totalserá de T1(n)+T2(n). Sin embargo, se
considera únicamente el más lento de los dos y eltiempo de ejecución
vendrá dado por tanto por O(max( f (n);g(n)) , siendo O( f (n)) eltiempo
para T1(n) y O(g(n)) para T2(n). También existen simplificaciones, por
ejemplo,O(c f (n)) se considera siempre O( f (n)).
 Una asignación u operación aritmética suele considerarse con tiempo

O(1).
 En las proposiciones condicionales, la parte de la condición suele

considerarse tiempoconstante si no necesita realizar llamadas a otras
funciones. El tiempo global de esta instrucción se toma de nuevo como
el mayor de las dos partes que la forman, parte then o parte else.
 En un ciclo se suele determinar por el número de iteraciones

multiplicadas por el orden del conjunto de instrucciones del cuerpo del
bucle. Si tenemos dos bucles de n ciclos, uno dentro de otro, se
considera tiempo cuadrático (suponiendo que el cuerpo del bucle tuviera
un tiempo contante).
Cuando se hacen llamadas a procedimientos no recursivos, se suman todos los
tiempos de ejecuci ón según las pautas anteriores, pero en procesos recursivos
se trabaja de forma distinta. Supongamos la siguiente función:
Para n > 2, tenemos que T(n) = c +T(n –1). El término T(n –1) se sustituye
por n –1:
T(n–1) = c+T(n–2), sustituyendo tenemos que T(n) = c+c+T(n–2). Siguiendo
este
proceso hasta el término i entonces T(n) = ic+T(n–i). Cuando i = n–1, T(n) =
nc+T(1) =
ncfi= O(n).
En el siguiente ejemplo tenemos a un algoritmo recursivo. Para el caso

general, n >1, el proceso divide el problema en dos mitades de
aproximadamente el mismo tamaño. Cuando éste proceso de división termina
necesita un tiempo lineal para unir los resultados de las dos mitades. Este
método es muy habitual en los problemas resueltos con el método Divide y
Vencerás.

1.3. Operaciones básicas en Geometría Computacional
En este apartado entraremos en contacto con métodos para la resolución de

algunos de los problemas más elementales en Geometría. Nos servirá
igualmente para recordar conceptos a nivel computacional. Los algoritmos
aparecerán mayormente escritos en lenguaje Pascal, a no ser que alguno de
ellos aparezca, no por razones prácticas sino didácticas.
1.3.1. Introducción
A nivel de tratamiento de la información, en Geometría Computacional es clara

la preferencia por los tipos de datos enteros, lo que se denomina aritmética
entera. La razón es obvia, el ordenador debe transformar todo dato de la recta
real en un tipo de dato de una computadora que tiene un espacio finito de
almacenamiento. Los datos enteros sí garantizan su transformación íntegra a
un tipo de dato almacenado en memoria, siempre que éste sea menor que una
valor dado. Sin embargo, los datos reales o en coma flotante pierden casi
siempre cierta precisión al ser guardados. Cuando una variable de tipo real
nace en la ejecución de un programa y a su vez es utilizada como entrada para
crear otras nuevas, este proceso repetido puede hacer que el dato se aleje del
valor correcto. Por esta razón, y siempre que sea posible, es preferible hacer
uso de la aritmética entera. Por ejemplo, para saber si dos segmentos
intersecan basta utilizar aritmética entera, sin embargo si queremos saber
exactamente el lugar de intersección, sí era necesario
realizar algún cálculo en coma flotante.
1.3.2. Algunos tipos de datos simples
Los datos geométricos, a la hora de ser procesados por un ordenador, son

reemplazados por lo que denominamos tipos de datos. Muchos conceptos
típicamente matemáticos se denominan de forma análoga cuando se
representan internamente, así usamos el concepto de variable o de constante.
Los tipos de datos identifican el tipo de cada una de estas posibles variables o
constantes. Los tipos de datos que cualquier lenguaje de programación soporta
cubren el espectro más habitual, sin embargo, los de tipo geométrico deben
ser definidos explícitamente por el programador.
En este curso utilizaremos varios de estos tipos de datos. Por ejemplo, el tipo
de dato TipoPunto, TipoPoligono, etc. En las clases de prácticas se definirán
muchos de ellos, ahora identificaremos los anteriores en Pascal para poder
trabajar con ellos a lo largo de este tema:

/************REPRESENTACION DE UN PUNTO*********************/
# define x 0;
# define y 0;
typedef enum{ FALSE, TRUE}bool;
# define DIM 2 /*Dimensión del punto*/
typedef int tpointi(DIM); /*Declaración de un arreglo de puntos*/
/*********REPRESENTACION DE UN PUNTO***********************/
# define PMAX 100

Typedef tpointi tpolygoni[PMAX]
Por simplicidad computacional, se emplea un array con dos posiciones para un

punto, identifi cando la posición 0 para guardar el valor de la x y la posición 1
para el de la y. Cuando se dice que un polígono es un array de puntos,
realmente tenemos una matriz bidimensional con un total de dos columnas,
igualmente fácil de manejar computacionalmente.
Las técnicas de tricoloreado dos tecnicas utilizadas para la representación de

los guardas y otras entidades diferentes de las triangulaciones y vasadas en las
diagonales si desean información de estas acudan al libro geometry
computacional in C.
1.3.3. Cálculo del área
Una de las operaciones más elementales en Geometría es el cálculo del área de

un triángulo, sea del tipo que sea. El método para realizar este cálculo no es
otro que la resolución de un determinante 3x3, aunque no es objetivo de esta
asignatura el cálculo matemático correspondiente.
El algoritmo escrito en pseudocódigo aparece a continuación. Por razones

argumentadas anteriormente, se opta por trabajar siempre con aritmética
entera. La función AreaTriangulo2 evitará la división por dos y calculará el
doble del área del triángulo, por lo hay que tener en cuenta que para obtener
el valor real del área será necesario hacer la división correspondiente.
Ahora vemos el código:
Int Area2(tPointi a, tPointi c, tPointi c)

{
return : = ( ( a [ 0 ] *b[1])–(a [ 1 ] * b [ 0 ]) +
( b [ 0 ] * c [1])–(b [ 1 ] * c [ 0 ]) +
( c [ 0 ] * a[1])–(c [ 1 ] * b [ 0 ]) ) ;
}
El resultado de este cálculo será positivo siempre que los vértices abc sean
recorridos en orden inverso a las agujas del reloj. En caso contrario el valor
será igualmente válido y medirá el área, pero tendrá el signo negativo.

El cálculo del área de un polígono convexo es bien sencillo, basta con calcular
el área de todos los triángulos que se pueden formar lanzando diagonales
desde cualquier vértice, hasta el resto de los vértices del polígono convexo.
Si el polígono no es convexo, el área puede calcularse sumando las áreas de

los triángulos resultantes o incluso restando los de aquellos que no tengan
superficie, como en el siguiente ejemplo:
El área del polígono puede calcularse de dos modos:
 Area (abd) + area (bcd)

 Area(abc) – area(adc)
Este mismo principio puede extenderse a cualquier polígono, indistintamente

del tipo y número de vértices que tuviera. Veamos el siguiente ejemplo: se ha
elegido un punto cualquiera p, interior o exterior al polígono y se han trazado
diagonales a todos sus vértices. Los vértices de éste han sido enumerados del
o al n–1 en orden inverso a las agujas del reloj. Este dato es muy importante,
porque va a ser siempre el mecanismo utilizado para numerar los vértices
cuando trabajemos con polígonos. El número de triángulos obtenidos será de
n–1, siempre partiendo del punto p y siguiendo con dos vértices sucesivos del
modo siguiente:

El triángulo p01 se traza en sentido inverso a las agujas del reloj, lo que
implicará siempre que el área de dicho triángulo es positiva. Se ha señalado
utilizando un símbolo + cuando el cálculo se realiza en el sentido antihorario y
con – cuando el área es negativa. Cuando el recorrido de los vértices del
triángulo siempre en la forma pvivi+1, sea en sentido horario, por ejemplo el
triángulo p67, el área correspondiente se resta. El resultado final, como
podemos observar en la figura, es que todas las áreas de los triángulos no
contenidas en el interior del polígonos son sumadas y restadas una vez con
resultado igual a cero, es decir, el resultado finalmente es el deseado.
Por tanto, podemos hacer uso de la función AreaTriangulo2 tantas veces como
triángulos se vayan formando con el proceso anterior, sumando unas veces las
áreas y otras restándose automáticamente según sea la salida de dicha
función. Como de cada triángulo se calcula el doble de su área, finalmente será
necesario dividir por dos el resultado final.
Como el punto P puede ser cualquier punto, sea interior o no al polígono,

podemos optar por tomar al punto del polígono s[0], o lo que es lo mismo
computacionalmente, a s[0]. El resultado lo podemos escribir a continuación:
Veamos el código:
int AreaPolygoni(tpointi s, int n)

{
float suma;
int i;
suma=0;
for(i=1;i<n-1;i++)
suma=suma+Area2(s[0],s[i],s[i+1]);
return suma;
}
1.3.4. Intersección de segmentos
Una de las operaciones elementales en Geometría Computacional es la

intersección de segmentos, cálculo válido para otros muchos problemas. Sin

embargo, y siguiendo con la dinámica de trabajar siempre que sea posible con
aritmética de enteros, el algoritmo de intersección de segmentos va utilizar
otra serie de subrutinas necesarias.
Si recordamos una de las propiedades de la función del cálculo del área del
triángulo, el resultado es positivo si la lectura ordenada de los vértices nos da
un recorrido antihorario. Esta propiedad puede ser útil para determinar si un
punto c está a la izquierda del segmento ab. Observemos la siguiente figura:
El triángulo imaginario abc se dibuja en orden inverso a la agujas del reloj, lo

que automáticamente nos está indicando que el punto c está a la izquierda de
ab. Es necesario observar que no es lo mismo el segmento ab que el segmento
ba computacionalmente hablando. El área del triángulo bac es negativa porque
el punto c está a la derecha del segmento ba. El subprograma correspondiente
únicamente necesita realizar una llamada a la función AreaTriangulo2
anteriormente vista. Aprovechamos un cálculo en principio de distinta índole,
para determinar la posición de un punto con respecto a un segmento.
Veamos el codigo:
bool Left(tpointi a, tpointi b, tpointi c)

{
Return Area2(a,b,c)fi0; /*Si areamayor que cero retorna TRUE */
}
No es difícil entender que este mismo principio sirve para determinar si el

punto c está justamente a la derecha (la función anterior nos devuelve un
valor f alse). o si el área del triángulo abc es igual a cero, lo que indica que los
tres puntos son colineales:

Veamos el codigo en C:
bool Collineal(tpointi a, tpoint b, tpoint c)

{
return Area2(a,b,c)==0;
}
Debemos insistir en que el código anterior da por supuesto que todos los
cálculos se realizan únicamente utilizando aritmética de enteros. No quiere
decir ésto que no pueda migrarse dicho código a operaciones en coma fiotante,
pero en ese caso jamás debería realizarse una operación como esta i f a = 0
::::, puesto que no siempre el valor que nosotros consideramos como cero (o
cualquier otro valor concreto) lo entienda así un tipo de dato en coma fiotante.
Para solventar este problema es más conveniente establecer un margen de
error permitido, y operar así: i f abs(a) < 0;001 :::, o lo que es lo mismo, si el
valor absoluto de la variable real a es menor que un valor próximo a cero.
Para saber si dos segmentos ab y cd intersectan, deberíamos saber si:
1. no son colineales
2. si d está a la izquierda de ab y c está a la derecha (o al revés) y además
3. si a está a la derecha de cd y b lo está a la izquierda (o al revés)
Nos podemos dar cuenta en la figura de que si no se cumple algunas de estas

premisas no tenemos garantía de que ambos segmentos intersecten.
El código debe tener en cuenta todos los casos citados anteriormente. La

operación válida para implementar el .al revés., es la operación XOR(a;b) cuya
tabla de verdad da el valor verdadero cuando a y b son distintos.

bool Intersect(tpointi a, tpoint b, tpointi c, tpointi d)

{
If (IntersectProp(a,b,c,d))
Return TRUE; /*Hay intersección propia*/
else
If(Between (a,b,c) || Between (a,b,d) || Between (c,d,a) || Between (c,d,b)
Return TRUE; /*Hay interseccion impropia*/
else
return FALSE; /*No hay interseccion*/
}
El inconveniente del método es la redundancia. Ahora realizaremos una nueva

versión del algoritmo utilizando la primitiva Entre, que será capaz de saber si
un punto c está o no en el segmento ab. Para ellos veremos si la coordenada x
de c cae en el intervalo determinado por la coordenada x de a y b. Lo mismo
debe hacerse para la ordenada.
Veamos el codigo en C:
boll Between (tpoint a, tpointi b, tpoint c)

{
If(!Collineal(a,b,c))
Return FALSE;
If(a[x]!=b[x])
return ( (a[x]<=c[x]) && (c[x]<=b[x]) || (a[x]>=c[x] ) &&
(c[x]>=b[x]) );
else
return ( (a[y]<=c[y]) && (c[y]<=b[y]) || (a[y]>=c[y] ) &&
(c[y]>=b[y]) );
}
Esta versión del algoritmo además cuenta con al ventaja de poder trabajar con
las intersecciones de forma propia o impropia. Una intersección impropia
ocurre cuando un extremo de uno de los segmentos está justo en en alguna
posición del otro. La siguiente función en Pascal detecta primero si existe la
posibilidad de colinealidad con la función Entre. Posteriormente hace el mismo
proceso que IntersectaSegmento.
Veamos el código:
bool IntersecImprop(tpoint a, tpoint b, tpointi c, tpointi d)

{
If( Between (a,b,c) || Between (a,b,d) || Between (c,d,a) || Between (c,d,b) )
return TRUE;
else
return(Left(a,b,c) || Left(a,b,d) && Left(c,d,a) || Left(c,d,b) )
}

Ahora veremos la function propia en C:
bool IntersecProp (tpoint a tpoint b, tpointi c, tpointi d)

{
If( Collineal(a,b,c) || Collineal (a,b,d) || Collineal (c,d,a) || Collineal (c,d,b) )
return FALSE;
return (Xor(Left (a,b,c), Left (a,b,d)) && Xor (Left(c,d,a),Left (c,d,b)));
}
bool Xor (bool x, bool y)

{
return !x^!y;
}
1.3.5. Cálculo de diagonales
El cálculo de una diagonal tiene como objetivo la triangulación de polígonos.

Una diagonal es aquel segmento que une dos vértices del polígono de forma
que no intersecte con ningún otro eje de dicho polígono y además sea interno
al polígono. Para saber si existe o no intersección puede utilizarse el proceso
anterior, pero para saber si es o no interno necesitamos realizar un
procesamiento adicional. Este cálculo puede realizarse en
tiempo constante porque si una diagonal es interior a un polígono P en su
vecindario (vértices próximos), también lo es para todo el polígono, no siendo
necesario un procesamiento completo del polígono P.
Diremos que un segmento s es interno a P si y sólo si es interno al cono cuyo

vértice es vi y cuyos lados pasan a través de vi–1 y vi+1. Existen dos casos, el
caso convexo en el que el resto del polígono está en la parte de menor ángulo
y el caso cóncavo en cuyo caso el ángulo es mayor que . La siguiente función
determina si el vector que une los vértices i y j del polígono P es interior o no
al polígono.
Veamos el codigo:
Esta función verifica si un vertice es convexo
boll InCone(int i, int n, tpoligoni P)

{
int i1,inl;
i1=(i+1)%n;
inl=(i+n-1)%n;
if(LeftOn(P[inl],P[i],P[i1])) /**/
return (Left(P[i],P[j],P[inl]) && Left (P[j],P[i],P[i1]));
else
return (!(LeftOn[P[i],P[i1]P[i1]) && LeftOn(P[j],P[i+,P[inl]));
}

bool LeftOn (tpointi a, tpoint b,tpoint c)

{
return Area2(a,b,c)fi0;
}
Vemos en la figura siguiente los dos casos comentados anteriormente. El caso

convexo ocurre cuando el vértice vi+1 está a la izquierda del eje trazado por
vi–1vi. En este caso, lo vemos en la figura de la izquierda, para que se trate de
un eje interno debe ocurrir que vi–1 esté a la izquierda de viv j y que vi+1 lo
esté a la izquierda. El caso cóncavo aparece a la derecha.
Por tanto, una diagonal es aquel segmento interior que está dentro del
polígono. Pero el segmento i j es una diagonal si no intersecta con ninguna
otro de las aristas del polígono. Este cálculo necesita forzosamente un tiempo
de ejecución lineal. La función DiagonalfiIE se encargará de realizar este
chequeo, y que será invocado por la función Diagonal cuyo código resulta
bastante evidente: el segmento i j es una diagonal del polígono P de tamaño n
si es interior y además no intersecta con ninguna arista.
Veamos el código:
Es/*ta function verifica la possible diagonal entre dos vertices.*/
bool Diagonal (int i, int j,int n,tpolygoni P)

{
return(InCode(i,j,n,P) && Diagonaie(i,j,n,P)());
}
/*Esta function verifica si una diagonal se intersecta con una arista del
poligono */
bool Diagonalie (int i, int j, int n, tpoligono p)

{
Int k,k1;
for(k=0; k<n; k++)
{
K1=(k+1)%n;
if( !( ( k==i) || ( K1==i ) || ( k==j) || ( k1==j ) ) )

if ( Intersect (p[i], p[j], p[k], p[k1]))

return FALSE;
}
return TRUE;
}
/*Esta function remueve el triangulo formado por la diagonal y la arista

asociada ala diagonal, para lo cual reasigna las etiquetas del polígono.*/
void ClipEar1 (int i, int n, tpoligoni p, int labels [ ])

{
Int k;
for(k=I; k<n-1 ; k++)
{
point assign (p[k+1]);
labels[k] = labels [k+1];
}
}
/*Esta funccion obtiene los vértices de la possible diagonal */
void TriRecurse(int n, tpoligoni P, int labels [])

{
int i,i1,i2;
if(n>3)
for(i=0; i<n;i++)
{
i1=(i+1)%n;
i2=(i+2)%n;
if (Diagonal(i,i2,n,p))
{
printf("%d %d lºn",labels[i2]);
ClipEar1(i1,n,p,labels);
TriRecurse(n-1,P,labels);
break;
} /*Cierre del if*/
} /*Cierre del for*/
} /**Cierre de la funcion/
1.3.6. Un ejemplo completo: triangulación de un polígono
La triangulación de polígonos es un cálculo muy importante en muchas

aplicaciones de Geometr ía Computacional. Permite, aparte de otras muchas
aplicaciones, dividir un polígono con posible cierta complejidad, en un conjunto
de triángulos fáciles de procesar.
Veremos que el siguiente método puede ser perfectamente válido para lograr
la triangulación de cualquier polígono P de tamaño n. Sin embargo, y a pesar

de su simpleza, su utilización no es aconsejable y por ello no se ha

implementado en un leguaje de programación. Vemos que es un método
recursivo porque se llama a sí mismo. La llamada recursiva se realiza cuando
se localiza una diagonal, y como en ese momento el número de vértices a
procesar es uno menos, puesto que el vértice i1 queda aislado al encontrarse
la diagonal ii2. La función EliminaVertice se encargaría de este operación,
dejando cada vez que se llama un polígono más pequeño.
Esta función triangula el poligono P de n vertices.
void Trinagulate1 (int n, tpoligoni)

{
tpoligoni.pt;
int labels[PMax];
clrscr();
for(i=0;i<n;i++)
{
PointAssign(pt[i]<P[i]);
labels[i];
}
printf("Diagonales de la triangulacion;\n");
TriRecurse(n,pt,Labels);
}
/*Esta función asigna al punto "a" el valor del punto "b".*/
void PointAssign(tpoint a, tpoint b)

{
int i;
for(i=0;i<DIM;i++)
a[i]=b[i];
}
La razón por la que este algoritmo no es desde luego nada interesente es por
su tiempo de ejecución. El algoritmo trabaja en O(n3) porque realiza un total
n–3 llamadas recursivas y cada una de ellas, en el peor de los casos, necesita
un tiempo cuadrático (la función diagonal es lineal, así como la ejecución
completa del bucle).
Como veremos a lo largo de este curso, para valores de n elevados, este

algoritmo resulta
Evidentemente lento, y en Geometría Computacional todos los problemas
cuyas soluciones inmediatas sean susceptibles de mejora, son estudiados.
Como veremos en sucesivos capítulos, cualquier polígono puede ser
triangulado en tiempo O(nlog n).
Los algoritmos geométricos, al igual que los desarrollados para otras

disciplinas, deberán combinar adecuadamente junto con su conjunto de

sentencias, a las estructuras de datos correctas para conseguir el objetivo

final, obtener programas eficientes.
1.4.1. Introducción a las estructuras de datos
El estudio de las estructuras de datos y los métodos para la organización de

dichos datos es uno de los aspectos clásicos más importantes para construir
algoritmos eficientes. Los programas trabajan con información que permanece
en memoria principal o en algún dispositivo de memoria secundaria. La
organización que se le da a dichos datos es lo que denominamos estructuras
de datos.
La mayoría de las estructuras de datos pueden verse como contenedores que

mantienen información de un determinado tipo con un cierto orden. El acceso y
manejo de los datos en un contenedor se realiza a través de un localizador.
Dependiendo de la estructura del contenedor, el localizador proporcionará un
modo de acceso a los datos, por ejemplo, un índice de un array o un puntero.
Una estructura de datos además de proporcionar un modo de acceso, también
deber llevar asociado un conjunto de operadores, como insertar un nuevo
dato, actualizar uno ya existente o eliminar algún otro. Las características de
una estructura de datos va en relación al orden de ejecución de sus
operaciones y a los requerimientos de espacio. En cualquier caso, la estructura
de datos más idónea dependerá siempre del problema que se pretenda
resolver.
Un tipo de dato es una colección de objetos a la que se le da una

representación matemática. Un tipo de dato abstracto o TDA es un tipo de
dato, más un conjunto de operaciones que lo manejan. Las estructuras de
datos pueden considerarse como implementaciones concretas de tipos de
datos abstractos. Los TDAs (notación anglosajona) han evolucionado hasta
convertirse en clases de objetos. Lo que inicialmente se concibió como un
concepto matemático que se adaptó a la sintaxis de los lenguajes de
programación tradicionales, se ha ido convirtiendo en una nueva filosofía de
programación con los nuevos lenguajes orientados a objetos.
Existen multitudes de estructuras de datos ampliamente documentadas en la

bibliografía. En este apartado repasaremos algunas de las estructuras de datos
usadas en el curso.
Dependiendo de la organización interna y del modo de acceso a los datos,

existen dos tipos fundamentales de contenedores, los contenedores
secuenciales o secuencias y los asociativos. Una secuencia es un contenedor
que almacena los elementos con un orden lineal determinado, realizando el
acceso a la información indicando la posición donde se localiza el dato. Por el
contrario un contenedor asociativo, independientemente de su organización
interna, permite el acceso por clave.
Contenedores secuenciales

Las secuencias más usuales son las listas enlazadas y los arrays. Las primeras
forman una sucesión de nodos o elementos informativos unidos unos a otros
mediante punteros. El tiempo de acceso es lineal, aunque normalmente el
acceso a los puntos extremos es constante. Los arrays son contenedores
implícitos con acceso directo. Esta ventaja de acceso en tiempo constante se
ve mermada por poseer menor fiexibilidad. Por ejemplo, la operación de
inserción de un elemento en posiciones intermedias es de orden lineal. Sobre
cualquiera de los contenedores secuenciales anteriormente citados puede
construirse estructuras de datos muy conocidas y empleadas, las pilas (LIFO) o
las colas (fiFO). Cualquiera de ellas implementada sobre una lista puede
considerarse como una estructura de datos dinámica. Esta consideración
también puede realizarse sobre arrays dinámicos.
Contenedores asociativos
Los contenedores asociativos poseen una filosofía de manejo y una estructura

interna totalmente diferente a las secuencias. La diferencia fundamental es que
el acceso a la información se realiza siempre utilizando una clave y no una
posición, que puede identificar o no de forma unívoca al dato. Las operaciones
fundamentales son de inserción, actualización, borrado y búsqueda por dicha
clave.
La organización interna de los datos depende del tipo de contenedor asocitivo,

por árbol o por tabla hash. Los primeros mantienen un árbol binario de
búsqueda o Inorden, manteniendo una relación de orden entre nodos padre e
hijos. Normalmente, todo nodo padre es mayor que su hijo izquierdo pero
menor o igual que su hijo derecho. El tiempo de acceso en este tipo de
estructuras permite eliminar en cada consulta la mitad del grueso de la
información, siempre que todas las ramas del árbol permanezcan a la misma
altura. Estas estructuras de datos garantizan búsquedas en O(logn).
Las estructuras de datos consideradas de carácter general son ampliamente

utilizadas en Geometría Computacional, pero existen otros aspectos como son
la naturaleza espacial de los objetos geométricos o sus propiedades
estructurales que requieren del manejo de estructuras de datos más
específicas para construir algoritmos eficientes.
La elección de un tipo de estructura de datos o de otro va a depender del tipo
de objetivo que se persiga: captura de información estructural, acceso a los
datos o actualización eficiente de éstos, optimización del espacio requerido o
del número de operaciones de E/S. En otras ocasiones, las estructuras de
datos se eligen según la asociación de objetos geométricos que representen.
1.4. Algunos métodos de programación utilizados en C.
La Geometría Computacional, en contraste con la disciplina clásica basada en

proporcionar teoremas matemáticos, enfatiza los aspectos computacionales de

los problemas y atiende a las propiedades geométricas para encontrar

algoritmos eficientes.
Que un problema geométrico tenga solución dentro de la Geometría

Computacional no basta en muchas ocasiones, se desea además que la
solución se encuentre en un tiempo óptimo. Existen una serie de técnicas y
paradigmas de programación que vienen siendo muy habituales no sólo en el
campo de la Geometría Computacional. Algunos de estos métodos como el
divide y vencerás ya habían proporcionado la solución óptima a problemas
como la ordenación, en otras ocasiones los métodos de resolución están
íntimamente relacionados con las capacidades de la propia Geometría.
A continuación daremos un repaso a los paradigmas de programación más
empleados dentro de la Geometría Computacional.
1.5.1. Método incremental
Éste puede ser considerado como uno de los métodos más simples e intuitivos,
también conocido como el método iterativo. La idea sobre la que trabaja este
método consiste en construir la solución de modo iterativo, considerando que
la entrada se produce de modo incremental. Para cada una de las nuevas
entradas, el problema se resuelve convenientemente.
Supongamos que se pretende procesar una nube de n puntos en el plano S,

para resolver cualquier problema Prob(S) bajo esta técnica. En muchas
ocasiones S deberá estar ordenada bajo algún criterio con coste O(nlogn). El
algoritmo trabaja siempre de forma similar. Inicialmente Prob se resuelve de
forma trivial para fs0; s1; :::; sk–1g, los primeros k puntos de S.
Posteriormente y uno a uno, se resolverá Prob(Si) para el resto de si 2 S; i =
fk; :::;n–1g tal y como indica el Algoritmo 1, obtiendo finalmente Prob(S).
Si en un problema de tamaño n, el coste de insertar un nuevo dato es O(n),

entonces el tiempo global del algoritmo será de O(n2). Pero si añadir un nuevo
elemento a la solución parcial del problema tiene coste constante o
logarítmico, el algoritmo final se procesará en O(nlogn), la misma cota
impuesta por el algoritmo de ordenación.
Algoritmo 1 Incremental-generalizado.
Incremental(RC,p)
1. Si p está dentro de RC
2. entonces devolver RC
3. sino
4. (Pt1,Pt2) := puntosTangentes(RC,p)
5. Eliminar aristas en RC de Pt1 a Pt2
6. Conectar Pt1 con p y p con Pt2

Ahora veremos los puntos tangentes:
1.5.1.1. Línea de barrido
Esta estrategia es una particularización del método incremental,

considerándose válida para problemas en dos dimensiones cuando el conjunto
de entrada se produce en un cierto orden. La solución de la mayoría de estos
problemas puede ser incremental, de hecho, la implementación de este
paradigma sigue las mismas premisas que las dadas para el método
incremental citado anteriormente.
El método supone que una línea horizontal (o vertical) recorre el plano de

arriba hacia abajo (o en sentido contrario). Cada vez que dicha línea encuentra
un ítem (un punto, una línea, etc) lo procesa modificando el conjunto de
estructuras que datos que participen en la construcción de dicho algoritmo. La
validez de esta técnica está basada en la observación de que la parte que
queda por encima o por debajo de la línea de barrido se ha construido
correctamente.
Por ejemplo en el problema de intersección de segmentos, cuando la línea

encuentra un nuevo segmento, se realizará una inserción en alguna estructura
de datos capaz de mantenerlos ordenados de izquierda a derecha (en el caso
de que la línea de barrido sea horizontal). Normalmente se escogen
estructuras de datos con tiempos de actualización y de acceso logarítmico. Si
el procesamiento de dichos objetos geométricos es constante, como es el caso
de la intersección de dos segmentos, pueden trabarse con tiempos del orden
de O(nlog n).

Esta técnica es empleada para diferentes problemas como la intersección de

segmentos, partición de polígonos en subdivisiones monótonas, intersección de
semiplanos, el diagrama de Voronoi y triangulación de Delaunay, los métodos
de Jarvis y Graham para el cálculo de la envolvente convexa, la técnica de
localización de los puntos más lejanos, y otros más. Existen técnicas análogas
para dimensiones mayores.
Algoritmo 1
El algoritmo de la línea de barrido rotatoria (Rotational Sweep Line):
Entrada: Un conjunto de obstáculos poligonales S y un conjunto de puntos Q.

Salida: Un grafo de visibilidad G = (V, E).
Sea W la unión de los vértices de S y los puntos de Q, sea E el conjunto de

aristas, y sea T un árbol de búsqueda equilibrado.
1.- Para cada vértice w de V:

2.- Ordenar todos los vértices de W en sentido horario según la semi-línea P,
y, en caso de empate, ordenar según distancia al punto p.
3.- Ordenar las aristas que intersectan con P e insertarlas en el árbol
equilibrado T.
4.- Para cada vértice w de la lista ordenada W:
5.- Si w es visible desde p, entonces añadir la arista e=(p, w) al grafo G.
6.- Insertar en el árbol los obstáculos que incidan en w y que estén en el
lado horario de P.
7.- Eliminar del árbol los obstáculos que incidan en w y que estén en el lado
antihorario de P.
1.5.2. Divide y Vencerás

Esta técnica clásica de programación es válida para resolver de forma eficiente

problemas Geom. étricos. Normalmente se basa en la sucesiva división en
partes iguales del problema original, hasta conseguir que éste posea un
tamaño lo suficientemente pequeño como para poder resolverse fácilmente.
Llegado a un punto en que la división deja de tener sentido, los problemas se
van resolviendo recursivamente y combinando sus soluciones para obtener la
solución final. El método más eficiente de ordenación, el quicksort, está basado
en este paradigma.
El Algoritmo 2 resume los pasos empleados para resolver el problema Prob(S)

partiendo del conjunto de datos S y realizando sucesivas divisiones por dos.
Para que el algoritmo se considere eficiente se espera que el Paso 3.a) que
divide el problema en subproblemas y el Paso 3.c) que combina las soluciones
parciales, se realice en tiempo lineal. El segundo ejemplo de ecuación de
recurrencia de la Sección 1.2 corresponde al método Divide y Vencerás.
Algoritmo 2
Paradigma de divide y vencerás


Es un ejemplote Voronoi.
Esta técnica es ampliamente

utilizada y sirve de base para
construir algoritmos aleatorios.
Puede emplearse para construir la
envolvente convexa, el diagrama de
Voronoi, etc.
2 La envolvente convexa y triangulación de polígonos
2.1. La envolvente convexa
2.1.1. Introducción

El cálculo de la envolvente convexa de un conjunto de puntos en espacios

euclídeos ha sido sin duda uno de los problemas a la vez más básicos y más
ampliamente estudiados a lo largo de la historia de la Geometría
Computacional. Además, los campos en los que ha resultado un cálculo útil
sorprenden por lo aparentemente poco relacionados con las matemáticas en
general y la geometría en particular.
Un conjunto convexo del plano se define como el conjunto que verifica que el
segmento que une a dos cualesquiera de sus puntos está totalmente contenido
en él. Evidentemente, esta definición puede ser aplicada en cualquier espacio
euclídeo n-dimensional. La idea de conjunto convexo nos lleva inmediatamente
a la de envolvente convexa, considerando a ésta como el menor conjunto
convexo que contiene a dicho conjunto. Este concepto es fácil de entender en
cierto modo si consideramos a la envolvente convexa de un conjunto de puntos
en el plano, como la forma que adquiriría una goma elástica envolviendo a
todos los puntos del conjunto que están fijos sobre el plano. De nuevo esta
idea es extensible intuitivamente a otras dimensiones, y puede servir de
partida para construir algoritmos simples para el cálculo de la envolvente
convexa.
Pero exiten otras definiciones válidas: la envolvente convexa de un conjunto

de puntos en el plano es la unión de todos los triángulos determinados por
dicho conjunto de puntos.
El estudio de la envolvente convexa en dos dimensiones ha sido objeto de

especial interés. Existen una serie de características asociadas a los puntos que
forman parte de la envolvente convexa en el plano y que han servido
igualmente para definirla y construirla. Un punto q 2 S pertenece a la
envolvente convexa de S, q 2CH(S), si es posible trazar una recta pasando por
dicho punto de forma que todo el conjunto S0, S0 = S–fqg quede a un lado de
dicha recta.
Como se ha indicado con anterioridad, el cálculo de la envolvente convexa ha

sido aplicado ampliamente a disciplinas en ocasiones ajenas a la Geometría
Computacional y en espacios distintos de dos dimensiones. Tal es el caso del
reconocimiento de patrones, procesamiento de imágenes, etc.

Los algoritmos propuestos para este problema son realmente numerosos. Sin
duda es uno de los planteamientos de la Geometría Computacional que más
soluciones ha conseguido. Desde incluso antes del nacimiento oficial de esta
disciplina se conoce el trabajo de Graham en el año 1972. Se han propuesto
estrategias siguiendo los paradigmas más empleados como el método
incremental y el divide y vencerás. Todos estos algoritmos construyen la
envolvente convexa en tiempo (nlog n). El método propuesto por Preparata y
Shamos en 1985 fue denominado Quickhull por su similitud con el método de
ordenación Quicksort. Otra propuesta diferente se dió a conocer en 1973 como
.La marcha de Jarvis.. Este método, que estudiaremos en este curso, posee un
tiempo de ejecución cuadrático, sin embargo supone un interesante ejemplo
basado en manejo de ángulos del cual partiremos para el tratamiento del
diagrama polar. Todos estos trabajos constituyen el conjunto clásico de
algoritmos para la resolución de la envolvente convexa, al que habría que
añadir otras técnicas posteriores.
La envolvente convexa posee una cota de (nlog n), es decir, no se puede

encontrar una algoritmo que trabaje en menor tiempo para todos los casos.
2.1.2. Un ejemplo de resolución
El problema de encontrar la envolvente convexa de un conjunto de puntos

puede ser interesante porque es equivalente a encontrar todo el conjunto de
puntos extremos de dicha nube. Por tanto, puede definirse como punto
extremo a cualquier punto de la envolvente convexa, y todo punto extremo
tiene la propiedad de que es posible trazar una línea recta a través de él de
modo que el resto de puntos queden a un lado.
También podemos decir que un punto es extremo si y sólo si está dentro de

algún posible triángulo cuyos vértices son cualesquiera de los puntos de la
nube original. Pero bajo esta definición, necesitaríamos procesar O(n3)
triángulos para cada uno de los n puntos, lo que nos proporciona un método en
triempo O(n4), lo cual no es eficiente teniendo en cuenta que se trata de un
problema (nlog n).
Pero la envolvente convexa posee aplicaciones fuera del ámbito de la

Geometría. Supongamos que una explotación petrolífera extrae diferentes tipos
de componentes mezclados en distinta propoción. Si el objetivo es conseguir
los componentes A y B pero en una nueva proporción, podemos hacer uso de
la envolvente convexa del modo siguiente. Supongamos que partimos de las
mezclas:
e1 = A10%B35%, e2 = A16%B20% y e3 = A7%B15% y queremos obtener e

f = A13%B22%. Para saber si es posible obtener este producto final e f basta
con considerar las anteriores mezclas como puntos del plano, obteniendo el
siguiente esquema:

Todo punto que caiga dentro de la envolvente convexa de todas las muestras
representadas por puntos en el plano, indica que puede ser producida. Si por
contra, cayera fuera de dicha envolvente, la combinación final no podría
producirse. Este problema sería un problema 3D si cada mezcla tuviera tres
componentes, la solución sería la contrucción de la envolvente convexa
tridimensional.
2.1.3 Algoritmo trivial 1.

 Determinación de puntos extremos
1. Para cada i hacer

2. Para cada j  i hacer
3. Para cada k  i  j hacer
4. Para cada h  i  k  j hacer
5. Si Ph está a la izqda de (Pi,Pj) y
6. Ph está a la izqda de (Pj,Pk) y
7. Ph está a la izqda de (Pk,Pi)
8. entonces Ph no es extremo
 Complejidad: O(n4 )
2.1.4 Algoritmo trivial 2.
 Determinación de aristas extremas


1. Para cada i hacer
3. Para cada k  i  j hacer
4. Si Pk no está a la izqda de (Pi,Pj)
5. entonces (Pi,Pj) no es extremo
 Complejidad: O(n3 )
2.1.5 Gift Wrapping
1. Encontrar punto p más pequeño en coord. y, sea i[0] su índice

2. i := i[0]
3. Repetir

5. Calcular el ángulo en sentido antihorario entre

Pj y la arista anterior de la EC
6. Sea k el índice del punto con ángulo menor
7. Marcar (Pi,Pk) como una arista de la EC
8. i := k
9. Hasta que i = i0
2.1.6 Quick Hull
QuickHull(a,b,S)
1. Si S={a,b} entonces devolver (a,b)
2. sino
3. c := índice del punto con máxima distancia a (a,b)
4. A := puntos a la izquierda de (a,c)
5. B := puntos a la izquierda de (c,b)
6. devolver
concatenar(QuickHull(a,c,A),QuickHull(c,b,B)
ConvexHull(S)
1. a := punto más a la derecha de S;
2. b := punto más a la izquierda de S
3. devolver concatenar(QuickHull(a,b,izquierda(a,b,S)),
QuickHull(b,a,izquierda(b,a,S)))
La idea básica del quickhull (envolvente rápida) es que para la mayoría de las
configuraciones de puntos se puede en cada paso descartar muchos puntos a
la hora de construir la envolvente convexa.
El primer paso del quickhull es encontrar los cuatro puntos extremos en las
direcciones norte, sur, este y oeste y formar el cuadrilátero que ellos definen

(este cuadrilátero puede ser degenerado), ahora todos los puntos en el interior
de dicho cuadrilátero no son extremos, con lo cual pueden ser descartados.
Así nos quedan puntos repartidos en cuatro regiones no conectadas entre si,
trataremos cada una de estas regiones independientemente. En cada una de
ellas encontramos el punto más alejado a la recta que define dicha región
obteniendo así cuatro nuevos puntos y un polígono de a lo más ocho lados que
divididirá a los puntos que no hemos eliminado en ocho regiones que tratamos
individualmente siguiendo la misma regla anterior.
En nuestro ejemplo en el paso siguiente se obtine ya la envolvente convexa.

El QuickHull suele calcular la envolvente convexa en un tiempo mucho más

corto que si lo hacemos a través del diagrma de Voronoi. Sin embargo, un
análisis del algoritmo nos lleva a que su complejidad en tiempo es cuadrática.
Por lo tanto, centrémosno ahora en encontrar un algoritmo óptimo.
Ejemplo:
2.1.4. Graham's scan
Este es sin duda uno de los algoritmos más importantes para el cálculo de la
envolvente convexa, no únicamente por su simpleza sino también por su
rapidez.
El proceso realiza primero una ordenación angular de los puntos. El punto

tomado de referencia para tal fin debe ser un punto de la envolvente convexa,
por ejemplo el de menor ordenada y al que llamaremos p0. El resto de puntos
quedan ordenados de izquierda a derecha obteniendo la secuencia p1, p2,…,
pn–1.
El proceso seguido por Graham toma sucesivamente triángulos elegidos según

el orden conseguido tras la ordenación. Siempre que el triángulo formado abc,
posea una superficie positiva, el vértice central, es decir, el vértice b será
tenido en cuenta como probable punto de la envolvente. Pero cuando dicho
área es negativa, b es descartado definitivamente.
Para comprender dicho algoritmo, será necesario repasar el concepto de pila.

Una pila es un tipo de dato abstacto (tipo de dato más operaciones para su

manejo) muy restrictivo a la hora de manejar los datos que almacena. Se

construye utilizando una estructura de datos lineal, array o lista enlazada,
sobre la que sólo se pueden introducir (push) o sacar elementos (pop) por uno
de sus extremos, lo que se denomina cima o tope de la pila.
Algoritmo Scan de Graham
1. Encontrar el punto inferior más a la derecha (P0)

2. Ordenar todos los puntos angularmente alrededor de P0;
aquellos puntos que estén en el mismo ángulo colocar primero el
más cercano a P0: etiquetarlos P1,...,Pn-1
3. Pila S := (Pn-1,P0)
4. t := tope de S (P0)
5. i := 1
6. Mientras que i<n hacer
7. Si Pi está estrictamente a la izqda de (Pt-1,Pt)
8. entonces Push(S,i); i := i+1
9. sino Pop(S)
Ejemplo:
El orden de ejecución de este algoritmo viene dado por la necesidad de

ordenar los puntos angularmente. Cualquier ordenación necesita al menos un
tiemo O(nlogn). A este tiempo se le debe añadir el del proceso ideado por
Graham. Para averiguar este tiempo basta con percatarse que en cada paso un
punto es tenido en cuenta o es descartado. En el peor de los casos, cuando la
envolvente convexa es un triángulo, necesitamos del orden de 2n–3
operaciones.
El Scan de Graham construye una lista que al final será la de los puntos
extremos ordenados. Supondremos que no existen tres puntos alineados
(aunque esta condición puede ser eliminada). Comenzamos encontrando el
primer punto con el orden lexicográfico, llamemosle p0. A continuación
ordenamos los puntos por el ángulo que forman con p0.

Suponemos que partimos de la lista ordenada así obtenida. En cada momento,

tendremos tres puntos, llamémosles Inicial, Medio y Final. Nos preguntamos si
el ángulo IMF es positivo (en el sentido contraro de las agujas del reloj o
negativo. Si es positivo, la lista la dejamos como estaba y el anterior Medio pas
a ser Inicial y el final pas a ser Medio y escogemos el siguiente en la lista para
ser el nuevo Final. Si es negativo, eliminamos Medio de la lista, el anterior
Inicial pasa a ser Medio, el Final sigue como Final y escogemos el anterior de la
lista para ser el nuevo Incial. La lista resultante después de recorrer todos los
puntos será la de los extremos de la envolvente convexa.
Teorema 5.1: El Scan de Graham calcula la envolvente convexa de n puntos

en el plano en tiempo óptimo O(n log n).
2.1.4. La marcha de Jarvis

La marcha de Jarvis está basada en el siguiente resultado, que sirve de

definición para la envolvente convexa:
El segmento l, definido por dos puntos de la nube de puntos, es un eje de la

envolvente convexa si todos los puntos de la envolvente convexa están a un
lado de ésta.
Siguiendo este criterio podríamos descubrir para cada punto los n2

combinaciones posibles, lo que nos da un fácil pero costoso O(n3) algoritmo.
Sin embargo, Jarvis pudo bajar la cota al comprobar que si pi pj es una arista
perteneciente a la envolvente convexa, la siguiente arista la encontramos
partiendo de p j en tiempo lineal. Veamos el siguiente ejemplo:
Partiendo de s6, el punto de menor ordenada, alcanzamos a s5 tras realizar un

barrido angular en sentido antihorario desde la horizontal. El siguiente punto
de la envolvente se puede localizar partiendo de s5 y haciendo un nuevo
barrido angular, localizando así a s1.
Es fácil de intuir que este proceso tardará en ejecutarse un tiempo

proporcional al número de puntos en la envolvente y al tamaño de la nube.
Cada barrido angular necesita un tiempo de proceso del orden de O(n) pasos.
Si la envolvente final posee k puntos, el tiempo final de ejecución es del orden
de O(nk). En el mejor de los casos el comportamiento puede ser lineal, por
ejemplo si la envolvente es un triángulo. El peor de los casos, sin embargo, se
da cuando todos los puntos están en la envolvente convexa, convirtiéndose en
un método cuadrático.
2.1.5. Algoritmo Incremental
La ventaja de unos métodos con respecto a otros a veces viene dada por su
velocidad computacional y otras veces por su fácil extensión a tres
dimensiones, lo que habitualmente llamamos problemas 3D. El método
incremental para el cálculo de la envolvente convexa es uno de estos casos.
En todo método incremental se supone que se ha resuelto el problema para un

tamaño n y que en cada paso se añade un nuevo punto dando solución a un
problema de tamaño n+1.
Para el cálculo de la envolvente convexa ordenamos inicialmente los puntos del

conjunto P de izquierda a derecha, por ejemplo, obteniendo el conjunto p0;
p1; :::; pn–1. Tomamos los tres primeros puntos tras esta ordenación
sabiendo que el polígono que forman p0; p1; p2, un triángulo, es convexo. El
siguiente paso intenta añadir el siguiente punto, p3, de modo que se tras
finalizar este paso tengamos la envolvente convexa de los primerso cuatro
puntos p0; p1; p2; p3.

Para añadir cada nuevo punto pi+1 basta con lanzar tangentes desde este
punto hasta el polígono convexo obtenido en el paso anterior. Localizaremos
dos tangentes, una superior y otra inferior, como vemos en la siguiente figura:
 Siempre ocurre que el punto más bajo de tangencia es tal que pi, es tal
que q está a laizquierda de pi–1 pi pero a la derecha de pi pi+1.
 El punto pj será el punto de mayor tangencia si q está a la derecha de p
j–1 pj pero a laizquierda de pj pj+1.
El procedimiento PuntosTangentes calcula los puntos resultantes de lanzar

tangentes desde el punto q al polígono P de tamaño n obteniendo como
resultado los vértices pt1 y pt2. El algoritmo determina que el vértice p[i] es
un punto tangente si recorriendo cada arista del polígono P dicho vértice
implica un cambio de resultado tras ejecutar la función IzquierdaOSobre.
Pero obtener los dos puntos tangentes no implica de ningún modo que el
proceso ha finalizado. El punto q será parte ahora del nuevo polígono convexo,
así como lo serán los puntos pt1 y pt2. Sin embargo, es posible que algunos
otros vértices del polígono convexo desaparezcan. En el ejemplo de la figura,
la secuencia de vértices i+1; :::; j–1 claramente desaparece al añadir el nuevo
punto. El resultado final sería el polígono
P = p0; p1; :::; pi_1; pi;q; pj ; pj+1; :::; pn_1.
El orden de ejecución del algoritmo es la suma de los siguientes términos:
1. la operación de ordenación con coste O(nlogn)
2. Operación que en el peor de los casos es lineal.

Por tanto, y aunque el algoritmo es susceptible de añadir mejoras, necesita en

el peor de los casos un tiempo O(n2).
2.1.6. Método Divide y Vencerás
Los métodos divide y vencerás siempre trabajan de modo similar. En este

caso, partimos de una nube de puntos ordenada de izquierda a derecha que se
divide en dos mitades A y B de aproximadamente el mismo tamaño. Para cada
una de estas mitades, continuamos el proceso de división hasta que finalmente
el tamaño de la nube de puntos es tan pequeño que puede resolverse el
problema fácilmente. Este caso concreto es cuando tenemos tres puntos.
Cuando el problema no pueda dividirse más, el siguiente paso es unir dos a
dos los polígonos convexos resultantes de la etapa anterior, en un nuevo
polígono convexo. El proceso finaliza obteniendo la envolvente convexa de
todos los puntos.
Sin embargo, la etapa de unión de dos polígonos convexos en un único

polígono convexo no es inmediata. Necesitamos calcular dos tangentes que
unan dichas envolventes, una tangente superior y otra inferior.
El mecanismo para conseguir, por ejemplo, la tangente inferior, podemos

observarlo en la siguiente figura. Se comenzaría suponiendo que el segmento
que une el punto más a la derecha de A y el punto más a la izquierda de B es
una tangente válida. Como esta suposición es falsa para este ejemplo,
decidimos bajar vértices sucesivamente hasta que por fin para el polígono A se
localiza una envolvente. En el ejemplo, A2-B5 ya es una tangente para A, sin
embargo no lo es para B. El siguiente paso es hacer exactamente lo mismo
pero bajando sucesivos vértices de B. El proceso termina cuando para los dos
polígonos se encuentra una tangente.
Para saber si ab es tangente a un polígono observemos los siguientes gráficos:

queda como ejercicio la implementación de las funciones TangenteMenor y
TangenteMayor.

El tiempo de ejecución de un algoritmo divide y vencerás depende en gran

medida del comportamiento de la función de mezcla de cada pareja de
diagramas polares. Cuando ésto se realiza en tiempo lineal, como es este caso,
sabemos que contamos con un algoritmo en tiempo O(nlog n).
2.2. Triangulación de polígonos
En el Tema 1 hicimos referencia por primera vez a la triangulación de

polígonos. En esa ocasión se hizo incapié de la necesidad de encontrar un
algoritmo eficiente para realizar este cálculo, puesto que el dado en dicho tema
posee un tiempo de ejecución poco eficiente.
En esta sección conseguiremos triangular cualquier tipo de polígono en tiempo

óptimo O(nlogn), para ello serán necesarios dos pasos diferentes: la partición
de cualquier polígono en particiones monótonas y la triangulación de cada una
de estas porciones.
2.2.1. Polígonos monótonos
Un polígono monótono con respecto a la vertical es aquel que si se recorre con

una línea horizontal bajando a lo largo del total del polígono, ocurre que sólo
encontramos como máximo dos intersecciones del polígono con dicha recta. Si
además no consideramos la existencia de aristas horizontales, entonces
hablamos de polígono extrictamente monótono.
Intuitivamente hablando, un polígono monótono será aquel que no posee

cúspides interiores, considerándo al vértice vi como cúspide si vi–1 y vi+1
están ambos arriba o abajo.
La ventaja de triangular un polígono monótono es más o menos intuitiva: al

bajar una línea horizontal imaginaria a lo largo de todo el triángulo y
encontrarse con el vértice vi, se sabe que su diagonal irá a un punto visible
desde dicho punto. La idea es ir bajando paulatinamente vértice a vértice, bien
por la izquierda, bien por la derecha, dibujando diagonales según el siguiente
algoritmo.
ALGORITMO TriangulacionMonotona
ENTRADA: El Ìpolgono S de Òtamao n
SALIDA : El conjunto de Diagonales que t r i a n g u l a n e l Ìpolgono

INICIO
Ordenar (S, n , p )
ListaCrea ( l )
l i s t aCr e a ( Diagonales )
ListaMeteFinal ( l , p [ 0 ] )
ListaMeteFinal ( l , p [ 1 ] )
PARA j <_ 2 HASTA n_1 REPETIR
SI Adyacente ( L i s t a I n i c i o ( l , p [ j ] ) AND NOT Adyacente ( L i s t a F i
nal(l),p[j])
ENTONCES
v<_ L i s t aSa c a I ni c io ( l )
MIENTRAS (NOT ListaVacia ( l ) ) REPETIR
v <_ L i s t aSa c a I ni c i o ( l )
ListaMeteFinal ( Diagonales , v , p [ j ] )
FIN_MIENTRAS
ListaMeteFinal ( l , v )
ListaMeteFinal ( l , p [ j ] )
SINO
SI Adyacente ( L i s t a F i n a l ( l ) , p [ j ] ) AND NOT Adyacente ( L i s t a I n
icio(l),p[j])
ENTONCES
v<_ListaSacaFinal ( l )
x<_F i n a l L i s t a ( l )
MIENTRAS ( Angulo ( p [ j ] , v , x ) < Pi ) REPETIR
ListaMeteFinal ( Diagonales , x , p [ j ] )
v <_ ListaFinalSaca ( l )
SI NOT ListaVacia ( l )
ENTONCES x<_L i s t a F i n a l ( l )
FIN_MIENTRAS
ListaMeteFinal ( l , v )
ListaMeteFinal ( l , p [ j ] )
SINO
v<_L i s t aSa c a I n i c io ( l )
v<_L i s t aSa c a I n i c io ( l )
MIENTRAS NOT ( ListaVacia ( l ) )
v<_L i s t aSa c a I ni c i o ( l )
ListaMeteFinal ( Diagonales , p [ j ] , v )
FIN_MIENTRAS
FIN_SI
FIN_SI
FIN_PARA
En la siguiente figura podemos observar el conjunto de diagonales obtenidas

tras la ejecución de este algoritmo para el polígono monótono de ejemplo.

Veamos como funciona el algoritmo en sus primeros pasos para este ejemplo.
Al ordenar los puntos de mayor a menor obtenemos la numeración que vemos
en la figura. Antes de entrar en el bucle, la lista l = s0; s1. Al entrar por
primera vez en el bucle con j = 2, observamos que s2 es adyacente al final de
la lista l (2a sentencia condicional) pero el algoritmo no construye aún
diagonales porque el Angulo(s[2],1,0)> por lo que la lista acaba siendo l
=s0; s1; s2. Las siguientes iteraciones son iguales, hasta que para j = 4 se
construyen las diagonales 1–4;2–4;3–4. La idea básica del algortimo es
construir diagonales con el comienzo de la lista l o con el final de ésta ,
teniendo en cuenta que sólo se unen puntos visibles entre sí (ángulo < ) y
que no son adyacentes.
El tiempo de ejecución de este algoritmo es O(nlog n). El proceso de

ordenación de los vértices ya posee este orden de ejecución, por lo que dicho
algoritmo no podría ejecutarse en menor tiempo. Además habría que añadir un
tiempo lineal, puesto que todas las operaciones del algoritmo, operaciones con
el final y principio de la lista, el cálculo del ángulo, etc., se ejecutan en tiempo
constante. Tan sólo nos puede plantear un problema los bucles MIENTRAS,
pero sin embargo aseguramos el tiempo lineal del proceso, puesto que todo
vértice es procesado como mucho dos veces, uno cuando entra en la lista y
otra vez cuando sale de ésta.
2.2.2. Partición de un polígono en componentes monótonas
La triangulación de polígonos monótonos desde luego deja de tener sentido si

no es posible particionar cualquier tipo de polígono en particiones monótonas.
En este apartado completamos el proceso de triangulación eficiente de
polígonos dando un algoritmo capaz de encontrar diagonales tales que dividan
dicho polígono en particiones monótonas.

Consideramos a un polígono y-monótono si para cada horizontal h, la

intersección del polígono con h es conexa, esto es, es un punto o el vacío. La
definición para x-monótono es análoga.
Antes de ver el funcionamiento del polígono determinaremos los cinco tipos de

vértices que podemos encontrar:
Vértice comienzo: el vértice vi es de comienzo si vi–1 y vi+1 poseen menor

ordenada y su ángulo interior es menor que .
Vértice final: el vértice vi es de final si vi–1 y vi+1 poseen mayor ordenada y

su ángulo interior es menor que .
Vértice Partición: el vértice vi es de partición si vi–1 y vi+1 poseen menor

ordenada ysu ángulo interior es mayor que .
Vértice Mezcla: el vértice vi es de mezcla si vi–1 y vi+1 poseen mayor

ordenada y suángulo interior es mayor que .

Vértice Regular: cualquier otro vértice no considerado anteriormente.
Utilizaremos la técnica de .línea de barrido. para encontrar las distintas

particiones monótonas. La idea será localizar los vértices que rompen la
monotonía, los de partición y los de mezcla. Desde ellos se lanzarán
diagonales, el destino de éstos será también un objetivo primordial del
algoritmo.
Las estructuras de datos implicadas son las siguientes:
P: será un array conteniendo los vértices del polígono, ordenados como es

habitual en sentido antihorario.
Q: La línea imaginaria bajando por el plano se encontraría los puntos de P de
mayor a menor ordenada. Para no duplicar los puntos, y sobre todo por
ventajas computacionales, Q será un vector de tamaño n con los índices
de P identificando los puntos ordenados de mayor a menor ordenada.
T: Se trata de alguna estructura de datos con tiempo de acceso logarítmico.
Almacenará los vértices ei, siendo ei = vi –vi+1, con excepción de en–1 =
vn–1v0. El conjunto de ejes se almacenan por la coordenada x, tanto de
izquierda a derecha.
Ayu: Es un array que almacena en todo momento el vértice candidato para
unir a los vértices de partición y mezcla. Los valores podrán ir
cambiando hasta que se localice el valor correcto.
D: Mantiene el resultado, es decir, el conjunto de diagonales conseguidas por
el algoritmo.
Puede ser un array o una lista.

Algoritmo de triangulación
PROCEDIMIENTO HacerMonotono (VAR P : TipoPol igono ; VAR D: TipoLi s ta )

ENTRADA: El Ìpolgono P de Òtamao n
SALIDA : El conjunto D de diagonales
INICIO
Ordenar_Y ( P, n ,Q)
I n i c i l i z a r L i s t a ( T)
I n i c i a l i z a r L i s t a (D)
Para k<_ 0 hasta n_1 Repet i r
i <_Q( k )
34
2 La envolvente convexa y triangulaciÛn de polÌgonos
EN CASO DE QUE TipoVer t i ce (P, i ) SEA
0 : ( _ Comienzo _)
ListaInser tarOrdenado (T, i ,P)
Ayu ( i ) <_ i
1 : ( _ Final _)
Si TipoVer t i ce (P , Ayu ( i _1))=2
Entonces I n s e r t a r L i s t a (D, { i_Ayu ( i _1)})
L i s t aEl imi n a r ( T , i _1)
2 : ( _ Mezcla_)
Si TipoVer t i ce ( P, Ayu ( i _1))=2
Entonces L i s t a I n s e r t a r (D, { i_Ayu ( i _1)})
L i s t aEl imi n a r ( T , i _1)

j <_ ListaBuscar Izdo ( T , i )

Si TipoVer t i ce ( P, Ayu ( j ) )=2
Entonces L i s t a I n s e r t a r (D, { i_Ayu ( j ) } )
Ayu ( j ) <_ i
3 : ( _ ÛPa r t i c i n )
j <_ ListaBuscar Izdo ( T , i )
L i s t a I n s e r t a r (D, { i_Ayu ( j ) } )
Ayu ( j )<_ i
ListaInser tarOrdenado ( T , i ,P)
Ayu ( i )<_i
4 : ( _ Regular_)
Si Inter iorDecha ( P, i )
Entonces
Si TipoVer t ice (P , Ayu ( i _1))=2
Entonces L i s t a I n s e r t a r (D, { i_Ayu ( i _1)})
L i s t aBo r r a r (T, i _1)
ListaInser tarOrdenado (T, i ,P)
Ayu ( i )<_i
Sino
j <_ListaBuscar Izdo (T, i )
Si TipoVer t ice (P, Ayu ( j ) ) = 2
Entonces L i s t a I n s e r t a r (D, { i_Ayu ( j ) }
Ayu ( j )<_ i
FIN_SI
FIN_SI
FIN_CASE
FIN
El tiempo de ejecución del algoritmo es óptimo. La ordenación de los vértices

puede realizarse en tiempo O(nlog n). Cada una de las n iteraciones de bucle
se ejecuta en tiempo logarítmico, el correspondiente a las operaciones de
manejo de la estructura de datos T.

3 Intersecciones
La detección de intersecciones constituye una de las primitivas geométricas

fundamentales con muy diversas aplicaciones. En realidad virtual o diseño de
circuitos VLSI el manejo de intersecciones es fundamental. Pero existen otras
áreas de interés más próximas a la Topografía como son los Sistemas de
Información Geográfica. En muchas ocasiones para hacer los mapas más
manejables y legibles, la información que contienen se divide en distintos tipos
de mapas, cada uno especializado en carreteras, ciudades, ríos y montañas,
densidad de población, etc. La información geométrica subyacente en cada uno
de estos mapas también puede considerarse diferente, así una carretera puede
ser representada mediante una polilínea y un núcleo urbano puede serlo
mediante conjunto de polígonos. Sin embargo, cuando dos de estos mapas
necesitan ser manejados al mismo tiempo (por ejemplo para conocer las
carreteras que llegan a una ciudad), es necesario el manejo de intersecciones
entre iguales o diversos objetos geométricos.
Los problemas que necesitan del procesamiento de intersecciones pueden ser

de distinta índole. En algunas ocasiones no es necesario determinar con
exactitud el punto de corte entre dos elementos geométricos, únicamente
conocer si existe dicha intersección. También podemos encontrar una
diferencia sustancial entre manejar un par de líneas o segmentos o hacerlo con
un conjunto de ellos. De hecho, la realidad a veces necesita simular la forma
de cualquier línea mediante una polilínea o conjunto de segmentos unidos a
modo de cadena. La naturaleza de los objetos también puede ser conveniente
conocerla a priori, puesto que la intersección de polígonos convexos cuenta con
un orden de ejecución menor que si se trata de polígonos generales.
3.1. Intersección de polígonos convexos
El tiempo de ejecución para conocer la intersección de dos polígonos

cualesquiera es O(nm), siendo n y m el número de ejes de los dos polígonos.
El resultado de calcular la intersección de dos polígonos cualesquiera podemos
verlo en la siguiente figura:

Sin embargo, realizar esta operación con polígonos convexos puede hacerse en
tiempo O(n+m). Existe una propiedad importante para la intersección de
polígonos convexos: la intersección es también un polígono convexo.
Denominaremos a A y B a los ejes que en cada momento se están ejecutando.

En cada iteración se avanza el eje A o el B (siempre en orden inverso a las
agujas del reloj) dependiendo de ciertas reglas de avance. El objetivo es que
dichos avances se vayan sincronizando en cuanto a su velocidad para
encontrar todas las intersecciones.
Denominamos a como el punto de la cabecera del vector A, y b el punto de la

cabecera de B. Las reglas de avance harán por ejemplo, que si B apunta hacia
la línea que contiene a A, entonces avanzamos B para buscar la intersección
con A.
Denominaremos a H(A) como el semiplano cerrado a la izquierda de A y a H(B)

como el semiplano cerrado a la izquierda de H(B). Ocurre que AxB > 0 cuando
el giro más corto de girar A hacia B es en sentido inverso a las agujas del reloj.
Como por regla general los dos vectores no coincidirán en su inicio,
imaginaremos sin embargo que así ocurre para localizar el giro más corto. En
el siguiente ejemplo, AxB > 0 puesto que observamos que hacemos un giro en
sentido de las agujas del reloj para ir de A hacia B.
Las reglas de avance quedan resumidas en la siguiente tabla:

AXB Condiciones del semiplano Regla de avance
El método anteriormente descrito aparece a continuación. También aparece el

pseudocódigo de otros subalgoritmos llamados por el algoritmo principal.

PROCEDIMIENTO IntersectaPol igonosConvexos (VAR P,Q: TipoPol igono ; n

,m: Entero )
ENTRADA: P,Q de ñtamao n y m
SALIDA :
VARIABLES:
CONSTANTES: Origen : ( 0 , 0 )
INICIO
a<–0
b<–0
Dentro <– –1
REPETIR
a1 <– (a+n–1) mod n
b1 <– (b+m–1) mod m
Subvector (P[ a ] , P[ a1 ] , A)
Subvector (Q[ b ] , Q[ b1 ] , B)
ProductoX <– Area2 ( Origen , A, B)
bHA <– IzdaSobre (P[ a1 ] ,P[ a ] ,Q[ b ] )
aHB <– IzdaSobre (Q[ b1 ] ,Q[ b ] ,P[ a ] )
SI ( I n t e r s e c t a P[ a1 ] ,P[ a ] ,Q[ b1 ] ,Q[ b ] ,P)
ENTONCES SI Dentro = –1
ENTONCES AvanA <– 0
AvanB <– 0
fiNfiSI
Dentro <– TestDentro ( aHB)
fiNfiSI
SI ( ProductoX fi 0)
ENTONCES SI ( bHA)
ENTONCES a <– Avanza ( a , AvanA , n , Dentro , P[ a ] )
SINO b <– Avanza ( b , AvanB , m, NOT Dentro , Q[ b ] )
SINO SI ( aHB)
ENTONCES b <– Avanza ( b , AvanB , m, NOT Dentro , Q[ b ] )
SINO a <– Avanza ( a , AvanA , n , Dentro , P[ a ] )
fiNfiSI
HASTA ( AvanA fi n AND AvanB fi m)
SI Dentro = –1
ENTONCES ESCRIBIR "No ha habido ó i n t e r s e c c i n " ;
fiN
FUNCION TestDentro (H: Entero ) : óLgico
INICIO
SI H < > 0
ENTONCES TestDentro <– 1
SINO TestDentro <– 0
fiN
FUCION Avanza (VAR ab , Avd : Entero ; n : Entero ; Dentro : óLgico ; v :
TipoPunto )
INICIO
SI Dentro
ENTONCES Pi n t a r ( v )

fiNfiSI
Adv <– Adv + 1
ab <– (ab +1) mod n
fiN
PROCEDIMIENTO Subvector (VAR a , b , c : TipoPunto )

INICIO
PARA i <– 0 HASTA 1 INCR + 1 REPETIR
c [ i ] <– a [ i ] – b [ i ]
fiNfiPARA
fiN
En el siguiente ejemplo observamos un ejemplo de polígonos convexos.
En la siguiente tabla observamos el resultado tras aplicar el algoritmo. En la

última columna observamos el avance de los ejes. Podemos comprobar que el
recorrido conjunto de ambos ejes permite localizar todas y cada una de las
intersecciones existentes.

3.2. Intersección de segmentos
La intersección de segmentos es un cálculo muy importante por las

repercusiones que tiene a nivel de intersecciones en el mundo real. Podemos
simular una carretera como un conjunt de segmentos. Para saber donde se
podría construir un puente podríamos computar el conjunto de intersecciones
entre el mapa de carreteras y el mapa de ríos. Las operaciones realizadas a
bajo nivel en la aplicación informática que lleve a cabo este cálculo serán las
de intersecciones de segmentos.
Puede realizarse siempre un algoritmo de fuerza bruta para realizar este

cálculo utilizando para ello un tiempo O(n2) si supuestamente empleamos un
número similar de ríos y de carreteras. Como es de imaginar este algoritmo
procesaría todos los ríos con todas las carreteras, y siendo por tanto poco
eficiente. Probablemente el número de intersecciones sea mucho menor al de
potenciales puntos de intersección, por lo que podría buscarse un método
alternativo que tuviera por principio el procesar únicamente posibles
intersecciones en segmentos que estén cerca, evitando así cálculos
innecesarios.
La estrategia a seguir puede ser la de bajar una línea horizontal L de arriba
hacia abajo por el plano de modo que se vaya tropezando tanto con un tipo de
segmentos como del otro. Cada vez que L se encuentra con un segmento lo
almacena en una lista ordenada de izquierda a derecha, y así sucesivamente
con todos y cada uno de los segmentos localizados. Para cada nueva
intersección y borrado en dicha lista se pregunta si la nueva situación provoca
una intersección, siempre entre segmentos vecinos de la lista.

Emplear las estructuras de datos correctas en este método es fundamental

para la eficiencia de éste.
P: Es un array que contiene el conjunto de segmentos iniciales dispuesto en

principio en cualquier tipo de orden. El array tiene un tamaño de nx4
puntos, siendo cada fila los cuatro puntos que forman un segmento en el
orden {x0; y0; x1; y1}, siendo siempre el punto (x0; y0) el extremo de
mayor ordenada.
Q: Es la denominada cola de eventos que almacena el conjunto de vértices y
de puntos intersección. Mantendrá los puntos extremos ordenados de
mayor a menor ordenada. Cuando en dicha lista se inserten dos puntos
con la misma ordenada, se considerará primero el de menor abscisa.
Será preferentemente una lista a un array porque deberá permitir
inserciones.
T: Estructura de datos que simula el comportamiento de la línea imaginaria L.
Mantendrá ordenados de izquierda a derecha los segmentos que en todo
momento vaya atravesando, eliminado los ya procesados e insertándolos
cuando se comienzan a atravesar. Esta estructura de datos deberá
permitir inserciones y borrados en tiempo logarítmico 1.
I: Cualquier tipo de estructura de datos que almacene las intersecciones
localizadas.
La función ManejarEvento es la encargada de procesar cada uno de los nuevos

extremos de la cola de eventos Q. Esta función sería llamada por el algoritmo
EncontrarIntersecccion tal y como vemos a continuación.
ALGORITMO Encontrar Intersección


Sin embargo, la función de intersección de segmentos desarrollada en el

primer tema no es válida para conocer el punto de intersección entre dos
segmentos, sólo para saber si dicha intersección se produce.

En el siguiente ejemplo vemos un conjunto de segmentos en los cuales

podemos encontrar un conjunto de intersecciones. Hay que tener en cuenta
que el algoritmo también detecta las intersecciones de los segmentos por sus
extremos, ya que hay que tener en cuenta que los segmentos pueden llegar
desordenados y sin relación unos con otros.
4 Localización de puntos y diagramas de Voronoi
4.1. Punto en polígono
El problema denominado punto en polígono se presenta cada vez que se

pincha el ratón en pantalla. Si el polígono P sobre el que trabajamos es
convexo, el problema puede solucionarse en tiempo O(logn). Pero el método
más interesante ocurre cuando P no es convexo.
Para este caso utilizamos el siguiente método: si queremos saber si el punto q

está dentro o fuera del polígono P trazamos una línea en cualquier dirección,
por ejemplo utilizando la recta r igual a y = 0, x fi 0 y entonces contamos el
número de intersecciones que se producen. El punto q está dentro de P si el
número de intersecciones es impar.
Para hacer más fácil el cálculo y utilizar una recta r válida para cualquier caso,
hacemos coincidir el punto q con el origen de coordenadas de forma que la r
pueda ser simplemente y = 0; para x >= 0.

Para conocer el lugar justo de intersección utilizaremos la siguiente fórmula:
trasladamos la idea anterior al siguiente algoritmo en pseudocódigo que realiza

el test de inclusión de punto en polígono. El primer conjunto de bucles hace el
cambio de origen de coordenadas.
En el siguiente se detectan las intersecciones con la recta y = 0, pero sólo se

tienen en
cuenta los cortes que se producen para x > 0.
El tiempo de ejección de este test de inclusión es lineal, como claramente

indica la búsqueda exhaustiva de intersecciones de una recta con todas las
aristas de un polígono.

DIAGRAMA DE VORONOI
En este capítulo estudiamos el diagrama Voronoi, una estructura geométrica

segunda en importancia sólo detrás del buque convexo. En cierto sentido un
diagrama de Voronoi registra todo lo que uno alguna vez querría saber acerca
de proximidad para un grupo de puntos (u objetos más generales). Y a menudo
uno quiere saber detalles acerca de la proximidad: ¿Quién está más cercano a
quién? ¿Quién está más lejos? Etcétera. El concepto tiene más de un siglo de
antigüedad, discutido en 1850 por Dirichlet y en 1908 por Voronoi.
Comenzaremos con una serie de ejemplos para motivar el debate y entonces, la
zambullida en los detalles de la estructura enriquecedora del diagrama Voronoi
(en las Secciones 5.2 y 5.3). Hay que familiarizarse con estos detalles antes de
que los algoritmos puedan ser apreciados (en la Sección 5.4). Finalmente
revelaremos la bella conexión entre diagramas Voronoi y buques convexos en la
Sección 5.7. Este capítulo incluye sólo dos pedazos pequeños de código, para
construir lo dual del diagrama Voronoi (la triangulación Delaunay), en la Sección
5.7.4.
APLICACIONES PRELIMINARES
1. Las torres de observación de fuego
Imagine un bosque vasto conteniendo un número de torres. Cada

guardabosque es responsable de extinguir cualquier fuego más cercano para
su torre que para cualquier otra torre. El grupo de todos los árboles para los
cuales un guardabosque particular es responsable constituye el “Polígono de
Voronoi” asociado con su torre. El diagrama de Voronoi traza las líneas entre
estas áreas de responsabilidad: Los lugares en el bosque que son
equidistantes de dos o más torres. (Una vistazo a la Figura 5.5 puede ayudar
a la intuición).

2. Las torres en llamas
Imagine ahora la situación perversa donde todos los guardabosques

encienden sus torres simultáneamente, y el bosque se quema a una velocidad
uniforme. El fuego se dispersará en círculos centrado en cada torre. Los
puntos en los cuales el fuego se apaga es porque ha alcanzado previamente
árboles consumidos son esas puntos equidistantes de dos o más torres, los
cuáles son exactamente los puntos en el diagrama Voronoi.
3. La agrupación de vecinos mas cercanos
Una técnica frecuentemente utilizada en el campo de reconocimiento de

patrones es trazar un mapa de un grupo de objetos blancos en un rasgo del
espacio reduciendo los objetos a puntos cuyas coordenadas son las medidas
de rasgo. El ejemplo de cinco medidas de la sastrería de la Sección 4.6.1
puede ser visto como una definición o una característica del espacio. La
identidad de un objeto de afiliación desconocida entonces le puede ser
asignada al objeto próximo de blanco en el rasgo del espacio.
Un ejemplo hará esto más claro. Suponga que un depósito de partes incluye
dos tipos de nueces A y B, una con diámetros interior y exterior de 2 y 3
centímetros respectivamente, y B con el espacio de diámetros 3 y 4 cm., el
rasgo es el cuadrante positivo del plano Euclidiano de dos dimensiones,
positivo porque ningún radio puede ser negativo A traza al grano (2,3), y B
al punto (3,4).
Suponga, que un sistema de visión enfoca la atención en una nuez x en el
depósito y se mide su radio interior y exterior para tener 2.8 y 3.7 cm.
Conociendo que hay inexactitudes de medida, y que sólo las nueces de tipo
A y B están en el depósito, ¿que tipo de nuez es x? Es más probable que sea
una nuez de tipo B, porque su distancia para B en el rasgo del espacio 0.36,
considerando su distancia para A es 1.06. Vea la Figura 5.1. En otras
palabras, la vecina más próxima de x es B, porque la x está en el polígono
de Voronoi de B.
Si hay muchos tipos de nueces, la tarea de identificación es localizar la nuez
desconocida x en el diagrama de Voronoi de las nueces blancos. Cómo puede
estar esto hecho eficazmente se discutirá en la Sección 5.5.1.

4. La facilidad de Localización
Suponga que a usted le gustaría localizar una tienda de comestibles nueva en

un área con varias tiendas de comestibles existentes, irreconciliables.
¿Asumiendo densidad de población uniforme, dónde debería estar la tienda
nueva localizada para optimizar sus ventas? Un método natural que satisfaga
esta restricción vaga es localizar la tienda nueva tan lejos de las viejas como
sea posible. Aun esto es un poco vago; Más precisamente podríamos escoger
una localización cuya distancia para la tienda próxima es tan grande como sea
posible. Esto es equivalente a localizar la tienda nueva en el centro del círculo
vacío más grande, el circulo más grande cuyo interior no contiene otras
tiendas. La distancia para la tienda mas próxima es entonces el radio de este
círculo.
Mostraremos en 5.5.3 Sección que mientras central de círculo vacío más
grande debe mentir en el diagrama Voronoi.
5. Planeando el camino
Imagine un ambiente desordenado a través del cual un robot debe planear un

camino. Para minimizar el riesgo de colisión, al robot le gustaría quedarse tan
lejos de todos los obstáculos como sea posible. Si restringimos la pregunta a
dos dimensiones, y si el robot es circular, entonces el robot debería quedarse
todo el tiempo en el diagrama de Voronoi de los obstáculos. Si los obstáculos
son puntos (digamos polos delgados), entonces éste es el diagrama
convencional de Voronoi. Si los obstáculos son polígonos u otras formas,
entonces una versión generalizada del punto del diagrama Voronoi determina
el camino apropiado.
Revisaremos este ejemplo en el Capítulo 8 (la Sección 8.5.2).
6. La cristalografía

Asuma un número de granos de cristal crecen uniformes, a velocidad

constante. ¿Cuál será la apariencia del cristal cuando el crecimiento ya no es
posible? Debería estar claro ahora que esto es análogo al incendio de bosques,
y que cada grano crecerá para un polígono de Voronoi, con regiones
adyacentes del grano encontrándose a lo largo del diagrama de Voronoi. Los
diagramas de Voronoi por mucho tiempo se han usado para simular
crecimiento del cristal.
La lista de aplicaciones podría seguir sin parar, y veremos otros en la Sección
5.5. Pero es hora de definir el diagrama formalmente.
DEFINICIONES Y PROPIEDADES BASICAS
Sea P = {p1, p2,…, pn} un grupo de puntos en el plano Euclidiano de dos

dimensiones. Éstos son llamados los sitios. Divida en partes el plano asignando
cada punto en el plano a su sitio más próximo. Todos esos puntos asignados a
pi forman la región de Voronoi V (pi). V (pi) consiste de todos los puntos al menos
tan cercanos a pi en lo que se refiere a cualquier otro sitio:
V (pi) = {x: | pi - x pj - x j }.
Note que hemos definido este grupo para ser cerrado. Algunas puntos no tienen
un único sitio próximo, o vecino próximo. El grupo de todos los puntos que tienen
más de un vecino cercano forman el diagrama de Voronoi V (P) para el grupo de
sitios.
Más tarde definiremos los diagramas de Voronoi para grupos de objetos más
generales que puntos. Primero miramos diagramas con justamente algunos
sitios antes de detallar sus propiedades para n mayor.
Dos sitios
Considere solo dos sitios, p1 y p2. Sea B (p1, p2) = B12 la bisectriz perpendicular
del segmento p1p2. Entonces cada punto x en B12 es equidistante de p1 y p2. Esto
puede verse dibujando el triángulo (p1, p2, x) como se muestra en la Figura 5.2.
Por el teorema del lado - ángulo - lado de Euclides, | p1x | = | p2x |.

Tres sitios
Para tres sitios, es claro que fuera del triángulo (p1, p2, p3), el diagrama contenga
la bisectriz B12, B23, B31. Lo que no esta claro es que ocurre en los alrededores
del triángulo. Otra vez de Euclides las bisectrices perpendiculares de los tres
lados del triángulo todos atraviesan un punto, el circuncentro, el centro del único
círculo que pasa a través de los vértices del triángulo. Así el diagrama Voronoi
para tres puntos debe aparecer como en la Figura 5.3. (Sin embargo, el
circuncentro de un triángulo no está siempre dentro del triángulo como se
muestra).
Semiplanos
La generalización más allá de tres puntos quizá todavía no esta clara, pero es
ciertamente claro que la bisectriz Bij desempeñará un papel. Sea H el semiplano
cerrado con límite Bij y conteniendo pi. Entonces H puede ser visto como todos
los puntos que están cercanos a pi que a pj. Ahora ordene el regreso de que V
(pi) es el grupo de todos los puntos más cercano a pi que a cualquier otro sitio:
En otras palabras, los puntos más cercanos a pi que a p1, y más cercano a pi que

a p2, y más cercano a pi que a p3, etcétera. Esto muestra que podemos escribir
esta ecuación o V(pi):
V (pi) = 
i j
H (pi, pj) (ecuación 5.2)
Donde la notación significa que la intersección debe estar ocupada sobre todo i
y j como i  j. Note que esa conjunción inglesa “y” ha sido trasladada a
intersección de conjunto.
Figura 5.4 (a) Diagrama de Voronoi para cuatro puntos cocirculares; (b)
diagrama después de mover los puntos hacia la izquierda.
La ecuación (5.2) inmediatamente nos da una propiedad importante de los
diagramas de Voronoi: Las regiones de Voronoi son convexas, pues la
intersección de cualquier número de Semiplanos es un grupo convexo. Cuando
las regiones están rodeadas, son polígonos convexos. Los bordes de las regiones
de Voronoi son llamados bordes de Voronoi, y los vértices son llamados vértices
de Voronoi. Note que un punto en el interior de un borde de Voronoi tiene dos
sitios próximos, y un vértice de Voronoi tiene al menos tres sitios próximos.
Cuatro sitios
El diagrama de cuatro puntos formando las esquinas de un rectángulo es
mostrado en la Figura 5.4 (a). Note que el vértice de Voronoi es de grado cuatro.
Ahora suponga que un sitio es movido ligeramente, como en la Figura 5.4 (b).
Hay un sentido en el cual este diagrama es normal, y uno en la Figura 5.4 (a)
que es anormal o “degenerado”. Es degenerado por que hay cuatro puntos
cocirculares. A menudo lo encontraremos útil para excluir este tipo de
degeneración.
Muchos sitios
Un diagrama típico con muchos sitios es mostrado en la figura 5.5. Un vértice
de Voronoi no es mostrado en esta figura: Los dos rayos casi horizontales

dejando el diagrama para la izquierda no son muy paralelos y se intersecan en

un vértice de Voronoi cerca de 70 centímetros a la izquierda de la figura.
Tamaño del diagrama
Aunque hay exactamente n regiones de Voronoi para n sitios, el tamaño
combinatorio total del diagrama concebible podría ser cuadrático en n, pues
cualquier región particular de Voronoi puede tener  (n) bordes de Voronoi
(Ejercicio 5.3.3 [4]). Sin embargo, nosotros ahora mostramos que de hecho este
no es el caso, que el tamaño total del diagrama es  (n).
Asumamos pues por simplicidad que ninguna de los cuatro puntos son
cocirculares, y por consiguiente cada vértice de Voronoi es de grado tres.
Construya la gráfica dual G (Sección 4.4) para un diagrama Voronoi V (P) como
sigue: Los nodos de G son sitios de V (P), y dos nodos están conectados por un
arco si sus polígonos correspondientes de Voronoi comparten un borde de
Voronoi (comparten un borde de longitud positiva).
Ahora observe que éste es un grafo planar: Podemos incrustar cada nodo en su
sitio, y todo el incidente de arcos para el nodo puede ser angularmente
clasificado lo mismo los bordes del polígono. Además todas las caras de G son
triángulos, siendo propio del vértice de Voronoi de grado tres. Este reclamo será
hecho más claro en un momento (la Figura 5.6).
Pero previamente mostramos que la fórmula de Euler significa que un grafo
planar triangulado con n vértices tiene 3n-6 de bordes y 2n-4 caras; Vea la
Sección 4.1.1 Teorema 4.4.5. Porque las caras de G son propias de los vértices
de Voronoi, y porque los bordes de G son propios de los bordes de Voronoi
(desde que cada arco de G le cruza un borde de Voronoi), hemos mostrado que
el número de vértices de Voronoi, bordes, y las caras es  (n).
Si ahora removemos, entonces la suposición que ninguno de los cuatro puntos

son cocirculares, la gráfica es todavía planar, pero no necesariamente
triangulado. Por ejemplo, lo dual del diagrama mostrado en Figura 5.4 (a) es un
cuadrilátero. Pero tales gráficas poco trianguladas tienen menos conexiones
entre dos vértices de un gráfico y caras, así es que los  (n) saltos continúan
teniendo aplicación.
Una consecuencia del salto del borde 3n-6 es que el número común de bordes
de un polígono de Voronoi no puede ser más de seis (el Ejercicio 5.3.3 [5]).
Triangulación de Delaunay
En 1934 Delaunay probó que cuándo la gráfica dual se traza con líneas rectas,
produce una triangulación planar de los sitios de Voronoi P (si ninguno de los
cuatro sitios son cocirculares), ahora llamado la triangulación de Delaunay D (P).
Figura 5.6 muestra la triangulación de Delaunay para el diagrama de Voronoi en
Figura 5.5, y la figura 5.7 muestra que la triangulación de Delaunay
superpuesta en el diagrama correspondiente de Voronoi. Note que no es
inmediatamente que usando líneas rectas en el duales evitaria cruzarse adentro

del dual; El segmento dual entre dos sitios necesariamente no cruza el borde
Voronoi compartido entre ahora, pero más bien esperaremos hasta que hayamos
recogido más propiedades de la triangulación Voronoi de diagramas y Delaunay,
cuándo la prueba será fácil.
Las propiedades de triangulación de Delaunay
Debido que la triangulación de Delaunay y el diagrama de Voronoi son

estructuras duales, cada uno contiene la misma “información” en algún sentido,
solamente representó en una forma más bien diferente. Para ganar un agarre
en estas estructuras complicadas, es importante para tener una comprensión
cabal de las relaciones entre una triangulación de Delaunay y su diagrama
correspondiente de Voronoi. Listamos sin prueba varias propiedades de
Delaunay y seguiremos con una lista más substantiva de propiedades de
Voronoi. Sólo la propiedad D6 y D7 no han sido mencionados anteriormente. Fija
un grupo de sitios P.
D1. D (P) es la línea recta dual de V (P). Esto es por definición.
D2. D (P) es una triangulación si ninguno de los cuatro puntos de P son
cocirculares: Cada cara es un triángulo. Éste es el teorema de Delaunay. Las
caras de D (P) son llamados triángulos de Delaunay.
D3. Cada cara (triángulo) de D (P) es propia de un vértice de V (P).
D4. Cada borde de D (P) es propio de un borde de V (P).
D5. Cada nodo de D (P) es propio de una región de V (P).
D6. El límite de D (P) es el buque convexo de los sitios.
D7. El interior de cada (triángulo) cara de D (P) no contiene sitios.
Las propiedades D6 y D7 aquí son lo más interesante; Pueden ser verificados
en Figura 5.6 y 5.7.
Elementos del diagrama de Voronoi
Podemos considerar los siguientes elementos en el diagrama de Voronoi:
pi punto generador.
eje es el conjunto de segmentos, semirectas o lÌneas in_nitas que son frontera

de una región de Voronoi a otra.
vértice un punto que comparte m·s de dos polÌgonoos de Voronoi.
adyacentes dos regiones se dice que son adyacentes si comparten algÿn eje.
Los conceptos anteriores son extensibles a tres dimensiones, teniendo en
cuenta que ahora las regiones de Voronoi serÌan poliedros y los ejes serÌan
polÌgonos.
Las propiedades de los Diagramas de Voronoi

V1. Cada región de Voronoi V (pi) es convexa.

V2. V (pi) es ilimitada si pi está en el buque convexo del grupo del punto.
V3. Si la v es un vértice de Voronoi en la unión de V (p1), V (p2), y V (p3),
entonces la v es el centro del círculo C (v) determinado por p1, p2, y p3. (Este
reclamo generaliza a los vértices de Voronoi de cualquier grado).
V4. C (v) es el circuncirculo para el triángulo de Delaunay correspondiente a v.
V5. El interior de C (v) no contiene sitios.
V6. Si pj es el vecino próximo a pi, entonces (pi, pj) es un borde de D (P).
V7. Si hay algún círculo a través pi y pj que no contiene otros sitios, entonces
(pi, pj) es un borde de D (P). El inverso también tiene aplicación: Pues cada
borde de Delaunay, hay algún círculo vacío.
La propiedad V7, la menos intuitiva, es una caracterización importante de los
bordes de Delaunay y será usada en varias pruebas más tarde. Ésta es la única
propiedad que probaremos formalmente.
La prueba. En una dirección es fácil: Si ab es un borde de Delaunay, entonces V
(a) y V (b) comparten un borde de longitud positiva e  V (P). Ponga a un círculo
C (x) con centro en x, con radio igual a la distancia de a o b. Este círculo está
obviamente vacío de otros sitios, pero si no fuera así, el sitio c estaría sobre o
dentro del círculo, x estaría en V (c) igualmente, pero conocemos que x esta
solamente V (a) y V (b).
La implicación inversa es más sutil. Suponga que hay un círculo vacío C (x) a
través de a y b, con centro en x. Tenemos la intención de poner a prueba que
ab  D (P). Porque la x es equidistante de a y b, x está en las regiones de
Voronoi de ambos a y b mientras ningún otro punto interfiera con “El sentido de
la hermandad próximo”. Pero ninguno es, porque el círculo está vacío. Por
consiguiente, x  V(a)  V (b) (la retentiva que definimos como regiones de
Voronoi son grupos cerrados). Porque ninguno de los puntos estan sobre el límite

de C (x) de otra manera que a y b (por la hipótesis), allí deban ser libertad para
contonearse la x un poco y mantener vacío C (x). En particular, podemos mover
x a lo largo de Bab, la bisectriz entre a y b, y podemos mantener vacío al
conservar el círculo a través de a y b. Ver la Figura 5.8. Por eso la x está en una
longitud positiva del borde de Voronoi (un subconjunto de Bab ) compartido entre
V (a) y V (b). Y por consiguiente ab EMBED Equation.3  D (P).
Dejamos la prueba de las otras propiedades para la intuición, los ejercicios, y
para la Sección. 5.7.2
Ejercicios
1. El polígono regular [fácil]. Describa la triangulación del diagrama de

Voronoi y la triangulación de Delaunay para los vértices de un polígono regular.
2. Las regiones ilimitadas. Ponga a prueba la propiedad V2: V (pi) es ilimitada
del si pi está en el buque convexo del grupo del punto. No se haga cargo de
la propiedad correspondiente de Delaunay D6, pero de otra manera cualquier
propiedad Delaunay o Voronoi puede ser empleada en la prueba.
3. El vecino más cercano. Ponga a prueba propiedad V6: Si el pj es un vecino
próximo a pi, entonces (pi, pj) es un borde de D (P). Cualquier propiedad
Delaunay o Voronoi puede ser empleada en la prueba.
4. El vértice de Delaunay de alto-grado. Diseñe un grupo de puntos, con n
arbitrario, y sin cuatro puntos cocirculares, algo semejante aquél que el
vértice de la triangulación Delaunay tiene grado n-1.
5. Numero promedio de bordes del polígono de Voronoi, pruebe que el promedio
de todas las regiones Voronoi para cualquier grupo de n puntos, no excede 6.
6. Las triangulaciones de Pitteway. Una triangulación de un grupo de P de puntos
es llamada una triangulación Pitteway si, para cada triángulo T = (a, b, c),
cada punto en T tiene uno de a, b, o c como su vecino mas cercano entre los
puntos de P.
a. Muestre por ejemplo que no toda triangulación de Delaunay es una
triangulación de Pitteway.
b. Caracterizar aquellas triangulaciones de Delaunay que son triangulaciones
de Pitteway.
Los ALGORITMOS
Las muchas aplicaciones del diagrama de Voronoi y su belleza inherente les han
instado a los investigadores a que inventen una colección variada de algoritmos
para computarlo. En esta Sección 5.7.2 examinaremos cuatro algoritmos, cada
uno superficialmente, para ver que la Sección 5.7.2 que el diagrama Voronoi
puede ser computado usando nuestro código del buque convexo.
La intersección de los Semiplanos

Podríamos construir cada región de Voronoi separadamente, por la intersección
de n-1 semiplanos según la ecuación (5.2). Construyendo la intersección de n
semiplanos es dual para la tarea de construir el buque convexo de n puntos en
dos dimensiones y puede ser llevado a cabo con algoritmos similares en el

tiempo O(n log n) tiempo (Ejercicio 6.5.3 [5]). Hacer esto para cada sitio costaría
a O (n2 log n).
Construcción incremental
Suponga que el diagrama de Voronoi V para k puntos están ya construidos, y
ahora nos gustaría construir el diagrama V’ después de añadir uno o mas puntos
p. Suponga que p cae dentro de los círculos asociados con varios vértices de
Voronoi, dice C (v1),…, C (vm). Entonces estos vértices de V no pueden ser
vértices de V’, pues violan la condición de que los círculos del vértice de Voronoi
deben estar vacíos de sitios (V5, Sección 5.3.2). Resulta que éstos son los únicos
vértices de V que no están arrastrados sobre V’ También resulta que estos
vértices están todos localizados en un área del diagrama. Estas observaciones
vagas pueden ser hechas precisas, y forjan uno de los algoritmos más limpios
para construir el diagrama de Voronoi. El algoritmo gasta O (n) tiempo por
inserción de punto, para una complejidad total de O (n2). A pesar de esta
complejidad cuadrática, éste ha sido el método más popular de construir el
diagrama; Ver Field (1986) para los detalles de implementación.
El algoritmo incremental ha sido revitalizado recientemente con aleatorización,
el cual tocaremos en la Sección 5.7.4.
Divide y vencerás
El diagrama de Voronoi puede estar construido con un complejo algoritmo divide
y conquista en el tiempo O (n log n), primera parte detallada por Sahmos y Hoey
(1975). Fue este papel que introdujo el diagrama de Voronoi para la comunidad
de ciencia de la computación. Esta vez la complejidad es asintóticamente óptima,
pero el algoritmo es bastante difícil para implementar. De cualquier forma puede
estar hecho con atención meticulosa para las estructuras de datos.

Omitiremos este algoritmo históricamente importante para enfocar la atención

en algunos desarrollos recientes emocionantes.
El algoritmo de Fortune
Hasta la mediados de los 80, la mayoría de implementaciones para computar el

diagrama de Voronoi le usaron a la O (n2) algoritmo incremental, aceptando su
desempeño más lento para evitar las complejidades de la codificación divide y
conquista. Pero en 1985, Fortune (1987) inventó un algoritmo del barrido de
plano listo que es tan simple como los algoritmos incrementales pero tiene
complejidad del peor caso de O (n log n). Nosotros ahora esbozaremos la idea
principal detrás de este algoritmo.
Los algoritmos Plane-sweep(barrido de plano) (Sección 2.2.4 ) pasan una línea
de barrido sobre el plano, dejando en cualquier hora el problema solucionado
para la porción del plano ya barrido y no resuelta para la porción todavía no
alcanzada. Un algoritmo Plane-sweep para construir el diagrama de Voronoi
construiría el diagrama detrás de la línea. A primera vista, esto parece realmente
mentira, como los bordes Voronoi de una región de Voronoi V (p) serían
encontrados por la línea de barrido antes de que la L encuentre la p del sitio
responsable para la región. Fortune superó esta imposibilidad aparente por una
idea extraordinariamente lista.
Los conos
Imagine los sitios en el plano xy del sistema de coordenadas tridimensional.

Erecto sobre cada sitio p un cono cuya cima está en p, y cuyos lados se inclinan

a 45º. Si la tercera dimensión es mirada como el tiempo, entonces el cono sobre

p representa un círculo dilatándose sobre p a una velocidad única: Después de
t unidades tiempo, su radio es t.
Ahora considere dos conos cercanos, sobre los sitios p1 y p2. Se intersecan en
una curva en el espacio. Recordando la vista de círculos en expansión del
diagrama de Voronoi, debería ser esperado que esta curva yazca enteramente
en un plano vertical, el plano ortogonal para la bisectriz de p1p2. Vea la Figura
5.9. Así que aunque la intersección está curvada en tres dimensiones, se
proyecta para una línea recta en el plano xy.
Es solamente un paso pequeño de aquí a que si los conos sobre todos los sitios
son opacos, y son mirados de z = -  , ¡lo que se ve es precisamente el diagrama
Voronoi!
El corte del cono
Estamos ahora preparados para describir la idea de Fortune. Su algoritmo barre

los conos con un plano sesgado, sesgado a 45º para el plano xy. La L de la línea
de barrido es la intersección con el plano xy. Demos por supuesto que la L es
paralela al eje vertical y que su coordenada de la x es l(ele). Vea Figura 5.10.
Imagínate que  , al igual que los conos, es opaco, y otra vez considera la vista
de z = -  .
Para la x > l, lado de L, solamente  es visible desde abajo: Hace un viraje
debajo del plano xy y así también obscurece los sitios y los conos. Esto
representa la porción del plano todavía no ha sido barrido. Para la x < l , lado
de L, el diagrama de Voronoi es visible hasta la intersección de  con la
“frontera” derecha (x positiva) de los conos. La intersección de  con cualquier
cono es una parábola (una propiedad básica de secciones cónicas), y así la
intersección de  con su frontera derecha proyecta al plano xy (y así aparece z
= -  ) como un “frente parabólico”, una curva compuesta de piezas de
parábolas. Vea Figura 5.11. Dos parábolas se unen en un lugar donde 
encuentra dos conos. De nuestro debate de la intersección de dos conos arriba,
esto debe estar en un borde de Voronoi.
Frente parabólico
Ahora finalmente podemos ver cómo solucionó Fortune el problema del problema
de la línea de barrido encontrando bordes de Voronoi antes de los sitios
generadores: ¡Porque su plano de barrido se inclina en los mismos bordes como
los lados de los conos, L encuentra un sitio p exactamente cuando  primero
golpea el cono para p! Por lo tanto no es ése el caso que el diagrama de Voronoi
que está en todo tiempo construido para la izquierda de L, pero está en todo
tiempo construido bajo  , lo cual quiere decir que esta construido a la izquierda
de L arriba para la parte delantera parabólica, lo cual queda atrás de L un poco.
El Lo que es mantenido en todo tiempo por el algoritmo es la parte delantera
parabólica, cuyas uniones trazan el diagrama de Voronoi sobre el tiempo, Desde
que todas estas enroscaduchas permanecen en los bordes de Voronoi. Aunque

nos acabamos de ninguna manera con la descripción del algoritmo, no haremos

el intento de detallarlo mas alla de esto.
Finalmente, debería estar claro que el algoritmo sólo necesite almacenar la parte
delantera parabólica, que es de tamaño O (n) y es a menudo O( n ) .Esto es
una ventaja significante del algoritmo de Fortune cuando la n es grande: El
almacenamiento necesitado es a menudo mucho más pequeño que el tamaño
de diagrama. Y n es a menudo grande, quizá 106 (Sugihara e Iri 1992), para
diagramas basados en datos recogidos por ejemplo en los sistemas de
información geográficos.
5.4.5 Ejercicios
1. D V (p) (p) Diseñar un algoritmo para la computar del diagrama de

Voronoi, dado la triangulación Delaunay. Trate de lograr complejidad de 0 (n)
tiempo.
2. Diagramas de Voronoi unidimensionales. Un Diagrama unidimensional de

Voronoi para un grupo de puntos P = { P1, …, Pn } en una línea (diga el eje de
la x) es un grupo de puntos V (P) = { x1, …, xn-1 } algo semejante que el x1 es
el punto medio de pi de Pi + 1.
Suponga que usted da un conjunto X = { x1, …, xn-1 }. Diseñe criterios que te

permitirán determinar si es o no X es un diagrama de unidimensional de Voronoi
de un grupo de puntos, y si es así. Determine P. ¿Con qué rapidez es el algoritmo
implementado?
3. Los diagramas dinámicos Voronoi. La imagen un grupo de puntos

moviendo en el plano, cada uno con una velocidad fija y dirección. Sea V (t) el
diagrama de Voronoi de puntos en el tiempo t. Este un problema no resuelto,
obtener saltos apretados en el número de diagramas distintos
combinatoriamente que pueden resultar todo el tiempo. Aquí le pregunto a usted
que establezca lo mejor conoce salto inferior:  (n2). En otras palabras,
encuentre un grupo de n moviendo puntos algo tal que V (t) cambie su estructura
combinatoria cn2 para alguna constante C.
Ningún a mismo capaz de encontrar un ejemplo en el cual haya más n2 cambios
pero el mejor salto alto esta alrededor de O(n3).
4. La triangulación arbitraria. Diseñe un algoritmo para encontrar que una
triangulación arbitraria de un grupo de punto P: Una colección de diagonales
incidente para cada punto de P que divide H (P) en triángulos. La ausencia del
requisito que la triangulación sea Delauny permite libertad considerable en el
diseño.
5. Algoritmo Lanzando. Investigue el siguiente algoritmo pensado para construir

a D (P): Comience con una triangulación arbitraria de P. Entonces repito el

siguiente procedimiento hasta que D (P) es logrado. Identifique dos triángulos

adyacentes abc y cbd compartiendo la diagonal bc, tal que el cuadrilátero abcd
sea convexo. Si d está dentro del circuncirculo de abc, entonces suprima cb y
agregue ad. ¿Trabajará esto?
5.5 Aplicaciones en Detalle.
Ahora Discutiremos cinco aplicaciones del diagrama de Voronoi, en el detalle

accidentado: Los vecinos próximos, las triangulaciones “gordas”, los círculos
más grandes vacíos, los árboles de extensión mínimos, y viajando a través de
caminos del vendedor.
5.5.1 Los vecinos más cercanos.
Una aplicación del diagrama Voronoi para agrupamiento de los vecinos más
cercanos mencionado en Sección 5.1 Este problema puede verse como un
problema de consulta: ¿Cuál es el vecino mas cercano a un punto buscado? Otra
versión es la problema del vecino más cercano: Encuentras el vecino mas
cercano para cada punto en un grupo dado. Esto tiene un número de aplicación
en una variedad de campos, incluyendo biología, la ecología, la geografía, y
Física.
Defina la relación entre el vecino mas cercano y un grupo P de puntos como

sigue: La b es una vecina próxima de a si | a – b |  minc  a| a – c |, donde c 
P. Podemos escribir esta relación a  b: Un vecino cercano de a es b. Note que
la definición no es simétrica con respectos a las tareas que a a y b les toca,
sugiriendo que la relación no sea así misma simétrica. Y de hecho éste es
ciertamente el caso: Si a  b, no es necesaria que b  a; Ver a Figure 5.12
También nota que un punto puede tener varios vecinos igualmente cercanos
(ejemplo, punto d en la figura).
El vecino cercano pregunta
Dado un grupo fijo de puntos P, construir el diagrama de Voronoi en el tiempo

O (n log n). Ahora para un punto de consulta q, encontrando un vecino cercano
de q para encontrar en cuál región de Voronoi cae, pues los sitios de esas
regiones de Voronoi son precisamente sus vecinos cercanos. El problema de
hallar un punto dentro de una partición es llamada localización del punto. El
problema ha sido estudiado con exceso y será discutido en el Capítulo 7 (Sección
7.11). Veremos que en este ejemplo, el tiempo O (log n) es suficiente para cada
consulta.
Todos los Vecino Cercanos
Defina al Nearest Neigbor Graph ((NNG) Graficos de vecinos mas cercanos) para
asociar un nodo con cada punto de P y un arco entre ellos si un punto es un
vecino cercano del otro. Hemos definido esto para ser un gráfico orientado,

aunque la relación no es simétrica, adecuadamente podría ser directa. Pero no

necesitaremos la versión directa aquí.
Una forma sucinta a captar la esencia del algoritmo del vecino cercano
eficiente es a través del siguiente lema.
Lema 5.5.1 NNG  D (P)
Dejo la prueba para el ejercicio 5.5.6 [2] y [3 ]
Un algoritmo de fuerza bruta para encontrar a los vecinos cercanos para cada
punto en un grupo requeriría O (n2), pero el lema de arriba nos deja registrar
solo los bordes O (n) de la triangulación de Delauny y por lo tanto logra O (n
log n).
Vecino natural: Otra forma de conseguir el valor que tendrÌa un punto

cualquier p serÌa el
de conocer todos aquellos vecinos naturales de p. Averiguar esta informaciÛn
no es m·s
que resolver el problema de los vecinos m·s cercanos a un punto utilizando el
diagrama
de Voronoi. Aplicaciones en este sentido son la identi_caciÛn de ·tomos
vecinos en el
espacio, molÈculas o partÌculas en estructuras cristalinas y amorfas, etc. Ahora
el punto
de estudio p puede estar in_uenciado por dicho conjunto de vecinos, los cuales
tambiÈn
puede llevar asociados distintos pesos de in_uencia
1.5.2 La triangulación Maximizando el Ángulo Mínimo.

Analizar las propiedades estructurales de forma complicada es a menudo

realizado por una técnica llamada “análisis finito del elemento.” Esto es usado,
por ejemplo, por fabricantes del automóvil a modelar cuerpos del coche (Field
1986). El dominio a ser estudiado está subdividido en una malla de “elementos
finitos, ” y entonces las ecuaciones diferenciales relevantes modelando la
dinámica estructural sea solucionado por discretización sobre la partición. La
estabilidad de los procedimientos numéricos usados depende de la calidad las
buenas particiones y esto pasa por que la triangulación de Delaunay son
especialmente buenas particiones. Nosotros ahora discutiremos el sentido en el
cual la triangulación Delauny es buena.
Una triangulación de un grupo de puntos S es la generalización del objeto del

cual la triangulación de Delauny es un ejemplo particular. Un grupo de
segmentos cuyos puntos finales están en S, Que sólo interseca a cada quien en
puntos finales, y cuál divide en partes el buque convexo de S en triángulos. Para
los propósitos del análisis finito del elemento, las triangulaciones con triángulos
“ gordos ” son más convenientes. Una forma para hacer esto precisa más es
evitar triángulos con ángulos pequeños. Así es natural buscar una triangulación
que tiene el ángulo menor más grande, esto es, para maximizar el ángulo de
más pequeño sobre todas las triangulaciones. ¡Esto ocurre para hacer
precisamente la triangulación de Delauny! De hecho, una declaración algo más
fuerte puede ser hecha, cuál nosotros ahora describimos después de introducir
alguna notación.
Sea T una triangulación de un grupo de puntos S, y sea su secuencia de angulos(

 1,  2, …,  3t), una lista de los ángulos de los triángulos, clasificados del
más pequeño al más grande, con t el número de triángulos en T. El número t
es uno constante para cada S (Ejercicio 5.5.6[4 ] ). Podemos definir una relación
entre dos triangulaciones del mismo grupo del punto, T y T ', eso trata de
capturar “ la gordura ” de los triángulos. Diga que T  T’ (T es más gorda que
T’) si la secuencia de ángulo de T es lexicográficamente mayor que la secuencia
de ángulo de T ': Ya sea  1 >  ’1, o  1 =  ’1 y  2 >  ’2 o  1 =  ’1 y  2=  ’2 y
 3 >  ’3,, etcétera. Edelsbrunnerr (1987, p. 302) probó este teorema:
Theorem5.5.2..La triangulación de Delaunay T=D (P) es lo máximo con

respecto a la relación de la gordura - ángulo: T  T’ para cualquier otra
triangulación T ' de P.
En particular esto dice que la triangulación Delaunay maximiza el ángulo

menor.
1.5.3 El círculo Vacío más grande
Mencionamos en sección 5.1 el problema de encontrar el círculo vacío más

grande entre un conjunto S de sitios: El centro de tal círculo es una buena
localización para una tienda nueva. Otra aplicación es mencionada por Toussaint
(1983a): Localice un reactor nuclear tan lejos de una colección de ciudades-

sitios como sea posible. Ahora examinamos problema del círculo vacío más
grande en detalle.
El problema hace sentir un poco menos alguna restricción sobre la localización

del centro del círculo, para hay siempre círculos arbitrariamente vacíos grandes
fuera de cualquier grupo de puntos finito. Así nosotros redactamos el problema
de esta forma:
El círculo Vacío más grande. Encuentre que un círculo vacío más grande cuyo
centro está en el buque convexo (cerrado) de un grupo de n sitios S, vacíos en
que no contiene sitios en su interior, y más grande que no hay otro semejante
con estrictamente radio mayor.
Sea a f (p) el radio del círculo más grande y vacío puesto en el centro en P del
punto. Entonces andamos buscando un máximo de esta función sobre toda p en
el buque de S, H=H(S). Pero hay un número aparentemente infinito de
candidatos apuntando a este máximo. Un tema común en la geometría
computacional es reducir un grupo infinito del candidato para una lista finita
pequeña, y entonces encontrar estos eficazmente. Seguimos esto en este
escenario en esta sección, comenzar por discutir informalmente que solamente
ciertos puntos p son candidatos verdaderos para un máximo de f.
Concéntrese Dentro del cierre.
Imagine inflar un círculo desde un punto p en H. El radio en el cual este circulo

golpea y por consiguiente incluye algún sitio de S = { S1, … Sn } es el valor de
f (P). asumamos temporalmente a esta subdivisión que la p es estrictamente
interior para H. Si el radio f (P), el círculo incluye justamente un sitio S1,
entonces debería ser claro que f (p) no puede ser un máximo de la función del
radio. Pues si p es movido para P ' a lo largo del rayo s1p (el rayo de s1 a través
de p) lejos de s1, entonces f (P ') es mayor, como se muestra en Figure 5.13
(los segundos pisos). Por eso la p no pudo haber sido un máximo local de f, pues
hay un punto P ' en cualquier barrio de p donde f es mayor. Nota que esa
suposición de que p es estrictamente interior para el buque garantiza que hay
una p ' como esa también en H.
Asumamos que en el radio f (P), El circulo incluye exactamente dos sitios S1 y

S2. Otra vez f (P) no puede estar en un máximo: Si la p es movida para P ' a lo
largo de la bisectriz de s1s2 (fuera de s1 s2), entonces f (P ') es otra vez mayor,
como se muestra en Figure 5.13 (baje círculos). Otra forma de ver esto por la
intersección de dos tales conos de sitios en el centro (Figure5 5.9) discutido en
la sección 4.4.4. la curva de intersección de dos conos represe la distancia de
los sitios para puntos en la bisectriz. Desde que la curva es una hipérbola
ascendente, ningún punto interior de la bisectriz es un máximo local: La distancia
aumenta de una dirección o otra.
Es única cuando el círculo incluye tres sitios que f (P) pudo estar en el máximo.
Si lo tres sitios “entrecruzados” el centro p, en el sentido que hizo girar más que

lo que un semicírculo (como en Figure 5.3), entonces el movimiento de p en

cualquier dirección resulta en moverse p más cercano para algún sitio, y así
disminuir a f (P). Nosotros ahora hemos establecido este hecho:
Lema 5.5.3 Si el centro p de un círculo vacío más grande es estrictamente

interior para el buque de la sitio H (S), entonces la p debe ser coincidente con
un vértice de Voronoi.
Note que no es necesariamente cierto que cada vértice de Voronoi represente

un máximo local de f (p) (el Ejercicio 5.5.6[5 ] ).
Centro dentro del convexo
Ahora consideremos que el circulo de centro p está en el buque H =H(S). La

razón que nuestras anteriores discusiones no ejercen es esa moviéndose p para
p ' el movimiento fuera del buque, y nuestra especificación problemática
restringieron centros para el buque. Nosotros ahora discutimos aún más
informalmente que por encima de que un círculo máximo debe incluir dos sitios.

Supongo que f (p) es un máximo con p en H y el círculo incluye justamente s1

de sitios. Primero, que no puede ser esa p está en un vértice de H, pues los
vértices de H es todos los sitios mismos, y esto implicaría a esa f (P) = 0. Así es
que p está en el interior de un borde de H. Entonces moviendo p en uno u otro
caso a lo largo de h debe aumentar su forma de distancia s1, cortado en rodajas
por un plano vertical (la Figura 5.9).
Si, sin embargo, el círculo centró en p contiene s1 de dos sitios y s2, entonces
es posible que la dirección a lo largo de la bisectriz de los sitios que aumenta
sus distancias sea la dirección que va fuera del buque. Así adecuadamente podría
ser que f (P) está en el máximo. Hemos mostrado este hecho:
Lema5.5.4 si el centro p de un circulo vació mas grande permanece en el

buque de sitios H (S), Entonces p debe permanecer sobre un borde Voronoi.

El algoritmo
Nosotros ahora hemos establecido nuestro meta: Ha encontrado un grupo finito

de punto que son centros potenciales de círculos vacíos más grandes: Los
vértices de Voronoi y las intersecciones entre bordes de Voronoi y el buque de
sitios. Esto sugiere el algoritmo 5.1, debido a Toussaint (1983a).
Note que no cualquier vértice de Voronoi está necesariamente dentro del buque
(la Figura 5.14), que necesita comprobar que v  H dentro del algoritmo. Una
implementación ingenua de este algoritmo requeriría el tiempo cuadrático en n,
pero localizar un vértice Voronoi en H e intersecar un borde de Voronoi con e
puede estar consumado en el tiempo O (log n), y estas eficiencias conducen a
un algoritmo O (n log n) en conjunto.
Dejamos Detallamos para ejercitar a 5.5.6[6.
El algoritmo: círculo Vacío MÁS GRANDE

Computar el diagrama Voronoi V (s) de la S de sitios.
Computar el buque convexo H=H (S).
Para v del vértice Voronoi haga
Si la v está dentro de H: V  H entonces
El radio de cómputo si el grupo cerrado de gente giró alrededor de
v y actualización llega al límite.
Para cada e del borde Voronoi haga
El cómputo p =e   H, la intersección del con el límite del buque.
El radio de cómputo de círculo giró alrededor de actualización de la P
llegue al límite.
El regreso llegue al límite.

Lo mínimo
que se extiende a lo largo un
árbol.
Lo mínimo que se extiende a lo

largo un árbol. (MST)(A minimum spanning tree) de un grupo de puntos es la
longitud del arbol que se extiende a lo largo de todos los puntos: es decir en
árbol más pequeño cuyos nodos son precisamente esos en el grupo. Cuando el
largo de un borde es medido por la longitud usual del segmento Euclideano
conectando sus puntos finales, el árbol es a menudo llamado el Euclideano
mínimo extendiéndose a lo largo de árbol, abreviado a EMST. Aquí sólo
considerarán las longitudes Euclideano y así también dejarán caer al modificador
redundante. Un ejemplo es mostrado en Figure 5.15. MST tienen muchas
aplicaciones. Pues el ejemplo es la topología de la red que minimiza la longitud
total del alambre que usualmente minimiza ambos costo y el tiempo que se
demora.
Algoritmo de Kruskal
Aquí consideraremos el problema de computar el MST de un grupo de puntos en

el plano. Veamos primero el problema más general de computar el MST para
una gráfica G. Aunque es de ninguna manera obvio, una estrategia ávida sin
discernimiento es encontrar al MST, basada en la intuición simple que un árbol
más pequeño debería estar cercano de los bordes más pequeños. Esto sugiere
que puede estar tal árbol construido arriba del incrementalmente añadiendo
borde más pequeño, todavía ningún explorado, lo cual también mantiene un
arbolado (alifaticidad). Este algoritmo es conocido como el algoritmo de Kruskal
y se publico en 1956.
Sea T el árbol incrementalmente construido, y sea la notación T + e quiere decir

que el árbol T une el borde e. El algoritmo Kruskal se muestra en Algoritmo 5.2.
No nos detendremos para probar este algoritmo,¿ esta bien?. pero sólo demanda
que su complejidad se domina por el primer paso ordenando. Esto requiere (E
log E) de tiempo, dónde la E es el número de bordes en la gráfica.

El algoritmo: El ALGORITMO DE KRUSKAL
Ponga en cortocircuito bordes de G por el largo por
ahí: E1, e2
Inicializar T para que este vacío
Mientras la T no avanza a rastras haga
Si T + e1 es acíclica
Entonces T + T + ei
Ii + 1
El algoritmo 5.2 el algoritmo de Kruskal.
MST  D (p)
Para el MST de puntos en el plano, hay ( n ) bordes, así es que la complejidad

2
del paso de clasificación es O (n log n) si es cargada fuera en la gráfica

2
completa. Para llamar a este registro de los bordes de la triangulación de

Delaunay de proximidad en algún sentido, es razonable esperar que sólo los
bordes de Delaunay alguna vez necesiten ser usados para construir un MST. Y
afortunadamente esto es cierto, como se muestra en el siguiente teorema.
Teorema 5.5.5 Lo mínimo que se extiende a lo largo un árbol es un

subconjunto de triangulación Delaunay: MST D (p).
Prueba. Queremos mostrar que si ab  MST, entonces ab  D. Implica that ab

 MST y suponga lo contrario que ab  MST. Entonces tratamos de derivar una
contradicción enseñando lo que se supuso MST no es mínimo.
Recuerde que si ab  D, entonces hay un círculo vacío a través de a y b

(Propiedad V7 y Teorema 5.3.1) .en caso contrario ab  D, ningún círculo a
través de a y b puede estar vacíos. En particular, el círculo de diámetro ab debe
de tener un sitio dentro de este.
Así se supone que C está en este círculo, como se muestra en figura 5.16.
Entonces
| ac | < | ab |, y |bc|< |ab|; Estas desigualdades tienen aplicación aun si C está
en el círculo, puesto que la C es distinta de a y b. La extracción de ab
desconectará el árbol en dos árboles internos, con a en primera parte, Ta, y b
en el otro, Tb. Suponga sin la pérdida de generalidad que e esta en Ta. Elimine
ab y añada el borde bc para hacer un árbol nuevo,
T’ = Ta bc +Tb. Este árbol es mas corto, así el único único usado ab, no podría
serminimo. Hemos alcanzado una contradicción negando que ab está en D, así
es que debe ser ese ab D.

Esto entonces produce una mejora en el primer paso de algoritmo de Kruskal:

Primero encuentre la triangulación de Delaunay en el tiempo O (n Long n), y
entonces clasifique sólo esos bordes O (n), en el tiempo O (n logn). Resulta lo
demás de algoritmo de Kruskal puede ser implementado para poner a funcionar
en O (n log n), para que la complejidad total por encontrar el MST para el grupo
de n untos en el plano es O (n log n).
5.5.5. El Problema del Vendedor de viajes.
Uno de los problemas más estudiados en la informática es el problema del

vendedor de viajes: Encuentre el más pequeño camino cerrado que visita cada
punto en un grupo dado. Tal camino se llamado El camino Vendedor de
viajes(TSP); imagine los puntos como ciudades que el vendedor debe visitar
en el orden arbitrario antes de devolver casa. Este problema tiene tremenda
importancia práctica, no sólo para esa aplicación si no porque muchas otras
problemáticas pueden reducirse a él. Se ha probado que desafortunadamente,
el problema es duro NP, un término técnico que ningún algoritmo polinómico
conoce para resolverlo (Garey y Johnson 1979); Ni parece probablemente al
momento de escribir la presente que a ser encontrada. Las combinaciones de
significado práctico y la inflexibilidad han conducido a una búsqueda para los
algoritmos de heurísticas efectivos y de aproximación. Uno de los algoritmos de
la aproximación más simples es basado en la triangulación de Delaunay, Vía lo
mínimo que Se extiende a lo largo el árbol.
La idea es más bien algo simple, pero no obstante hace un trabajo razonable.
Encuentra al MST para el grupo de puntos, y simplemente lo lleva cabo y lo allá
por la manera ilustrada en Figure 5.17. Debería estar claro que la excursión
construida por aquí tiene exactamente dos veces el largo del MST, desde que
cada borde del árbol se cruza una vez en cada dirección.

Ahora obtenemos un límite dentrote que esta mal este doble-MST recorrido
podría ser. Sea M la longitud de Lo mínimo que se extiende a lo largo un
árbol y M2 la longitud de a doble-MST; claro M2 = 2M. Sea T la longitud de
El camino de un Vendedor de viajes r y T1 la longitud de un TSP con un
borde removido. Note que T1 se extiende a lo largo del árbol.
Las siguientes desigualidades son inmediatas:
T1 < T,
M  T1,
M < T,
M2 < 2T.
Esto entones logra un límite superior constante en la calidad del recorrido: Lo

doble-MST no está peor que dos veces la longitud de TSP.

Este resultado puede ser mejorado con heurísticas diversas. Esbozaré sólo el
más simple tan heurístico, lo cual se basa en la determinación comprensible para
no volver a visitar un sitio dos veces. El recorrido del camino doble-MST de
entrada, con la modificación que si el próximo sitio ya se ha visitado hasta ahora
por el camino, salte el sitio y considera conectarse al próximo uno a lo largo del
doble-MST recorrido. Esto hace el efecto de tomar una ruta más directa para
recorrer MST . Si ponemos en un índice los sitios por el orden en que ellos se
visitan a lo largo del recorrido del MST, a algunos sitios que Si podría conectar
para Sj por un segmento de la línea recta o un atajo al recorrido, considerando
que el recorrido doble-MST sigue un camino encorvado Si, Si+1 , …, Sj-1,Sj..
Heurístico puede ser único acorta el camino. Un ejemplo es mostrado 5.18. Note
que el camino fue acortado.
Desafortunadamente este heuristico no garantiza un desempeño mejorado, pero

una variación leve Conocido como las gamas “Heurísticas Christofides”. Usa un
grupo de segmentos llamados un “El mínimo de Euclideano emparejando” como
un guía para atajos y puede garantizar un longitud del camino no más de (3/2)
T, eso es, no más de 50 % más largo que lo óptimo. Más heurísticos sofisticaron
generalmente encuentran un camino dentro de un poco porcentaje óptimo
(Bentley 1992), aunque este desempeño no está garantizado en su estado actual
para el algoritmo citado anteriormente. Un resiente descanso teórico es sin
dudarlo el esquema de aproximación de Polinomio-tiempo para el TSP, acerca
de lo mejor, puede ser esperanza para un problema completo a NP. Éste es un
método de llegar dentro (1 +  ) de optativo para cualquier  > 0, en un tiempo
O (np), dónde la p son proporcionales para 1/  . Vea a Arora (1996) y Mitchell
(1996).
5.5.6 Los ejercicios
1. El grado de NING. ¿Cuál es grado mínimo de salida de un nodo de un Grafico

de vecino mas cercano(NING) (la Sección 5.5.1) de n puntos en dos 2
dimensiones? ¿Cuál es el grado máximo de un nodo? Demuestran ejemplos que
justifiquen su respuesta, e intento probar que son máximos.
2. NNG y D [Fácil] . Encuentran un ejemplos que muestre ese NNG pueden ser
un subconjunto correcto de D (p).
3. NND D. Ponga a prueba a Lema5.5.1: Si la b es una vecina próxima de a.

Entonces ab D (p).
4. Los Números de triángulos en una estrangulación. Comprobar que el número

de triángulos t en cualquier triangulación de algún grupo de puntos reparados
S esat una constante toda triangulación de S tiene la misma t.
5. El vértice de Voronoi no un máximo local. Construya un grupo de puntos que

tiene un vértice de Voronoi estrictamente p dentro del buque, algo semejante

que f (p) no es un máximo local, donde la f es función del radio definido en la

sección 5.5.3
6. El algoritmo del círculo vacío. El detalle (en el código pseudo) cómo llevar a
cabo el algoritmo del círculo vacío (Algoritmo 5.1) con el fin de que su
complejidad de tiempo es O (n log n).
7. El Gráfico del Barrio relativo (RNG) de juego de puntos P1,…, Pn es un gráfico

cuyos nodos corresponden a los puntos, y con Pi de dos nodos y Pj conectado
por un arco ellos son para que no acerca de cualquier otro punto, eso es, si
|Pi + Pj|  max { | Pi + Pm |,| Pi + Pm | }.

m i . j
(Vea Jaromezyk + y Toussaint (1992).) Esta ecuación determina una región “

prohibida ” dentro de la cual ningún punto Pm puede mentir si Pi y Pj son
adyacentes en el RNG, no a diferencia del Teorema 5.3.1 Esta región, llamada
Lune ( Pi, Pj), son la intersección de dos discos abiertos centradas en Pi y Pj,
ambos de radio | Pi – Pj |.
a. Diseñe un algoritmo “de fuerza bruta” para construir al RNG. No se

preocupe por eficiencia. ¿Qué es su complejidad de tiempo?
b. Ponga a prueba a ese RNG: Cada borde del RNG es también borde de la
triangulación de Delauny. (Compárese con Teorema 5.5.5).
c. Use (b) diseñar un algoritmo más rápido.
8. El tamaño de triangulación de Delaunay en tres dimensiones. Tenemos que

mostrar cual es el tamaño de la triangulación de Delaunay adentro de dos
dimensiones es lineal, O (n). Mostrar que esto no se mantiene en tres
dimensiones: El tamaño de D (p) puede ser cuadrático. Defina a D (p) en tres
dimensiones exactamente, análogamente y para la versión de Dos dimensiones
(bidimensional): Es el dual de V (p), el cual es el lugar de puntos geométricos
que no tienen un único vecino cercano.
Sea P un punto determinada consistente en dos partes:
a El n/2 puntos uniformemente distribuidos alrededor de un círculo en el

plano x y centrados en el origen, y
b El n/2 puntos uniformemente distribuidos en el origen del eje z
simétrico al origen..
Sostenga la opinión que el tamaño de D (p) es  (n2).

9. El tamaño del gráfico del barrio relativo (RNG) en dimensiones del árbol.
Ejercicio[7] anteriormente establecido ese RNG D (P) en dos dimensiones, y esta
relación contiene dimensiones arbitrarias. Se ha demostrado el tamaño que
tiene el RNG en dimensiones del árbol es O (n3/2) (Jaromezyk y Toussaint
1992), así es que es más pequeña que la triangulación de Delaunay. Pero parece
que este salto superior es débil: Jaromezyk y Kowaluk (1991) suponen que el
tamaño es O (n). Confirmar esta conjetura es un problema.
10. MST  RNG Pruebe que cada borde de un MST es un borde del RNG.
(Compárese con Teorema 5.5.5)
11. Los puntos más remotos de Voronoi. Defina el diagrama de puntos más
remotos de Voronoi F (P) asociado cada punto del plano para el sitio que es su
“vecino más remoto”, el sitio que está más lejos (fuera). Los puntos con el vecino
mas cercano de una region de voronoi mas remota; Los puntos con dos vecinos
mas lejanos limitan con forma de bordes F (P). Vea Figura 5.19.
a. Que es F (P) para dos sitios?

b. ¿Cuál es F (P) para tres sitios?
c. Derive algunas propiedades estructurales de diagrama más remoto

Voronoi, parecido al Delaunay y Voronoi en Sección 5.3.1 y 5.3.2. Uso Figure
5.19 y 5 5.2.3. Uso 5.19 para ayudar a formar a hipótesis

12. L Mínimo que se expande a lo largo de un Círculo. Muestre cómo el círculo

más remoto del radio – el diagrama del punto de Voronoi puede usarse para
computar lo más pequeño – que rodea un grupo dado del punto. Asuma que F
(P) está disponible.
Ejes Medios
El diagrama de Voronoi puede ser generalizado en varias direcciones, y

algunas de estas generalizaciones tienen importante significado práctico. En esta
sección tocamos una generalización, una de las más simples: aceptando un
grupo de sitios que son un grupo infinitos de puntos, en particular el límite
continúo de un polígono.
En la sección 5.20 definimos el diagrama de Voronoi como el grupo de

puntos cuyo sitio más cercano no es único. Estos puntos son equidistantemente
mejor cerrados en dos o más sitios. Define los ejes medios de un polígono P,
que están dentro de un grupo de puntos internos P que un punto bien cerrado
entre los puntos de  P. Una definición muy similar puede ser usada para una
colección de puntos arbitrarios, pero aquí examinaremos solo el caso donde los
puntos forman el límite de un polígono.
El eje medio de un rectángulo se muestra en la figura 5.20; cada punto

sobre el segmento horizontal dentro del rectángulo está equidistante de los
puntos verticales de arriba abajo y están por encima y por debajo de los lados
del rectángulo. Cada punto sobre un segmento diagonal esta equidistante de dos
lados adyacentes del rectángulo y los dos puntos finales del segmento horizontal
están equidistante de tres lados del rectángulo.

Un ejemplo mas completo se muestra en la figura 5.21, ocho vértices en

un polígono convexo. Uno puede suponer a partir de este ejemplo que el eje
medio del polígono convexo P está un árbol cuyos permisos son los ejes de P.
Esto es un porcentaje verdadero y está realmente lleno de polígonos no
convexos. Todo punto de los ejes medios está en el centro de un circulo que toca
el límite de los puntos más lejanos y así es como los vértices de Voronoi están
en los centros de los círculos tocando tres sitios, los vértices de los ejes medios
están en el centro de los círculos tocando tres puntos distintos del limite como
se muestra en la figura 5.22.
A veces los ejes medios de P están definidos como el sitio central de los
círculos máximos: los círculos dentro de P estos no son los mismos encerrados
en algunos otros sitos dentro de P. El proceso de transformación dentro de los
ejes medios son en ocasiones llamados “Transformación de Bosques Quemados”
por si una imagen del polígono P tal como un césped seco que alumbra con un
fuego a los bordes de P, todo esto causará que queme todo dentro de el a una
velocidad uniforme y los ejes medios sean el grupo de puntos extintos donde el
fuego conozca al fuego de otra dirección. La conexión entre esta analogía y la
quema del bosque discutido en la sección 5.1 debería ser evidente.
Los ejes medios fueron introducidos por Blum en 1967 para el estudio en
forma biológica, el observo de manera semejante a un esqueleto (eje) las
amenazas bajo el medio (mediana) de alguna forma. Esta es menos aparente
para un polígono convexo que para un no convexo y formas planas que era el
principal interés de Blum, uno puede caracterizar la forma de cierta sección de
la estructura de estos ejes medios y esto va incluido un interés considerable
entre los investigadores en el reconocimiento de patrones y visiones de
computadoras, por ejemplo bookstein lo usa para caracterizar las diferencias
entre los huesos de la mandíbula normales y los deformados. Puede ser usada
para calcular una compensación interior de un polígono, todos de cuyas fronteras
son compensaciones interiores por una distancia fija. Expandidas o externas
compensaciones cuentan en la versión exterior del eje medio. Calcular
compensaciones es un importante problema en la manufacturación, donde la
tolerancia de ingeniería es llevada naturalmente a formas de compensación.

El eje medio de un polígono de n vértices puede ser construido en 0 (n

log n) time; asintoticamente menor pero más prácticos de logaritmos están
disponibles. Para polígonos convexos, 0 (n) veces es suficiente.
Ejercicios
 Eje medio de un polígono no convexo. Mostrar por ejemplo que el eje

medio de un polígono no convexo puede contener segmentos curvados.
¿Qué puedes decir acerca de la forma funcional de estas curvas?

 Eje medio y el diagrama de Voronoi o hay alguna relación entre el eje

medio de un polígono convexo P y el diagrama de Voronoi de los vectores
de P? Supone algunos aspectos de esta relación y pruébalos y construye
contra ejemplos.
Eje medio de un polígono. Describe lo que debe parecer el eje medio de un

polígono.
Estructura recta. Aichholzer, Alberts, Aurenhammer & Gärtner, introdujo

una estructura que es similar al eje medio, pero compuesta de segmentos rectos
incluso para polígonos no convexos. Mover cada borde de un paralelo al mismo
interior a una velocidad constante con bordes adyacentes encogiendo y
creciendo así que los vértices viajan a lo largo del ángulo bisector. Cuando un
borde se encoge hasta la longitud cero, sus bordes vecinos se hacen adyacentes.
Cuando un vértice reflejo choca hacia adentro de un borde, el poligono se agrieta
y el proceso de encogimiento de las piezas continúa.
Trabaja manualmente la estructura recta con unas formas letras

conectadas del alfabeto: T, E, X. Forma algunas suposiciones acerca de las
propiedades de la estructura recta.
Conexión con el Convexo Hulls
El 1986 Ellels Brunner & Seidel decubrió una bella conexión entre la
triangulación de Delaunay y el convex hulls en una de las más altas dimensiones:
primero explicaré entre el convex hull bidimensional y la triangulación
unidimensional de Delaunay (que son admitimademente triviales) y entonces
generaliza la triangulación bidimensional de Delaunay y el tridimensional convex
hull.
Entonces esta conexión nos dará un método fácil para calcular la

triangulación de Delaunay y del diagrama de Voronoi, vía tridimensional hulls
triangulación unidimensional de Delaunay. Empezaremos en una dimensión
donde la matemática es transparente sea
P= {x1,…,xn} un conjunto de puntos sobre el eje x. Claramente la triangulación
unidimensional de Delaunay es simple el camino conecta x1 a x2 a… xn , pero
veremos que esto es una proyección sobre el eje x de un conjunto de puntos
bidimensionales con coordenadas (xi, x2i). Estos puntos pueden ser vistos como
una proyección de la ascendencia de x en la parábola z= x2. Es trivialmente
verdadero que el connuex hull de estos puntos bidimensionales proyectado hacia
abajo a la triangulación unidimensional de Delaunay, tanto como el borde más
alto del hull es descartado, pero hay mucho más aquí que esta observación trivial
que puede ser aclarada con la consideración de las tangentes a la parábola.

La pendiente de la parábola z= x2 en el punto x= a es 2a (porque dz/dx=

2x). De esta manera la ecuación de la tangente a la parábola en el punto (a, a2)
es
z-a2= 2a (x-a)
z= 2a x-a2
En preparación para estudiar el mismo proceso en tres dimensiones, ahora

investigaremos la intersección entre esta tangente y la parábola cuando la
tangente es trasladada verticalmente una distancia r2. Cuando la tangente es
aumentada por esta cantidad su ecuación se convierte en
z=2a x-a2 + r2
Entonces la tangente aumentada intersecta la parábola en + r lejos de a,

el punto original de tangencia. Nota que x= a + r puede ser pensado como la
ecuación de un circulo unidimensional de radio r centrado en a. Esto es ilustrado
en la figura 5.23 con a= 5 y r= 3 así que el disco es el segmento [2,8].
Triangulación Bidimensional de Delaunay
Repetimos el mismo análisis en dos dimensiones.
El paraboloide es z= x2 + y2, (Ver la figura 5.24) toma los sitios/puntos

dados en el plano y los proyecta hacia arriba hasta que toca el paraboloide, eso
es, trazar cada punto como sigue:
(xi, yi) | (xi, yi, x2i + y2i)
Toma el convex hull de este conjunto de puntos tridimensionales, ver la

figura 5.25. Ahora descarta las caras más altas de este hull. Todas esas caras

que son exteriores punteando los puntos superiores normales, en el sentido de

times un producto positivo el resultado es una “condra” más baja. Proyectar esto
al plano xy. El reclamo es que esta es una triangulacion de Delaunay. Ver la
figura 5.26. Ahora establecemos esta fenomenal conexión formalmente. La
ecuación del plano tangente encima del punto (a, b) es
z=2a x + 2b y – (a2 + b2)

(Esta es una analogía directa a la ecuación z= 2a x – a2: dz/dx= 2x and
dz/dy= 2y)
Ahora cambiamos este plano superior por r2, exactamente como

cambiamos la línea tangente en la subsección previa
z= 2a x +2b y – (a2 + b2)+ r2

(x-a)2 + (y-b2)= r2

El plano cambiado intercepta el paraboloide en una curva (una elipse) que

proyecta a un círculo. Esto es ilustrado en la figura 5.27 y 5.28.
Ahora revisemos desde un punto de vista para dirigirnos s la triangulación

Delaunay. Considere el plano  a través de tres puntos en el paraboloide  = (
pi, pj, pk) que forma una cara del buque de convexo en tres dimensiones. Este
plano parte de la paraboloide. Si traducimos verticalmente hacia abajo, entonces
en algún punto cesará de intersecar el paraboloide. Digamos que el último punto
que toca es (a, b, a2 b2). Entonces podemos observar como un cambio
ascendente de este plano contiguo; Llame a la cantidad de cambio r2. Ahora
debería estar claro que el análisis previo tiene aplicaciones.
Desde  esta en una cara inferior del buque, todo las otras puntos del
paraboloide están arriba. Desde que están arriba  , están más que el r2 arriba,
cuál es el r2 debajo. Por eso estos puntos se proyectan fuera del círculo de radio
r en el plano x y. Por eso el círculo determinado adentro de los planos x y está
vacío en todos los otros sitios. Por eso forma un triángulo Delaunay. Por eso
cada cara triangular inferior del buque convexo es propia de un triángulo
Delaunay. ¡Por eso la proyección del “fondo” del buque convexo se proyecta para
la triangulación Delaunay! Otra vez evacue a Figure 5.26.
Déjeme explicar esta compenetración importante otra vez de otra manera.

Comience con el plano t contiguo para el paraboloide por encima de p = (a, b).
Su punto de contacto se proyecta hacia abajo para p. Ahora muévase t arriba.
La proyección de su intersección con el paraboloide es un círculo en expansión
puesto en el centro en p. Cuando los t golpes una punto q en el paraboloide que
esta por encima de un sitio, las intercepciones del círculo en expansión en el
sitio en el plano que es la proyección de q. Así el círculo está vacío t hasta  los
límites exteriores, cuándo atraviese los tres sitios cuya proyección forma la cara
 del buque del triángulo soportada por  .

Un corolario útil para el debate citado anteriormente es éste:
Corolario 5.7.1 Cuatro puntos (xi, yi), i = 1, 2, 3, 4, consisten en una mentira

del círculo si (xi, yi, xi2 yi2) en un plano.
La coplanaridad de estas puntos puede ser comprobada viendo si el volumen

del tetraedro que determinan (la Ecuación 1.15 y 4.6) es cero.
La implicación
Teorema 5.7.2 La triangulación de Delaunay de un grupo de puntos en dos

dimensiones es precisamente la proyección para el Plano x y del buque
convexo inferior de lo transformado apunta en tres dimensiones, transformado
por mapeo arriba para el paraboloide z = x2 y2.
Desde que el buque convexo en tres dimensiones puede ser computado en el

tiempo O (la Sección 4.2.2) (n log n), esto significa que la triangulación de
Delaunay puede ser computada en el mismo tiempo límite. Una vez que la
triangulación Delaunay está en tus manos, es relativamente fácil computar el
diagrama Voronoi (el Ejercicio 5.7.5[2 ] ). Esto conduce a otro algoritmo O (n
log n) para construir el diagrama de Voronoi.
Como se podría esperar, esta relación entre diagramas Voronoi y podría

abombar buques que yo una dimensión más alta mantengo en dimensiones
arbitrarias. Así ambos el diagrama Voronoi y la triangulación Delaunay en tres
dimensiones pueden forjarse de un buque convexo en cuatro dimensiones. De
hecho, puede ser que el más uso común de código del buque del 4D es para
construir mallas sólidas de Delaunay tetraédrico. En general, el diagrama de
Voronoi dual para un grupo de puntos de d-dimensional es la proyección del
buque “ inferior ” de puntos en d + 1 dimensión.
La implementación de la Triangulación de Delaunay: El código O (n4)
Teorema 5.7.2 el código conciso permite increíblemente computar la

triangulación de Delaunay, si uno es indiferente sobre la complejidad de tiempo
¡En particular, si O (n4) es aceptable (y raramente lo es), entonces la
triangulación de Delaunay puede ser computada con menos esas treinta líneas
de código de la C! Esto es presentado en código 5.1 en parte como la curiosidad,
pero también a enfatiza cómo la comprensión profunda de geometría puede
conducir al código limpio.
main()
{

int x[MAX],y[MAX],z[MAX]; /*Intreda de puntos x,y,z*/

int n; /*Numero dep puntos introducidos*/
int i,j,k,m; /*induce de cuatro puntos*/
int flag; /*localizacion normal de (i,j,k)*/
/*Intrda de puntos y computar z=x^2+y^2*/
scanf("%d",&n);
for(i=0; i<n; i++)
{
scanf("%d %d",&x[i],&y[i]);
z[i]=x[i]*x[i]+y[i]*y[i];
}
/*por cada tres (i,j,k)*/

for(i=0;i<=n-2;i++)
for(j=0;j<=n-2;j++)
for(k=0;k<=n-2;k++)
if(j!=k)
/*computar la triangulacion normal*/
xn=(y[j]-y[i]*z[k]-z[i])-(y[k]-y[i]*z[j]-a[i]);
yn=(x[k]-x[i]*z[j]-z[u])-(x[j]-x[i]*z[k]-z[i]);
zn=(x[j]-x[i]*y[k]-y[i])-(x[k]-x[i]*y[j]-y[i]);
/*solo examina las caras del boton de la paraboloide zn <0*/

if(flag==(zn<0))
/*para otro punto m*/
for(m=0;m<n;m++)
{
/*revizar si m se acerca (i,j,k)*/
flag=flag&&
((x[m]-x[i]*xn+
(y[m]-y[i]*yn+
(z[m]-z[i]*zn<=0;
if(flag)
printf("%d\t%d\t%d\n",i,j,k);+
}
La estructura O (n4) del código es evidente yo los cuatro de para lazos anidados.
Para cada triple de puntos (i, j, k), el programa revisa y ve si todos los otros
puntos m están o por encima del plano conteniendo i, j, y k. Si es así, (i, j, k)
es salida como triángulo Delaunay. (La símil arridad para el algoritmo del buque
de dos dimensiones en Algoritmo 3.2 debería ser evidente).

Triang. de Delaunay dual.
La prueba de por encima de plano es realizada chocheando la orientación

exterior normal para el triángulo, (xn, yn, zn), con un vector de punto para
apuntar m.
Aunque es interesante para ver tal código sucinto computar un propósito guste
la triangulación Delaunay, es impráctica para varias razones:
1. El código devuelve todos los triángulos dentro de una cara de

triangulación Delaunay cuyo límite consta de cuatro o más puntos del
cocircular. Así una mueca cuadrada resulta en salida cuatro de triángulo,
representando las dos triangulaciones del cuadrado. Obtener más salida útil
requeriría el postprocesamiento.
2. Hay ineficiencias obvias en el código (por ejemplo, la m-loop podría

quebrarse cuando un punto es descubierto debajo del plano del I, j, k). Estos
podrían repararse fácilmente al precio de alargarle un poco, pero…
3. La dependencia de tiempo del n4 es inaceptable. Pues dos prueban

carreras con n = 100 y n = 200 puntos, el tiempo de computar fue 12 y
239 segundos respectivamente, exhibiendo un más de 24 incremento de
16 pliegues para el doble número de puntos. Esto indica 1,000 tan n
tomaba varios días.
Triangulación de Delaunay 3D cáscara: O (el n2) el Código
Es una tarea fácil convertir el código cuadrático desarrollado en Capítulo 4

para construir el buque del 3D en el código cuadrático para construir la
triangulación Delaunay. Toda la complejidad está en el código del buque
(código de casi 1,000 líneas de ) acerca del razonamiento que entró en
Teorema 5.7.2. Las modificaciones adicionales son relativamente menores.

Primer, que la rutina ReadVertices (código 4.10) debería leer en x, y y

computar z= x2 +y2. En segundo lugar, después del buque entero se forja,
un procedimiento LowerFaces se siente llamado al lazo sobre todas las fases
e identifique cuáles es en la carena (código 5.2). Como en código secreto
5.1, este está consumado computando las coordenadas de la z de un vector
normal para cada f de la cara. Esta computar, encarnado en Normz, es
justamente un cambio leve para Collinear (Código 4.12). Si Normz (f) < z,
entonces la cara está en la carena, y su proyección encima del Plano x y es
un triángulo de Delaunay.
Ilustramos con un ejemplo de n = 10 puntos cuyas coordenadas son

ostentadas en la tabla 5.1. Note que las coordenadas de la z son infundidas
arriba en la magnitud cuadrando. Esta parte pequeña que el ejemplo detiene
adecuadamente dentro del rango seguro de la computar de volumen discutió
comparación para el código del buque del 3D. La salida Postscript del código
es mostrada en Figure 5.29.
Como esperada, esta implementación O (n2) es mucho más rápida que el

código O (n4): En la misma n = 100 y n = 200 ejemplos que mientras código
más lento usó 12 y 239 segundos, el código más rápido usaron 0.2 y 1.3
segundos respectivamente. Además, la aceleración del randomizadas discutió
en Sección 4.5 vueltas así de en una O (n log n) esperado algoritmo de
tiempo.
5.7.5 Ejercicio 1.
El rango de dt2.c [programación] . Encuentro un grupo del punto cuyas

coordenadas son tan pequeñas como sea posible, y para las cuales el código
del dt2.c (código 5.2) devuelve un resultado incorrecto debido al
derramamiento del cálculo de volumen.
void LowerFaces(void)
{
tFace f=faces;
int Flower=0; /*numero total*/
do{
if(Normz(f)<0){
Flower++;
f->vertex[0]->Vnum,
f->vertex[1]->Vnum,
f->vertex[2]->Vnum);
}
f=f->next;
}while(f!=faces);
printf("%d lower faces identificada\n",Flower);
}

int Normz (tFaces f)

{
tvertex a, b, c;
a=f->vertex[0];
b=f->vertex[1];
c=f->vertex[2];
return
(b->v[x]-a->v[x])*(c->v[x]-a->v[y])-
(b->v[y]-a->v[y])-(c->v[x]-a->v[x]);
}
2. D à V (P) (P) [programación] . Modifique el código del dt2.c para computar

el diagrama de Voronoi de la triangulación de Delaunay. (Vea ejercicio 5.5.6
[1]). Hay que repetidamente construir círculos a través de tres puntos dadas
a, b, c. Las coordenadas de la p central = (p0, p1) pueden ser computadas
como sigue:
A = b0 – a0,
B= b1 – a1,
C = c0 – a0,
D = c1 – a1,
E = A(a0 + b0 ) + B(a1 + b1 ),
F = C(a0 + b0 ) + D(a1 + b1 ),
G = 2(A(c1 – b1 ) – B(c0 – b0 )),
p0 = (DE – BF)/G,
p1 = (AF – CE)/G.
Tabla 5.1 Coordenadas de sitios de Delaunay, Incluyendo z= x2 +y2
I X Y X2+y2
0 31 -76 6737
1 -13 21 610
2 -63 -83 10858
3 -5 -66 4381
4 87 -94 16405
5 40 71 6641
6 23 -46 2645
7 64 -80 10496
8 0 -57 3249

9 -14 2 200
5.8 Conexión a arreglos
Tenemos que mostrar que la triangulación de Delaunay puede ser derivada de

la transformación paraboloide e indican que es fácil de obtener el diagrama de
Voronoi si es posible obtener el diagrama de Voronoi directamente de la
transformación del paraboloide. Aunque todo esto se entiende que tienes que
esperar al siguiente capitulo (Sección 6.7) y mostraremos la conexión que se
realiza utilizando las ecuaciones mas relevante.
5.8.1 Diagrama de Voronoi unidimensional

Considerando dos tangentes examinadas en la sección 5.7.1 (ecuación 5.4)
siendo x=a y otro siendo x=b:
z=2ax-a2
z=2bx – b2
Donde se intersecan resolviendo las ecuaciones simultáneas la solución sería
2ax-a2 = 2bx – b2,

x(2a – 2b)=a2 – b2,
x=(a+b)(a-b)
2(a-b)
x= a+b
2
De esta manera la proyección de las intersecciones están adyacentes al
diagrama de Voronoi y al grupo de puntos

5.8.2 Diagrama de Voronoi bidimensinal

Considere dos tangentes planas del paraboloide analizado en la Seccion (5.7.2)
(ecuación 5.8), donde estan a y b y otra donde esta c y b.
z = 2ax + 2by – a2 + b 2,
z = 2cx + 2dy – c2 + d2
¿donde están los intersectos? Resolviendo la ecuación simultanea

2ax + 2by – a2 + b 2 = 2cx + 2dy – c2 + d2
x(2a – 2c) + y(2b – 2d) = ( a2 - c 2) + (a2 + b 2 )
Esta ecuación es precisamente la bisectriz perpendicular del segmento de (a,b)

y (c,d) ver figura 5.31.
Si observamos las tangentes opacas planas de z=+infinito (con el paraboloide

transparente) debería ser visible en la primera intersección su primera
intersección es la bisectriz entre los lugares que generan las tangentes planas
la proyección de estas primeras tangentes es precisamente el diagrama de
voronoi!
También tenemos que recordar la situación al visualizar la proyección de
puntos dentro del paraboloide de z=-infinito vea la triangulación de Delaunay
la observación de las tangentes planas del paraboloide y estos puntos de
z=+infinito vea el diagrama de Voronoi.

Bibliografía
[1] M. Berg, M. Kreveld, M. Overmars, O. Schwarzkopf. Computational
Geometry, Algorithms
and Applications. Springer, 1997.
[2] M. Kreveld, J. Nievergelt, T. Roos, P. Widmayer. Algorithmic Foundations of
Geographic
Information Systems. Springer, 1997.
[3] J. O'Rourke. Computational Geometry in C. Cambridge University Press,
1994.
[4] F. P. Preparata y M. I. Shamos. Computational geometry: an introduction.
Springer-Verlag,
New York, 1985.
73

Graficos de C

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Graficos de C

Uploaded by

Copyright:

Available Formats

Bismarck Salvador Traña López__________________________________________UNI

Introducción a la Programación grafica en C.

1. Especificar el fichero o librería graphics.h

2. Inicializar el modo grafico correspondiente mediante la Función initgraph;

Initgraph(&adaptador,&modo,”dirección de los archivos bgi”);

3. Crear y manipular las figuras graficas.

/*Desarrollo del programa*/

4. Restaurar el modo de video antes de salir del programa(restaurar el modo texto)

Juan Carlos Gutiérrez Barquero____________________________________________ 1

Arc getmaxy putimage

Es necesario conocer hacerca de los macros y estructuras, entre las estructuras

arccoordstype linesettingstype textsettingstype

Entre los macros se encuentran:

colores errores modos

Juan Carlos Gutiérrez Barquero____________________________________________ 2

Constante Valor Significado

Constante Valor Significado

Juan Carlos Gutiérrez Barquero____________________________________________ 3

Color del modo CGA

Número Paleta Color 1 Significado Color 2 Significado Color 3 Significado

0 CGA_LIGHT Verde Claro CGA_LIGHTRED Rojo Claro CGA_YELLOW Amarillo

Colores para las paletas.

Constante (CGA) Valor Constante (EGA/VGA) Valor

Juan Carlos Gutiérrez Barquero____________________________________________ 4

Constante Valor Valor

Dirección del Texto

Constante Valor Significado

VERT_DIR 1 Texto vertical

Justificación de Texto en la Horizontal

Constante Valor Significado

Justificación de Texto en la Vertical

Constante Valor Significado

TOP_TEXT 2 Justificar arriba

Juan Carlos Gutiérrez Barquero____________________________________________ 5

Constante Valor Significado

Constante Valor Significado

Nota: El grosor es definido escribiendo NORM_WIDTH para rallas normales y

Juan Carlos Gutiérrez Barquero____________________________________________ 6

Grosores para Líneas Modos de Escritura

Constante Grosor Valor Significado Constantes Valor Significado

Dispositivo Modo/Constante Código Resolución Paleta Pagina

Si la tarjeta es de 64 K o la tarjeta es de 256 K

Juan Carlos Gutiérrez Barquero____________________________________________ 7

Constante Código Significado

Constante Valor Significado

Nota: Estas operaciones se usan exclusivamente con la función putimage. El cual

Juan Carlos Gutiérrez Barquero____________________________________________ 8

Métodos de Inicialización del modo grafico.

Juan Carlos Gutiérrez Barquero____________________________________________ 9

1. Método de inicialización del modo grafico a prueba de errores.

2. Método de inicialización rápido del modo grafico.

driver: Es la dirección de la variable que contiene el código del tipo de de driver o

c:\\tc20\\bin: Es el directorio donde se encuentra el código del manejador, puede ser

graphresult():Regresa el código error de la ultima llamada a una función grafica de turbo

grOk : regresa el código de error de la función graphresult().

Juan Carlos Gutiérrez Barquero____________________________________________ 10

¿Qué son los primitivos gráficos…?

Un primitivo gráfico es un elemento fundamental de dibujo en un paquete grafico tal como

 Figuras geométricas: Dibujan las figuras de la geometría clásica: líneas,

 Relleno: tiene dos formas de realizarse. El primero es con polígonos, donde se

 Gráficas Matemáticas: Dibujan los primitivos barras y sectores para conseguir

La función line() no retorna ningún valor.

Juan Carlos Gutiérrez Barquero____________________________________________ 11

/Desarrollo del programa/