Linea

2015
TEXTO GUÍÍA RECOPÍLADO:
Programacioó n Graó fica
Sistemas e Informatica - F.N.I.

Juan Gregorio Choque Uño
20/01/2015
1
2
Contenido
INTRODUCCION A GRAFICAS POR COMPUTADORA....................................10
INTRODUCCION.................................................................................................................. 10
APUNTES DE LA HISTORIA................................................................................................... 11
APLICACIONES..................................................................................................................... 15
Entretenimiento.......................................................................................................................15
Diseño asistido por computador..............................................................................................16
Visualización cientifíca y médica..............................................................................................18
Simulación y entrenamiento....................................................................................................19
Gráficos de presentación.........................................................................................................20
Creaciones artísticas.................................................................................................................21
TECNOLOGÍAS DE SALIDA.................................................................................................... 22
Tecnología de Salida: Vectorial.................................................................................................22
Tecnología de Salida: Raster-Scan............................................................................................24
EL PROCESO DE OBTENCIÓN DE IMÁGENES..........................................................................27

P.O.I. Recorrido de la Escena....................................................................................................28
P.O.I. Transformación del Modelo............................................................................................29
P.O.I. Transformación de la Vista..............................................................................................29
P.O.I. Recortado........................................................................................................................30
P.O.I. Eliminación de Caras Ocultas..........................................................................................30
P.O.I. Proyección.......................................................................................................................31
P.O.I. Transformación del Dispositivo.......................................................................................32
P.O.I. Conversión al Raster........................................................................................................33
P.O.I. Iluminación......................................................................................................................33
P.O.I. Otras Operaciones...........................................................................................................34
PRIMITIVAS - RENDERING.................................................................................. 39
3
INTRODUCCIÓN.................................................................................................................. 39
PRIMITIVAS GRAFICAS......................................................................................................... 41
ESPECIFICACIÓN DE UNA DISCRETIZACION...........................................................................42
DIBUJO DE LÍNEAS RECTAS................................................................................................... 42

EL ALGORITMO MÁS SENCILLO................................................................................................44
ALGORITMO BÁSICO INCREMENTAL DDA................................................................................46
ALGORITMO DE BRESENHAM..................................................................................................50
ALGORITMO DEL PUNTO MEDIO.............................................................................................57
ALGORITMOS BASICOS PARA CIRCULOS...............................................................................62

ALGORITMO BÁSICO (COORDENADAS CARTESIANAS)............................................................62
COORDENADAS POLARES.........................................................................................................64
SIMETRÍA DE 8 LADOS..............................................................................................................66
ALGORITMOS PARA ELIPSES................................................................................................ 74

ALGORITMO BASICO (Coordenadas Cartesianas)....................................................................75
ALGORITMO BASICO (Coordenadas Polares)...........................................................................76
TRANSFORMACIONES GEOMETRICAS EN 2-D..............................................82
QUE ES UNA TRANSFORMACION?.......................................................................................82
TRANSFORMACION EN 2D................................................................................................... 83
TRASLACION.............................................................................................................................83
ESCALAMIENTO........................................................................................................................85
ROTACION.................................................................................................................................87
COORDENADAS HOMOGENEAS........................................................................................... 89
REPRESENTACION EN COORD. HOMOGENEAS........................................................................91
COMPOSICION DE TRANSFORMACIONES.............................................................................95
4
OTRAS TRANSFORMACIONES..............................................................................................96
TRANSFORMACIÓN VENTANA-ÁREA DE VISTA...................................................................100
VISION TRIDIMENSIONAL................................................................................ 108
COORDENADAS HOMOGENEAS......................................................................................... 108
SISTEMA DE LA MANO DERECHA.......................................................................................109
SISTEMA DE LA MANO IZQUIERDA.....................................................................................110
TRANSFORMACIONES EN 3D............................................................................................. 110

TRASLACIÓN DE UN CUERPO.................................................................................................110
ESCALACIÓN DE UN CUERPO.................................................................................................112
ROTACIÓN SOBRE UN EJE COORDENADO..............................................................................113
ROTACIÓN RESPECTO DEL EJE X.........................................................................................114
ROTACIÓN RESPECTO DEL EJE Y.........................................................................................116
ROTACIÓN RESPECTO DEL EJE Z.........................................................................................117
COMPOSICION DE TRANSFORMACIONES EN 3D.................................................................118
PROYECCIONES.................................................................................................... 121
QUE ES UNA PROYECCION?............................................................................................... 121
PROYECCIONES GEOMÉTRICAS PLANARES.........................................................................122
CLASIFICACIÓN DE LAS PROYECCIONES..............................................................................123
PROYECCIÓN EN PERSPECTIVA........................................................................................... 124

Matemáticas de las Proyecciones en Perspectiva..................................................................125
PROYECCIÓN PARALELA..................................................................................................... 127

Matemáticas de las Proyecciones Paralelas Ortogonales.....................................................128
5
Matemáticas de las Proyecciones Paralelas Oblicuas...........................................................130
Proyección CAVALLIER.......................................................................................................132
Proyección CABINET..........................................................................................................132
DETERMINACIÓN DE SUPERFICIES VISIBLES............................................137
SUPERFICIE VISIBLE........................................................................................................... 137
APROXIMACIONES............................................................................................................ 138
ALGORITMO DE PRECISIÓN DE OBJETO..............................................................................138
ALGORITMO DE PRECISIÓN DE IMAGEN.............................................................................139
DIFERENCIAS PRECISIÓN DE OBJETO VS PRECISIÓN DE IMAGEN.........................................140
CLASIFICACIÓN DE LOS ALGORITMOS................................................................................140

Algoritmo de z-buffer.............................................................................................................140
Algoritmo de A-buffer............................................................................................................143
Traza de rayos en superficies visibles.....................................................................................143
Algoritmo del pintor...............................................................................................................144
Árboles BSP............................................................................................................................146
Back-face culling.....................................................................................................................151
PROGRAMACION EN AUTOLISP......................................................................155
Comandos de programación.-............................................................................................ 159
Utilización de Listas.-......................................................................................................... 160
UTILIZACIÓN DE LAS FUNCIONES DEL TIPO GET..................................................................161
ESTRUCTURAS DE PROGRAMAS.-.......................................................................................164
Programación en DCL y AutoLISP.................................................................180

6
7
TEMA 1
8
9
INTRODUCCION A GRAFICAS POR
COMPUTADORA
OBJETIVOS
El estudiante será capaz de distinguir las características de los dispositivos de salida
Vectoriales y Raster.
El estudiante conocerá los pasos a realizar para el proceso de obtención de una

imagen.
CONTENIDO
 INTRODUCCION
 APUNTES DE LA HISTORIA
 APLICACIONES
 TECNOLOGÍAS DE SALIDA
 EL PROCESO DE OBTENCIÓN DE IMÁGENES
INTRODUCCION
Lo que se verá en la materia:
o “Imaging”: Cómo representar imágenes en 2D.

o “Modeling”: Cómo representar objetos en 3D y cómo construirlos
o “Animation”: Representación y control del cómo se pueden “mover” las cosas
o “Rendering”: Cómo construir imágenes en 2D a partir de modelos en 3D
10
APUNTES DE LA HISTORIA
1944: Computador Whirlwind (MIT)
o Proyecto para entrenamiento en lanzamiento de bombas (líder: Jay Forrester)

en tiempo real
o Primer computador con memoria de núcleo magnético
o T.R.C. para salida
o Impresora gráfica
1949: “Pistola de Luz” (Computador SAGE)
o SAGE: Semi-Automatic Ground Environment

11
o Equivalente a cientos de estaciones de radares en USA y Canada
o Primera Red de Computadores a gran escala
o Operador dirigía acciones tocando con un “cañón luminoso” una pantalla
o Precursor del Lápiz de Luz
o Usa fotocelda
1956: TX-0 y TX-2 (MIT)
o Uso de transistores
o Terminal de Video
o Lápiz de Luz
1963: Sketchpad (tesis doctoral)
o Software para TX-2

o Graficación Interactiva
o Estructuras de Datos Jerárquicas
12
o Dispositivos de interacción(lápiz de luz)
1962: Society for Information Display (SID): Investigación, diseño, manufactura,

aplicaciones y ventas de todo dispositivo de despliegue.
1963: DAC SYSTEM (General Motors)
o DAC: Design Augmented by Computers – primer sistema de dibujo para

computador
o Software Interactivo gráfico para DAC-1
o Usa Sketchpad
o Sistema comercial
o Uso en CAD y CAM (automóviles)
1964: Tableta gráfica (RAND Corp.)
13
1970: “Casco virtual”
 1º dispositivo de su género
 Ivan Sutherland
1972: “PONG” (ATARI)
 1º video-game computarizado
14
 Versión comercial
1977: APPLE II (APPLE)
 Computador con texto y gráficos en la misma pantalla

 Computador personal
INICIOS DE LOS 80’
 Revolución de la microminiaturización de componentes

 Reducción gradual del costo del hardware
o Procesadores
o Memoria!!!
o Monitores
 Popularidad de sistemas Raster
APLICACIONES
Entretenimiento
– Áreas
o Cine: (Tron. Toy Story, etc)
o Televisión (Cortinillas, cabeceras, etc)
15
o Juegos por computador
– Técnicas
o Animación
o Rendering
o Efectos especiales (ej. morphing)
o Interactividad
Diseño asistido por computador
16
– CAD: Conjunto de herramientas gráficas que permiten diseñar prototipos y
evaluarlos antes de ser construidos.
– Áreas importantes:
o Diseño mecánico
o Arquitectura
o Circuitería eléctrica
o Circuitos impresos e integrados
– Técnica habitual: diseño basado en primitivas constructivas.
– Otras posibilidades:
o Animaciones interactivas
o Sistemas multivista
o Presentación final realista
o Sugerencias constructivas
o Análisis del diseño con métodos de ingeniería u Conexión con el
sistema de fabricación (CAM)
17
Visualización cientifíca y médica
– Como característica común, el computador es usado para la visualización

gráfica de gran cantidad de datos.
– Áreas:
o Medicina (Ej. Resonancias)
o Ingeniería (Ej. Esfuerzos en mecanismos)
o Física (Ej. Campos)
o Química (Ej. Interacción molecular)
o Matemáticas (Ej. Solución a ecuaciones)
o Topografía y oceanografía (Ej. Terrenos y corrientes)
18
– Técnicas:
o Codificación por color
o Curvas de nivel
o Visualización de volúmenes
o Generación de terrenos fractal
Simulación y entrenamiento
– Áreas:
o Simulación de conducción
o Simulación de procesos
o Entrenamiento
o Enseñanza
19
– Técnicas:
o Tiempo real
o Interactividad
– Equipamiento:
o Generalmente se necesita un equipamiento específico para simular el
objeto de entrenamiento (Ej. Simuladores de vuelo)
Gráficos de presentación
– Uso de los gráficos para producción de ilustraciones de soporte a informes y

trabajos.
20
– Áreas de mayor uso:
o Economía
o Estadística
o Matemáticas
o Administración y gestión
– Técnicas principales:
o Gráficos de línea
o Gráficos de barra
o Gráficos de tarta
o Superficies 3D
Creaciones artísticas
– En este campo se producen imágenes con un fin artístico o comercial:

o Diseño de logotipos
o Bellas Artes
o Animaciones publicitarias
– Técnicas y software:
o Programas tipo “paintbrush”
o Programas de soporte a la animación
21
o Técnicas de tratamiento de imagen
o Técnicas de “rendering”
TECNOLOGÍAS DE SALIDA
Tecnología de Salida: Vectorial
Inicios: Uso de dispositivos Vectoriales (Caligráficos).
Se basan en la tecnología del Tubo de Rayos Catódicos (TRC o CRT)
22
El haz de electrones se mueve de acuerdo a comandos, de un punto a cualquier otro
23
Impacto del haz sobre el fósforo de la pantalla genera luz (no persistente)
Requiere refrescamiento
Tecnología de Salida: Raster-Scan
• El cañón emite electrones (cátodo).
• La intensidad del rayo se controla con la rejilla.
• El enfoque hace que los electrones describan una trayectoria convergente.
24
• La deflexión hace apuntar el rayo a un punto de la pantalla.
• El rayo impacta contra el fósforo que emite luz.
• La emisión del fósforo decae rápidamente, por lo que se necesita un refresco

del rayo sobre el punto.
Caracteristicas de la Tecnología de Salida: Raster-Scan
• Usa TRC, Control de TRC diferente al vectorial
• Barrido continuado de electrones a superficie de despliegue (Modelo de TV)
• Barrido es “Discreto”: puntos en pantalla en vez de líneas llenas. De izquierda

a derecha, y de arriba hacia abajo.
• Lectura en el mismo orden que el despliegue
• Señales de barrido en el TRC
25
• No hay división de líneas impares y pares
• Fósforo de la pantalla con más persistencia
• Monitores de mejor calidad
• Monitor monocroma
o Usa un tipo de fósforo
• Monitor color
o Usa 3 distintos fósforos en pantalla
o Composición de un pixel en color: tríada o stripe (tiras)
26
EL PROCESO DE OBTENCIÓN DE IMÁGENES
• El proceso de obtención de imágenes se puede tratar desde dos puntos de

vista:
o La adquisición y tratamiento de una imagen para conseguir un modelo

informático de la misma (tratamiento de imagen)
o La representación gráfica en el computador del modelo informático de

una imagen (síntesis de imagen)
• El proceso de síntesis de una imagen (proceso de visualización) es el conjunto

de operaciones (en 3D y en 2D) sobre un modelo informático de datos que
resultan en una representación gráfica del mismo en un dispositivo físico de
representación.
27
• En general, se considera disponible:
o Una descripción geométrica 3D de los objetos
o Una descripción física asociada a los objetos
o Un observador de la escena (conjunto de objetos)
o Unas condiciones de iluminación
o Un dispositivo físico de representación
o Un objetivo a cumplir (realismo, rapidez, codificación por colores, etc.)
P.O.I. Recorrido de la Escena

• La escena es el conjunto de objetos que se quieren representar además de su
entorno (luces, observador, etc)
• La geometría de los objetos se describe con un modelo geométrico.
• El recorrido de la escena comprende los métodos de interrogación de las

características de los objetos a visualizar.
• Sistema de coordenadas: sistema 3D particular de los objetos.
• Técnicas implicadas:
28
o Modelado geométrico de superficies
o Modelado de sólidos
o Otros modelos (datos científicos, fractales, gramáticas, etc)
o Arquitecturas jerárquicas
o Algoritmos de recorrido e interrogación de estructuras de datos
P.O.I. Transformación del Modelo

• Habitualmente es necesario colocar los objetos en la escena a partir de un
sistema particular donde se definieron.
• La transformación del modelo supone un cambio de sistema de coordenadas:
o Espacio afín (vectores y puntos)
o Transformaciones afines (traslación, giro y escalado)
o Matrices de transformación
P.O.I. Transformación de la Vista

• Toda visualización precisa de un observador.
• La transformación de la vista, una vez conocida la posición del observador,

supone un cambio de coordenadas de la escena al sistema local de
observación.
• El sistema local de observación viene definido por el modelo de la vista.
29
o Modelado de la vista (cámara sintética, volumen de la vista, etc)
o Transformaciones afines
o Matrices de transformación
P.O.I. Recortado
• El observador tiene un campo de visión determinado por el volumen de la
vista. Lo que queda fuera del campo de visión debe ser eliminado de las
posteriores operaciones: proceso de recortado.
• En general, el recortado calcula la parte común entre dos entidades
geométricas. En este caso, una de ellas es el volumen de la vista; la otra cada
uno de los objetos.
o Cálculo de intersecciones
o Criterios de interioridad
o Concavidad y convexidad
o Algoritmos de recortado de rectas
o Algoritmos de recortado de polígonos
P.O.I. Eliminación de Caras Ocultas

• En una escena, los objetos se tapan a sí mismos y entre sí, quedando siempre
partes ocultas al observador.
• Las partes ocultas deben ser eliminadas de posteriores operaciones: proceso
de visibilidad.
30
• El proceso de visibilidad es complejo, por lo que existen numerosas
soluciones. Una clasificación simple:
o Resolución del problema en el sistema de coordenadas de la escena
o Resolución del problema apoyándose en el dispositivo (sistema de
coordenadas de la imagen)
o Cálculo de normales
o Ordenación
o Algoritmos de visibilidad
o Aceleración por coherencia
P.O.I. Proyección
• La representación en el dispositivo es en 2D, la escena está en 3D.
• La operación de paso de un sistema 3D a uno 2D se conoce como proceso de

proyección.
• La proyección de un punto 3D sobre un plano se calcula trazando una visual

por el punto y calculando la intersección con el plano.
31
• Tipos de proyección:
o Paralela: visuales paralelas
o Perspectiva: visuales partiendo del observador (pto. de vista)
o Sistemas proyectivos
o Matrices de proyección
o Transformación perspectiva-paralela
P.O.I. Transformación del Dispositivo

• Los objetos proyectados están referidos a un sistema de coordenadas 2D
procedente del de la vista.
• Los objetos inscritos en un rectángulo del plano de proyecciones (ventana) se

visualizarán en un rectángulo del dispositivo físico (marco).
• El cambio de sistema de coordenadas del mundo real (vista) al del dispositivo
se conoce como transformación del dispositivo.
o Cambio de sistemas de coordenadas 2D
o Sistemas y transformaciones normalizados
o Recortado en 2D
o Isotropía y anisotropía
o Ampliación (zoom) y deslizamiento
32
P.O.I. Conversión al Raster
• Actualmente la representación de gráficos en un computador se realiza
activando puntos discretos de una matriz: el raster.
• Las entidades gráficas a representar (primitivas) son de naturaleza continua.
• Al proceso de conversión de una entidad continua en un conjunto de puntos

discretos se le denomina conversión al raster.
o Algoritmos de conversión de rectas
o Algoritmos de conversión de curvas (circunferencias, elipses, etc)
o Representación de texto gráfico
o Relleno de áreas y polígonos
o Técnicas de anti-aliasing
P.O.I. Iluminación
• Conocidos los puntos que representan sobre el raster cada primitiva es
necesario conocer el color que se debe asignar a cada punto.
• El color depende de:
o Las condiciones de iluminación del punto 3D sobre la superficie del
objeto con el que se corresponde.
o La forma (normal) de ese objeto en ese punto.
33
o Las propiedades ópticas del material que está hecho.
o El acabado superficial (rugosidad).
o El color del objeto (del material o de la pintura).
• Un modelo de iluminación tiene en cuenta todos los factores anteriores para

calcular el color que se ve en ese punto,
o Modelos de iluminación y sombreado
o Textura
P.O.I. Otras Operaciones

• Interactividad
– Generalmente, las aplicaciones de gráficos por computador deben responder

a las acciones del usuario sobre la pantalla.
– Una interacción comprende:

o La acción del usuario: evento
o La comprensión del evento: mensaje
o La comunicación a la aplicación: rutina de respuesta (callback)
o La actualización del gráfico
• Construcción del modelo
– El modelo se construye:
o A partir de una imagen real (adquisición)
o A partir de una idea (editor)
– Los programas editores de modelos suelen estar integrados en aplicaciones de

CAD.
• Uso de librerías y herramientas
34
• Todas las operaciones descritas se programan por medio de librerías gráficas
(OpenGl, StarBase, etc.)
35
36
TEMA 2
37
38
PRIMITIVAS - RENDERING
OBJETIVOS
El estudiante será capaz de comprender los diferentes métodos de discretización.
El estudiante podrá generar Líneas, circunferencias y elipses usando los algoritmos de

generación de primitivas
CONTENIDO
 INTRODUCCIÓN
 PRIMITIVAS GRAFICAS
 ESPECIFICACIÓN DE UNA DISCRETIZACION
 DIBUJO DE LÍNEAS RECTAS
 ALGORITMOS BASICOS PARA CIRCULOS
 ALGORITMOS PARA ELIPSES
INTRODUCCIÓN
 En los sistemas raster, las imágenes vienen definidas por la intensidad de sus
pixels.
39
 Los objetos presentes en la imagen se componen de primitivas simples (líneas,
puntos)
 El sistema gráfico dibuja estas primitivas transformándolos en pixels ->
Rasterización
 Los métodos de conversión deben ser lo más eficientes posible
 La primitiva “Punto” es la más sencilla:
40
o Se coloca la intensidad deseada en la celda de memoria del frame
buffer correspondiente
o Cuando el haz de electrones pase por esa línea horizontal (scan-line),
emitirá al pasar por esa posición
C++ Builder, permite dibujar puntos en un lienzo, usando la instrucción Pixels
void __fastcall TForm1::Button1Click(TObject *Sender)

{
Form1->Canvas->Pixels[10][10]=clBlue;
}
 A partir de este punto, se hará uso del modelo de dispositivo de raster.

 Para conseguir independencia de dispositivo, entonces, es necesario adoptar
un conjunto de primitivas y establecer una serie de métodos que permitan
representar dichas primitivas en nuestro dispositivo de raster satisfaciendo un
conjunto de especificaciones.
 Convertir la imagen real a la imagen en la pantalla se denomina discretizacion.
PRIMITIVAS GRAFICAS
 Es muy difícil escoger un conjunto de primitivas graficas que sea adecuado
para la presentación de todo tipo de entidades graficas. Sin embargo, el
siguiente subconjunto en la práctica resulta suficiente:
o Puntos.- Se especifican a partir de su localización y color.
41
o Segmentos de recta.- Son esenciales para la mayor parte de las
entidades. Se especifican a partir de un par de puntos que
representan sus extremos.
o Circunferencias.- En algunos casos representar entidades curvadas con
segmentos poligonales puede ser inadecuado o costoso, por lo que en
la práctica las circunferencias o círculos se adoptan como primitivas.
Se especifican con la posición de su centro y su radio.
o Polígonos.- Son indispensables para representar entidades sólidas. Se
representan a partir de una secuencia de puntos que determina la
poligonal de su perímetro.
ESPECIFICACIÓN DE UNA DISCRETIZACION

 Al elegir un método de discretizacion de una primitiva grafica, es
indispensable contar con criterios que permitan evaluar y comparar las
ventajas y desventajas de las distintas alternativas. Entre todas las
especificaciones posibles, podemos mencionar las siguientes:
o Apariencia.- Normalmente se espera que un segmento de recta tenga
una “apariencia recta”, tampoco debe tener discontinuidades o puntos
espureos, debe pasar por el primer y último puntos del segmento.
o Simetría e invariancia geométrica.- Debe producir resultados
equivalentes si se modifican algunas propiedades geométricas de la
primitiva. Ejemplo no debe variar si dicho segmento se traslada o si es
rotado, etc.
o Simplicidad y velocidad de computo.- Los métodos tienden a no
depender de estructuras complejas y a ser directamente
implementadas en hardware especifico de baja complejidad
DIBUJO DE LÍNEAS RECTAS

 Para dibujar líneas rectas, habrá que calcular las posiciones intermedias entre
los dos extremos
 Este problema no existía en las pantallas vectoriales o plotters
42
 Sin embargo, las posiciones de los pixels son valores enteros, y los puntos
obtenidos de la ecuación son reales -> existe un error (aliasing)
 A menor resolución, mayor es el efecto
 Es necesario disponer de métodos para convertir primitivas en pixels de la

forma más eficiente posible.
Consideraciones para el dibujo de rectas:
 Hay que calcular las coordenadas de los pixels que estén lo más cerca posible
de una línea recta ideal, infinitamente delgada, superpuesta sobre la matriz de
pixels.
 Las consideraciones que un buen algoritmo debe cumplir son:
o La secuencia de pixels debe ser lo más recta posible
o Las líneas deben dibujarse con el mismo grosor e intensidad
independientemente de su inclinación
o Las líneas deben dibujarse lo más rápido posible
EL ALGORITMO MÁS SENCILLO
43
• La ecuación de una recta es y = mx + b
o m es la pendiente
o b es el corte con el eje y
 Para cada valor de X desde x0 hasta x1, calculamos el valor de Y
• El algoritmo No es muy eficiente

• Cada paso requiere una multiplicación flotante, una suma y un redondeo
Dibuja una línea, usando la ecuación de la recta, solo para pendientes m<=1
void Ecuacion(int x0, int y0, int x1, int y1)

{
int dx=x1-x0,dy=y1-y0;
putpixel(x0,y0,BLUE);
float m=(float)dy/dx;
44
float b= y0-m*x0;
if(dx<0) dx=-1 else dx=1;
while(x0 != x1)
{
x0 +=dx;
y0=ceil(m*x0+b);
}
}
Dibuja una línea, usando la ecuacion de la recta, para cualquier pendiente m
void Ecuacion(int x0, int y0, int x1, int y1)

{
int dx=x1-x0,dy=y1-y0;
float m=(float)dy/dx;
float b= y0-m*x0;
if(dx<0) dx=-1 else dx=1;
while(x0 != x1)
{
x0 +=dx;
y0=ceil(m*x0+b);
}
}
else
{
float m=(float)dx/dy;
float b= x0-m*y0;
if(dy<0) dy=-1 else dy=1;
while(y0 != y1)
{
y0 +=dy;
x0=ceil(m*y0+b);
}
}
}
ALGORITMO BÁSICO INCREMENTAL DDA

45
• Podemos eliminar la multiplicación de la siguiente manera:
Sabemos que
yi = mxi + b
Entonces el siguiente valor sera:
yi+1 = mxi+1 + b
Reemplazando el valor xi+1= xi +x se tiene:
yi+1=m(xi +x)+ b
Multiplicando y reemplazando :
yi+1= mxi + b + mx
yi+1= yi + mx
Como ΔX =1, llegamos a la fórmula final
yi+1 = yi + m
• Cada pixel se calcula en función del anterior
• No hace falta calcular b
DDA donde m<1
m <1, los pasos son a largo de ‘x’.
Algoritmo DDA
Funcion Linea_DDA(int x0, y0, x1, y1)

inicio
46
dx = x1-x0
dy = y1- y0
m =(float) dy/dx
y = y0
Para x=x0 hasta x1 hacer
Pintar Pixel(x,y)
x=x+1
y=y+m
Fin para
fin
• Si m>1 falla, pues quedan huecos, como se muestra
• Solución:
Intercambiamos las variables x e y,
47
sabemos que:
xi = (1/m) (yi – b)
Entonces hallamos el siguiente valor:
xi+1 = (1/m)( yi+1 – b)
Reemplazando yi+1 =yi +Δy se tiene
xi+1 = (1/m) (yi +Δy– b)
Multiplicando y reemplazando:
xi+1 = (1/m) (yi – b) + Δy/m
xi+1 = xi + Δy/m
Como Δy=1, llegamos a la fórmula final
xi+1 = xi + 1/m
DDA donde m>1
m >1, los pasos no son en x. Para manejar esto, cambiar ‘x’ por ‘y’.
48
Algoritmo DDA para pendientes m<=1

inicio
dx = x1-x0
dy = y1- y0
m = (float)dy/dx
x = x0
Para y=y0 hasta y1 hacer
Pintar Pixel(x,y)
x=x+1/m
y=y+1
Fin para
fin
Algoritmo DDA para cualquier pendientes m

inicio
dx = x1-x0
dy = y1- y0
Si abs(dx) > abs(dy) entonces steps = abs(dx)
sino steps = abs(dy)
xinc =dx / steps
yinc =dy / steps
x = x0
y = y0
para k=1 hasta steps hacer
Pintar Pixel(x,y)
x=x+xinc
y=y+yinc
fin para
fin
• Inconvenientes:
o Existen errores de acumulación
o El redondeo es muy lento
49
Dibuja un línea de punto a otro usando el Algoritmo DDA
void Dda(int x0, int y0, int x1, int y1)

{
float x, y, xs, ys;
int dx, dy, steps;
dx = x1 - x0;
dy = y1 - y0;
x = x0;
y = y0;
if (abs(dx) > abs(dy)) steps = abs(dx);
else steps = abs(dy);
if (steps == 0) {
putpixel( x, y,BLUE);
return;
}
xs = dx/steps;
ys = dy/steps;
for (i = 0; i <= steps; i++)
{
x = x + xs;
y = y + ys;
}
}
ALGORITMO DE BRESENHAM
• Sólo usa aritmética entera
• Supongamos el caso 0 < m < 1 hay que decidir qué pixel dibujamos a
continuación, y
¡ sólo hay dos candidatos !
50
• El algoritmo debe decidir cuál de los dos pintar
• Partamos del pixel (xk, yk), y hay que decidir entre el pixel (x k+1, yk) o (xk+1,
yk+1)
• Para ello calculemos la distancia vertical entre el centro de cada pixel y la

línea real
d2 = (yk+1-y) = yk + 1 – m (xk + 1) - b
d1 = y – yk = m (xk + 1) + b -yk
• La diferencia entre ambas constantes nos ayudará a decidir qué pixel pintar
d1 – d2 = m (xk + 1) + b – yk –yk+1 + m (xk + 1) + b
51
d1 – d2 = 2m (xk + 1) +2 b – yk –yk -1
d1 – d2 = 2m (xk + 1) – 2yk + 2b – 1
• Multiplicando por Δx eliminamos el parámetro m, que no es entero
pk = Δx (d1 – d2)= Δx (2 (Δy / Δx) (xk + 1) - 2 yk + 2 b - 1)
pk = 2 Δy xk - 2 Δx yk + 2 Δy + 2 b Δx - Δx
pk = 2 Δy xk - 2 Δx yk + c
donde C = 2 Δy + Δx (2b – 1)
• Como Δx > 0, el signo de pk coincide con el de la diferencia (d1 – d2), y por tanto:
Si pk > 0  d1 > d2
hay que pintar el pixel (xk+1, yk+1)
Si pk < 0  d1 < d2
hay que pintar el pixel (xk+1, yk)
52
• La gran ventaja es que puede calcularse pk+1 a partir del anterior
pk = 2 Δy xk - 2 Δx yk + c
utilizando solamente ¡aritmética entera!.
En el paso k + 1, el parámetro de decisión se evalúa con base en la ecuación

anterior como
pk+1 = 2 Δy xk+1 - 2 Δx yk+1 + c
Al sustraer la ecuación de la anterior pk obtenemos
pk+1 - pk = 2 Δy xk+1 - 2 Δx yk+1 + c-2 Δy xk + 2 Δx yk - c
pk+1 - pk = 2 Δy (xk+1 - xk) - 2 Δx( yk+1 - yk)
Pero xk+1 = xk + 1, de manera que
pk+1 = pk + 2 Δy – 2 Δx (yk+1 – yk)
Donde el termino (yk+1 – yk) es 0 o 1, dependiendo del signo del parámetro pk.
Si pk > 0  d1 > d2
53
hay que pintar el pixel (xk+1, yk+1)
entonces yk+1 = yk +1:
pk+1 = pk + 2 Δy – 2 Δx (yk +1– yk)
pk+1 = pk + 2 Δy – 2 Δx
Si pk < 0  d1 < d2
hay que pintar el pixel (xk+1, yk)
encontes yk+1 = yk
pk+1 = pk + 2 Δy – 2 Δx (yk – yk)
pk+1 = pk + 2 Δy
• El primer parámetro p0 se evalúa a partir de la ecuación pk
54
pk = Δx (2 (Δy / Δx) (xk + 1) - 2 yk + 2 b - 1)
en la posición (x0,y0), sustituyendo con b = y0 - m x0 y m = Δy / Δx.
p0 = Δx (2( Δy / Δx)(x0 + 1) - 2 y0 + 2 (y0 - (Δy / Δx) x0) - 1)
p0 = 2 Δy x0 + 2 Δy - 2 Δx y0 + 2 Δx y0 - 2 Δy x0 - Δx
• donde se obtiene la siguiente ecuación:
p0 = 2 Δy - Δx
• Si m > 1, intercambiamos las variables x e y
• Si m < 0, el cambio es similar
55
Dibuja un línea de un punto a otro usando el Algoritmo Bresenham
void Bresenham(int x0, int y0, int x1, int y1)

{
int x, y, dx, dy, p;
int incE, incNE, stepx, stepy;
dx = (x1 - x0); dy = (y1 - y0);
if (dy < 0) {
dy = -dy; stepy = -1;
} else stepy = 1;
if (dx < 0) {
dx = -dx; stepx = -1;
} else stepx = 1;
x = x0; y = y0;
putpixel( x0, y0,BLUE);
56
if(dx>dy){
p = 2*dy - dx;
incE = 2*dy;
incNE = 2*(dy-dx);
while (x != x1){
x = x + stepx;
if (p < 0){
p = p + incE;
}
else {
y = y + stepy;
p = p + incNE;
}
}
}
else{
p = 2*dx - dy;
incE = 2*dx;
incNE = 2*(dx-dy);
while (y != y1){
y = y + stepy;
if (p < 0){
p = p + incE;
}
else {
x = x + stepx;
p = p + incNE;
}
}
}
}
ALGORITMO DEL PUNTO MEDIO
• Bresenham, J.E. "Algorithm for Computer Control of a Digital Plotter". IBM Systems
Journal, 4(1), 1965, 25-30.
o Usa aritmética entera
o Supone la pendiente (m) en el rango [0, 1]
57
o Parte del punto inferior-izquierdo al punto superior-derecho
• Segmento de recta desde (x0, y0) a (xf, yf)

o (x, y) : centro de un pixel
o y + e : valor exacto de la ordenada de la recta
o e : error (distancia) a la ordenada del pixel; e [-0.5, 0.5]
o m : pendiente de la recta
• Qué pixel pintar (x+1, y) o (x+1, y+1) ?

• Si y + e + m < y + 0.5 entonces se dibuja (x+1, y)
o Para (x+1, y), el nuevo valor de ‘e’ será:
o e = (y + e + m) – y
o e = e+m
58
• Si y + e + m >= y + 0.5 entonces se dibuja (x+1, y+1)
o Para (x+1, y+1), el nuevo valor de ‘e’ será:
o e = (y + e + m) – (y +1)
o e = e + m -1
Algoritmo Punto Medio
incio
e = 0
y = y1
para x = x1 hasta x2
setPixel(x, y)
si e + m < 0.5
e = e + m
sino
59
y = y + 1
e = e + m –1
fin si
fin para
fin
• Dado que m = dx / dy, entonces

e + m < 0.5
e + dy / dx < 0.5 / multiplicando por 2 * dx
2 * dx * e + 2 * dy < dx
• Sustituyendo e * dx por e’, el test pasa a ser:

2(e’ + dy) < dx
• Para la actualización del error tenemos:

ee+m
ee+m-1
• multiplicando por dx:

e * dx  e * dx + dy
e * dx  e * dx + dy - dx
• y sustituyendo e * dx por e’ :
e’  e’ + dy
e’  e’ + dy - dx
Algoritmo Punto Medio
inicio
e’ = 0
y = y1
para x = x1 hasta x2
setPixel(x, y)
si 2(e’ + dy) < dx
e’ = e’ + dy
sino
60
y = y + 1
e’ = e’ + dy –dx
fin si
fin para
fin
Dibuja un línea de un punto a otro usando el Algoritmo Bresenham
void PuntoMedio(int x0, int y0, int x1, int y1)

{
int x, y, dx, dy, p;
int incE, incNE, stepx, stepy;
dx = (x1 - x0); dy = (y1 - y0);
if (dy < 0) {
dy = -dy; stepy = -1;
} else stepy = 1;
if (dx < 0) {
dx = -dx; stepx = -1;
} else stepx = 1;
x = x0; y = y0;
putpixel( x0, y0,BLUE);
if(dx>dy){
p = 0;
incE = dy;
incNE =(dy-dx);
while (x != x1){
x = x + stepx;
if (2*(p+dy) < dx){
p = p + incE;
}
else {
y = y + stepy;
p = p + incNE;
}
}
}
else{
p = 0;
incE = dx;
61
incNE = (dx-dy);
while (y != y1){
y = y + stepy;
if (2*(p+dx) < dy){
p = p + incE;
}
else {
x = x + stepx;
p = p + incNE;
}
}
}
}
ALGORITMOS BASICOS PARA CIRCULOS
• Una circunferencia se define como un conjunto de puntos que se encuentran, en

su totalidad, a una distancia r de una posición central (xc, yc).
• Esta relación de distancia se expresa por medio del teorema de Pitagoras en

coordenadas cartesianas como:
(x - xc)2 + (y - yc) 2 = r2
ALGORITMO BÁSICO (COORDENADAS CARTESIANAS)
• Círculo en el origen: X 2 + Y 2 = R 2
62
• Se podría calcular para los puntos de una circunferencia a lo largo del eje x en
pasos unitarios los valores correspondientes de y en cada posición como:
Algoritmo Coordenadas Cartesianas
Funcion Circulo_cartesiana(int xc, yc, r)

inicio
y = R
Para x= -r hasta r hacer
y= sqrt(r*r-x*x)
Pintar Pixel(x+xc, y+yc)
Pintar Pixel(x+xc,-y+yc)
x=x+1
Fin para
fin
• METODO INEFICIENTE
o Se resuelve sólo 1/4 de círculo (SIMETRIA!!)
o X se incrementa en 1 por cada paso
o Y se obtiene de la ecuación del círculo:
63
o Operaciones en Punto Flotante implicadas!!
o Contorno con brechas (X cercano a R)
o Dibujo de la circunferencia con huecos
Programa en C++ Builder usando Coordenadas Cartesianas
void circulo_cartesiano(int xc, int yc, int r)

{
float x,y;
for (x=-r;x<=r;x++)
{
y=sqrt(r*r-x*x);
Form1->Canvas->Pixels[x+xc][+y+yc]=clRed;
Form1->Canvas->Pixels[x+xc][-y+yc]=clRed;
}
}
COORDENADAS POLARES
 Otra manera de eliminar el espacio irregular consiste en calcular los puntos a

lo largo de la frontera circular utilizando las coordenadas polares r y .
 Al expresar la ecuación de la circunferencia en forma polar parametrica, se
obtiene el par de ecuaciones
 X = R COS 
64
 Y = R SEN 
 Donde:  varía entre 0º y 90º
 No hay vacíos o brechas
Algoritmo Coordenadas Polares
Funcion Circulo_polares(int xc, yc, r)

inicio
Para ang= 0 hasta 360 hacer
x= r*cos(ang*3.141516/180)
y= r*sin(ang*3.141516/180)
Pintar Pixel(x+xc,-y+yc)
ang = ang + 1.0/r
Fin para
fin
 Método Ineficiente, por cálculos de Cos y Sen

 Para una frontera más continua, se puede establecer el tamaño de paso como
1/r. Esto hace que se tracen posiciones de pixel que están aproximadamente
una unidad aparte .

Programa en C++ Builder usando Coordenadas Polares
void circulo_polar(int xc, int yc, int r)

{
float x,y,ang;
for (ang=0;ang<=360;ang+=1.0/r)
{
x=r*cos(ang*3.141516/180);
y=r*sin(ang*3.141516/180);
Form1->Canvas->Pixels[x+xc][+y+yc]=clRed;
}
}
SIMETRÍA DE 8 LADOS
65
 Consideración para ahorrar cálculos:
o Aprovechar las simetrías de la circunferencia. Por cada punto hallado se
pueden ubicar siete más.
o En este caso la circunferencia está centrada en el origen, pero si no fuera
así, basta con restarle a (x,y) las coordenadas del centro de la
circunferencia, aplicar las simetrías y a los siete puntos sumarles las
coordenadas del centro nuevamente.
Dado un punto de la Circunferencia, se pinta los 7 restantes por Simetria de los 8 lados
SIMETRIA_8_LADOS(xc,yc,X,Y:integer);
INICIO
Pintar_Pixel ( X+xc, Y+yc);
Pintar_Pixel ( Y+xc, X+yc);
Pintar_Pixel ( Y+xc,-X+yc);
Pintar_Pixel ( X+xc,-Y+yc);
Pintar_Pixel (-X+xc,-Y+yc);
Pintar_Pixel (-Y+xc,-X+yc);
Pintar_Pixel (-Y+xc, X+yc);
Pintar_Pixel (-X+xc, Y+yc);
FIN
 Sólo un segmento de 45 º se requiere para obtener el círculo completo
66
 El valor de x que se requiere para obtener el círculo completo es desde 0 hasta
llegar a y.
Programa en C++ Builder cono Coordenadas Cartesianas usando simetría de los 8 lados
void simetria(int xc, int yc, int x, int y)

{
Form1->Canvas->Pixels[ x+xc][+y+yc]=clRed;
Form1->Canvas->Pixels[ x+xc][-y+yc]=clRed;
Form1->Canvas->Pixels[-x+xc][+y+yc]=clRed;
Form1->Canvas->Pixels[-x+xc][-y+yc]=clRed;
Form1->Canvas->Pixels[ y+xc][+x+yc]=clRed;
Form1->Canvas->Pixels[ y+xc][-x+yc]=clRed;
Form1->Canvas->Pixels[-y+xc][+x+yc]=clRed;
Form1->Canvas->Pixels[-y+xc][-x+yc]=clRed;
}
void circulo_cartesiano(int xc, int yc, int r)
{
float x,y;
y=r;
for (x=0;x<=y;x++)
{
y=sqrt(r*r-x*x);
simetria(xc,yc,x,y);
}
}
 El valor del Angulo que se requiere para obtener el círculo completo es de 0 a 45

grados
Programa en C++ Builder con Coordenadas Polares usando simetría de los 8 lados
void simetria(int xc, int yc, int x, int y)

{
Form1->Canvas->Pixels[ x+xc][+y+yc]=clRed;
Form1->Canvas->Pixels[ x+xc][-y+yc]=clRed;
Form1->Canvas->Pixels[-x+xc][+y+yc]=clRed;
Form1->Canvas->Pixels[-x+xc][-y+yc]=clRed;
67
Form1->Canvas->Pixels[ y+xc][+x+yc]=clRed;
Form1->Canvas->Pixels[ y+xc][-x+yc]=clRed;
Form1->Canvas->Pixels[-y+xc][+x+yc]=clRed;
Form1->Canvas->Pixels[-y+xc][-x+yc]=clRed;
}
void circulo_polar(int xc, int yc, int r)
{
float x,y,ang;
for (ang=0;ang<=45;ang+=1.0/r)
{
x=r*cos(ang*3.141516/180);
y=r*sin(ang*3.141516/180);
simetria(xc,yc,x,y);
}
}
 Bresenham (1977) desarrollo un generador incremental que genera todos los

puntos en un circulo.
 El algoritmo de Bresenham evita los cálculos de raíces cuadradas.
 Utiliza un parámetro de decisión para determinar cuál de las dos posiciones
posibles de y está más próxima a la trayectoria de la circunferencia.
 Las posiciones de los otros siete octantes se obtiene por simetría.
68
 Hay que determinar el píxel más cercano a la circunferencia
 Consideremos el centro del círculo en (0,0)
 Comenzaremos en el punto (0,R) e iremos desde x=0 hasta x=y, donde la

pendiente va de 0 a -1
 Sólo pintaremos el primer octante
 Sea la función:
 Este test lo ejecutaremos en los puntos medios entre los píxel que hay que
decidir
 Mecanismo de elección del píxel a pintar:
 Uso de P (referencia)
o Si P esta dentro del circulo, Píxel a la derecha
69
o Si P esta fuera del circulo, Píxel a la derecha y abajo.
 Coordenadas de P ??
Supongamos ya dibujado el píxel (xk, yk)
pk = f (xk+1, yk – ½) = (xk+1)2 + (yk – ½) 2 – R2
La gran ventaja es que puede calcularse pk+1 a partir del anterior pk. En el paso k + 1, el
parámetro de decisión se evalúa con base en la ecuación anterior como
pk+1 = f (xk+1 + 1, yk+1 – ½) = (xk+1 + 1) 2 + (yk+1 – ½) 2 – R2
Al sustraer la ecuación de la anterior p k obtenemos
pk+1 - pk = (xk+1 + 1) 2 + (yk+1 – ½) 2 – R2 - (xk+1)2 - (yk – ½) 2 + R2
pk+1 - pk = xk+12+2 xk+1+12- (xk+1)2 +(yk+12 -2½yk+1+ ½2) - (yk2–2½yk+½ 2)

70
pk+1 - pk = 2 xk+1+1 +yk+12 -yk+1- yk2+yk
Reordenando obtenemos
pk+1 = pk + 2xk+1 + 1 + (y k+12–yk2) – (yk+1–yk)

Donde: yk+1 es yk ó yk-1 dependiendo del signo de pk
Si pk < 0  hay que

pintar el pixel (xk+1, yk)  yk+1 = yk
reemplazando en pk+1 se tiene
pk+1 = pk + 2xk+1 + 1 + (y k2–yk2) – (yk–yk)
pk+1 = pk + 2xk+1 + 1
pk+1 = pk + 2xk+ 3
Si pk > 0  hay que

pintar el pixel (xk+1, yk-1)  yk+1 = yk -1
reemplazando en pk+1 se tiene
71
pk+1 = pk + 2xk+1 + 1 + (( y k–1 ) 2–yk2) – (yk–1–yk)
pk+1 = pk + 2xk+1 + 1 + (yk2–2yk+1 –yk2) – (yk–1–yk)
pk+1 = pk + 2xk+1 –2yk+3
pk+1 = pk + 2xk –2yk+5

 Empezamos en el punto (0, R).
 ¿Cuánto vale p0?

p0 = f (1, R- ½) = 12+ (R- ½) 2 -R2

p0 = 12+ R2 -2R ½ - ½ 2 -R2

p0 = 5/4 – R  no es entero!
 Sin embargo, da igual. Podemos redondearlo, porque todos los incrementos
son enteros, y sólo queremos utilizar el signo de pk, y no su valor
72
Dibuja una circunferencia con el Algoritmo del Punto Medio
void CircleMidPoint(int xc, int yc, int r)

{
int x, y, p;
x = 0;
y = r;
p = 1 - r;
PlotPoint(xc,yc,x,y);
/* se cicla hasta trazar todo un octante */
while (x < y)
{
x = x + 1;
if (p < 0)
p = p + 2*x + 3;
else {
y = y - 1;
p = p + 2*(x - y) + 5;
}
PlotPoint(xc,yc,x,y);
}
73
}
Void Point( int xc, int yc, int x, int y)

{
Point(xc + x,yc + y);
Point(xc - x,yc + y);
Point(xc + x,yc - y);
Point(xc - x,yc - y);
Point(xc + y,yc + x);
Point(xc - y,yc + x);
Point(xc + y,yc - x);
Point(,xc - y,yc - x);
}
ALGORITMOS PARA ELIPSES

 Expresado de forma ambigua, una elipse es una circunferencia alargada.


 Una elipse se define como el conjunto de puntos en que la suma de las
distancias desde dos posiciones fijas (focos) sea la misma para todos los
puntos.
 Si las distancias de los dos focos desde cualquier punto P=(x,y) en la elipse se
representan como d1 y d2, entonces la ecuación general de una elipse puede
expresarse como
d1 + d2 = constante
74
ALGORITMO BASICO (Coordenadas Cartesianas)
 Las ecuaciones de la elipse se simplifican, en gran medida, si se orientan los
ejes mayor y menor para alinearse con los ejes de las coordenadas, como se
muestra en la siguiente figura.
 El parámetro rx por convención designa el eje mayor y el parámetro ry designa

el eje menor.
 La ecuación de la elipse puede expresarse en termino de las coordenadas del
centro de la elipse y los parámetros rx y ry, como
Dibuja una Elipse con coordenadas cartesianas
void elipse(int x0,int y0, int rx, int ry)

{
int x,y;
for (x=-rx;x<=rx ;x++)
{
y=ry*sqrt(1-((float)x/rx)*((float)x/rx));
Form1->Canvas->Pixels[x+x0][y+y0]=clBlue;
Form1->Canvas->Pixels[x+x0][-y+y0]=clBlue;
}
75
}
ALGORITMO BASICO (Coordenadas Polares)
 Al utilizar las coordenadas polares r y , también es posible describir la elipse

en posición estándar con las ecuaciones parametricas:
 x = xc + rx cos ß
 y = yc + ry sin ß
 Se puede aplicar consideraciones sobre la simetría para reducir aun mas los
cálculos.
 Una elipse en posición estándar es simétrica entre cuadrantes, no es simétrica
entre los dos octantes. De este modo que al calcular una posición de un píxel
obtenemos por simetría las tres posiciones de los otros tres cuadrantes.
Dibuja una Elipse con coordenadas Polares
void elipses(int x0,int y0, int rx, int ry)

{
int x,y;
for (float ang=0;ang<=360 ;ang++)
{
x=rx*cos(ang*3.141516/180);
y=ry*sin(ang*3.141516/180);
Form1->Canvas->Pixels[x+x0][-y+y0]=clBlue;
76
}
}
 El planteamiento que se utiliza aquí es similar a aquel empleado en el

despliegue de una circunferencia.
 Dado los parámetros rx, ry, (xc, yc), se determina los puntos (x, y) para una
elipse en posición estándar centrada en el origen y luego se altera los puntos,
de modo que la elipse este centrada en (xc, yc).
 El método de punto medio para elipse se aplica a lo largo del primer cuadrante
en dos partes, de acuerdo a una elipse con la pendiente rx < ry, como se
muestra a continuación.
Dibuja una Elipse con el Algoritmo del Punto Medio
void melipse(int xc,int yc,int rx,int ry, int color){

long double rx2 = rx * rx, ry2 = ry * ry;
long double tworx2 = 2*rx2, twory2 = 2*ry2;
long double p, x = 0, y = ry;
long double px = 0, py = tworx2 * y;
77
puntose(xc,yc,x,y,color);
//region 1
p=ceill( ry2 - ( rx2 * ry ) + ( 0.25 * rx2 ) );
while(px<py){
x++;
px+=twory2;
if( p < 0 ) p += ry2 + px;
else{ y--;
py-= tworx2 ;
p += ry2 + px - py;
}
}
//region 2
p = ceill(ry2 * ( x+.5 ) * ( x+.5 ) + rx2
* ( y-1 ) * ( y-1 ) - rx2 * ry2);
while(y>0){
y--;
py-= tworx2 ;
if(p>0) p+= rx2-py ;
else{ x++;
px+= twory2;
p+= rx2-py+px;
}
}
}
void puntose(int xc,int yc,int x,int y, int c){
putpixel(xc+x,yc+y,c);
putpixel(xc-x,yc+y,c);
putpixel(xc+x,yc-y,c);
putpixel(xc-x,yc-y,c);
}
78
79
TEMA 3
80
81
TRANSFORMACIONES GEOMETRICAS EN 2-D
OBJETIVOS
El estudiante será capaz usar los diferentes algoritmos para la representación de
gráficas en 2D.
El estudiante será capaz realizar rotaciones, traslaciones y escalaciones en 2 D y

representarlas en la pantalla.
CONTENIDO
 QUE ES UNA TRANSFORMACION?
 COORDENADAS HOMOGENEAS
 COMPOSICION DE TRANSFORMACIONES
 OTRAS TRANSFORMACIONES
 TRANSFORMACIÓN VENTANA-ÁREA DE VISTA
QUE ES UNA TRANSFORMACION?

 Una transformacion es una operacion que transforma o cambia una figura
(line, drawing etc.)
 Hay varias formas basicas para cambiar una figura:
o translacion (moving it)
o rotacion (turning it round)
o escalamiento (making it bigger or smaller).
 Hay otras:
o Reflexion
o Corte
82
C++ Builder, se hará uso de una vector para almacenar los datos de la imagen.
int m=5; // numero de vertices

float vert[10][3]={ { 0, 0, 0},
{100, 0, 1},
{100,100, 1},
{ 0,100, 1},
{ 0, 0, 1}
};
void dibujar() {
int xc=Form1->Width/2,yc=Form1->Height/2;
int i;
for(i=0;i<m;i++) {
if(vert[i][2]==0)
Form1->Canvas->MoveTo(xc+vert[i][0],yc+vert[i][1]);
else
Form1->Canvas->LineTo(xc+vert[i][0],yc+vert[i][1]);
}
}
TRANSFORMACION EN 2D
TRASLACION
83
 Considere la flecha abajo. Podemos desear moverla desde la posición A a la
posición B.
 Podemos trasladar el punto (x, y) en el plano a las nuevas posiciones agregando

cantidades de la traslación a las coordenadas de los puntos. Para cada punto P (x,
y) que se moverá las unidades dx paralelas al eje de x y las unidades dy paralelas al
eje de y, al nuevo punto P' (x', y'). La traducción tiene la forma siguiente:
84
X’ = Tx + X
Y’ = Ty + Y
P’ = T + P
Traslada los puntos al la nueva posición (dx,dy)
void trasladar(float dx,float dy)

{
int i;
for(i=0;i<m;i++) {
vert[i][0] +=dx;
vert[i][1] +=dy;
}
}
ESCALAMIENTO
85
 Los puntos se pueden escalar por sx a lo largo del eje x y por sy a lo largo del eje y
los nuevos puntos por las multiplicaciones:
 Podemos especificar más grande o más pequeño por medio de un “factor de
posicionamiento”
 Para doblar el tamaño de un objeto utilizamos un factor de posicionamiento de 2,
a la mitad del tamaño de un objeto que utilizamos un factor de posicionamiento
de 0.5
X’ = Sx * X
Y’ = Sy * Y
P’ = S * P
Escala los puntos al la nueva posición (dx,dy)
86
void escalar(float dx,float dy)
{
int i;
for(i=0;i<m;i++) {
vert[i][0] *=dx;
vert[i][1] *=dy;
}
}
ROTACION
 Primero repasamos la idea del sin y del cos para un ángulo dado:
l | OP | x2  y2
cos   x / l
sin   y / l
x  l cos 
y  l sin 
 Y las formulas
sin(   )  sin  cos   cos  sin 

cos(   )  cos  cos   sin  sin 
cos(  )  cos  sin(  )   sin 
 Los puntos se pueden rotar a través de un ángulo sobre el origen:
87

| OP ' || OP | l
x ' | OP ' | cos(   )  l cos(   )

 l cos  cos   l sin  sin 
 x cos   y sin 
y ' | OP ' | sin(   )  l sin(   )

 l cos  sin   l sin  cos 
 x sin   y cos 
X’ = COSQ * X - SINQ * Y
Y’ = SINQ * X + COSQ * Y
88
P’ = R * P
Realiza la rotación de los puntos al la nueva posición (dx,dy)
void rotar(float angx)

{
float x,y;
angx=angx*3.141516/180;
int i;
for(i=0;i<m;i++) {
x=vert[i][0];
y=vert[i][1];
vert[i][0]=x*cos(angx)-y*sin(angx);
vert[i][1]=x*sin(angx)+y*cos(angx);
}
}
COORDENADAS HOMOGENEAS
 Las ecuaciones obtenidas
 no son consistentes al combinarlas (distintos operadores)

 Solución: Coordenadas Homogéneas
o Trata TODAS las transformaciones con operaciones de multiplicación
o Usa una coordenada adicional para cada par (X,Y)
89
W: Valor distinto de cero
• Dos conjuntos de coordenadas homogéneas:
(X,Y,W) (X’,Y’,W’)
• Representan el mismo punto ssi uno es múltiplo del otro
Ejemplo: (2,3,6) y (4,6,12) son el mismo punto
 Generalizando, todas las tripletas de la forma
(TX,TY,TW), T <> 0
 Formarán una línea en el espacio 3D!!

 Dividiendo por W, (T = 1):
(X,Y,1)
 Los puntos homogeneizados constituyen el plano definido por W = 1 en el espacio

(X,Y,W)
90
REPRESENTACION EN COORD. HOMOGENEAS
Traslación:
Escalamiento:
Rotación:
Implemetar un programa para graficar en 2D, usando Coordenadas Homogeneas.
Declaración de variables necesarias para la implementación: MATRIZ almacenara la

matriz identidad y la matriz de transformación. VTX almacenara todos los puntos de la
imagen que se graficara
typedef struct {
float v[3][3];
} MATRIZ;
MATRIZ identidad= {{{1,0,0},
{0,1,0},
{0,0,1} }};
91
MATRIZ mtrans=identidad;
typedef struct {
float x,y;
int dib;
} VTX;
int maxvtx=4;
VTX lista[3000]={{ 0, 0,0},
{100, 0,1},
{ 50,100,1},
{ 0, 0,1}};
Funcion que permite aplicar la Matriz de Transformación a un punto dado de la imagen

a graficar.
void aplica_matriz(VTX a,VTX &b)

{
b.x=mtrans.v[0][0]*a.x+
mtrans.v[0][1]*a.y+
mtrans.v[0][2]*1;
b.y=mtrans.v[1][0]*a.x+
mtrans.v[1][1]*a.y+
mtrans.v[1][2]*1;
b.dib=a.dib;
}
Función que grafica la imagen en pantalla, aplicando la Matriz de Transformación, antes

de graficarlo.
void dibujar(void)
{
VTX aux;
int i;
for (i=0;i<maxvtx;i++)
{
aplica_matriz(lista[i],aux);
92
if(aux.dib==0)
Form1->Canvas->MoveTo(aux.x, aux.y);
else
Form1->Canvas->LineTo(aux.x, aux.y);
}
}
Permite multiplicar 2 matrices, esta es invocada en las funciones de traslación,

rotación, y escalamiento.
void multiplica(MATRIZ a,MATRIZ b,MATRIZ &c)

{
int i,j,k;
for (i=0;i<3;i++) {
for (j=0;j<3;j++) {
c.v[i][j]=0;
for (k=0;k<3;k++)
c.v[i][j]+=a.v[i][k]*b.v[k][j];
}
}
}
Traslación:
Modifica la matriz de trasformación para trasladar un objeto a la posición (tx,ty,tz)
void trasladar(float tx,float ty)

{
MATRIZ aux,temp;
aux=identidad;
93
aux.v[0][2]=tx;
aux.v[1][2]=ty;
temp=mtrans;
multiplica(aux,temp,mtrans);
}
Escalamiento:
Modifica la matriz de trasformación para escalar un objeto en (sx,sy)
void escalar(float sx,float sy)

{
MATRIZ aux,temp;
aux=identidad;
aux.v[0][0]=sx;
aux.v[1][1]=sy;
temp=mtrans;
multiplica(aux,temp,mtrans);
}
Rotación:
Modifica la matriz de trasformación para rotar “ang” grados en el eje z
void rotarz(float ang)

{
94
MATRIZ aux=identidad,temp;
ang=ang*3.141516/180;
float vcos=cos(ang), vsin=sin(ang);
aux.v[0][0]=vcos;
aux.v[0][1]=-vsin;
aux.v[1][0]=vsin;
aux.v[1][1]=vcos;
temp=mtrans;
multiplica(aux,temp, mtrans);
}
COMPOSICION DE TRANSFORMACIONES
 Componer es aplicar sucesivamente transformaciones a una figura
 La sucesión de transformaciones constituye una multiplicación de matrices
sucesivas
 Propósito: mejorar eficiencia al aplicar una única transformación compuesta, en
vez de una serie de ellas.
EJEMPLO DE COMPOSICIÓN
 Rotar una casa respecto de uno de sus vértices
95
 Trasladar figura en -P al origen (P es pto. de referencia)
P’ = T(-x1,-y1) * P
 Rotar figura en q grados
P’’ = R(q) * P’
 Trasladar figura en +P a la referencia (P es pto. de referencia)
P’’’ = T(+x1,+y1)* P’’ = T(+x1,+y1)*R(q)*T(-x1,-y1)*P
 Se procede de modo similar si se desea escalamiento
OTRAS TRANSFORMACIONES
 Otras transformaciones que permiten llevar a cabo operaciones muy utiles, estas
son:
o Reflexiones
o Corte
Reflexiones en X y Y
 Las reflexiones respecto al eje X y Y se obtienen con la matrices siguientes:
96
Reflexion respecto al origen
 Las reflexion respecto al origen se obtiene con la matriz siguiente:
Reflexion respecto a la recta y=x
97
 Una reflexion respecto a la recta y=x, puede obtenerse en tres pasos:
o Girar un angulo de 45 grados en el sentido de las manecillas del reloj
o Una reflexion respecto al eje x
o Una rotación de 45 grados en contra del sentido del reloj
Reflexion general
 Una reflexion sobre una recta arbitraria y=m*x+b, puede obtenerse en los
siguientes pasos:
98
Corte en X
 El corte produce una deformación similar al deslizamiento de una capa sobre otra.
El corte en X se produce por la matriz:
Corte en Y
 El corte en Y se produce por la matriz:
99
TRANSFORMACIÓN VENTANA-ÁREA DE VISTA
 Dadas las primitivas de salida especificadas en coordenadas del mundo debe
especificarse como llevar dichas coordenadas a coordenadas de pantalla para que
puedan ser mostradas.
 Se debe especificar una región rectangular (ventana) en coordenadas de mundo y

una correspondiente región rectangular en coordenadas de la pantalla (viewport),
en la cual se efectuará el mapeo de la ventana del mundo.
 La ventana en coordenadas del mundo y el viewport en coordenadas de pantalla

determinan el mapeo que es aplicado a todas las primitivas en coordenadas del
mundo
Ventana
Coordenadas del Mundo
100
Rango Máximo de
Coordenadas de la
Pantalla
Viewport
Coordenadas de la Pantalla
 Dados:
- la ventana (en coordenadas del mundo)
- el viewport
 la matriz de transformación que mapea la ventana a coordenadas de pantalla

puede ser desarrollada mediante la composición de tres transformaciones simples
sugeridas en la figura siguiente:
 Proceso:
o Trasladar la ventana a su origen
o Escalar ventana al tamaño del area de visión
o Trasladar nueva ventana a posición final
101
 Pasos para transformar una ventana en coordenadas del mundo al Viewport en
coordenadas de pantalla
 Trasladar al Origen
 Escalar y trasladar al posicion final
 Como se puede apreciar en lo anterior, la ventana, especificada por su esquina

inferior izquierda y su esquina superior derecha, es primero trasladada al origen
de las coordenadas del mundo. Luego, la ventana es escalada para coincidir con
las dimensiones del viewport.
 Posteriormente, se utiliza una traslación para posicionar el viewport. La matriz que
corresponde a estas transformaciones Mwv es:
 u  u min vmax  vmin 

M wv  T (umin , vmin )  S  max ,   T (  xmin , ymin )
x
 max  x min y max  y min 
102
 u max  umin 
 0 0
1 0 u min   xmax  xmin  1 0  xmin 
vmax  vmin
 0 1 vmin    0 0  0 1  ymin 
 ymax  ymin 
0 0 1   0 0 1 0 0 1 
 
 
 u max  u min umax  u min 

x  x 0  xmin   umin 
xmax  xmin
 max min

vmax  vmin vmax  vmin
 0 ymin   vmin 
 ymax  ymin ymax  ymin 
 0 0 1 
 
 
 Multiplicando P = Mwv [x y 1] T se consigue el resultado esperado:
 u  u min v v 
P  ( x  xmin )  max  u min , ( y  ymin )  max min  vmin , 1
 xmax  xmin ymax  ymin 
 Este resultado corresponde al punto P expresado en coordenadas de la pantalla.

 La transformación ventana-viewport también puede combinarse con rutinas de
recorte (clipping) en relación al tamaño de la ventana.
103
 Las primitivas de salida en coordenadas del mundo son recortadas en relación al
marco de la ventana. El remanente es mostrado en el viewport
104
105
TEMA 4
106
107
VISION TRIDIMENSIONAL
OBJETIVOS
El estudiante será capaz usar los diferentes algoritmos para la representación de
gráficas en 3D.
El estudiante será capaz de realizar rotaciones, traslaciones y escalaciones en 3D y

representarlas en la pantalla.
CONTENIDO
 COORDENADAS HOMOGENEAS
 SISTEMA DE LA MANO DERECHA
 SISTEMA DE LA MANO IZQUIERDA
 TRASFORMACIONES EN 3D
 COMPOSICION DE TRANSFORMACIONES EN 3D
COORDENADAS HOMOGENEAS
 Trata TODAS las transformaciones con operaciones de multiplicación
 Usa una coordenada adicional para cada par (X,Y,Z)
W: Valor distinto de cero
108
SISTEMA DE LA MANO DERECHA
 Sistema matemático convencional

 “Z” va hacia afuera
109
 Dirección de rotación positiva
SISTEMA DE LA MANO IZQUIERDA
 Sistema para representación en una pantalla

 “Z” va hacia adentro
TRANSFORMACIONES EN 3D
TRASLACIÓN DE UN CUERPO
110
111
Modifica la matriz de trasformación para trastalar un objeto a la posición (tx,ty,tz)
void trasladar(float tx,float ty,float tz)

{
MATRIZ aux,temp;
aux=identidad;
aux.v[0][3]=tx;
aux.v[1][3]=ty;
aux.v[2][3]=tz;
temp=mt;
multiplica(aux,temp,mt);
}
ESCALACIÓN DE UN CUERPO
112
Modifica la matriz de trasformación para escalar un objeto en (sx,sy,sz)
void escalar(float sx,float sy,float sz)

{
MATRIZ aux,temp;
aux=identidad;
aux.v[0][0]=sx;
aux.v[1][1]=sy;
aux.v[2][2]=sz;
temp=mt;
}
ROTACIÓN SOBRE UN EJE COORDENADO
113
 ROTACION: Existen 3 casos, uno por cada eje de referencia
ROTACIÓN RESPECTO DEL EJE X
114
Modifica la matriz de trasformación para rotar “ang” grados en el eje x
void rotarx(float ang)

{
MATRIZ aux,temp;
aux=identidad;
ang=ang*3.141516/180;
float vcos=cos(ang);
float vsin=sin(ang);
aux.v[1][1]=vcos;
aux.v[1][2]=vsin;
115
aux.v[2][1]=-vsin;
aux.v[2][2]=vcos;
temp=mt;
}
ROTACIÓN RESPECTO DEL EJE Y
Modifica la matriz de trasformación para rotar “ang” grados en el eje y
void rotary(float ang)

{
MATRIZ aux,temp;
aux=identidad;
ang=ang*3.141516/180;
aux.v[0][0]=vcos;
aux.v[0][2]=vsin;
aux.v[2][0]=-vsin;
aux.v[2][2]=vcos;
temp=mt;
116
}
ROTACIÓN RESPECTO DEL EJE Z
Modifica la matriz de trasformación para rotar “ang” grados en el eje z
void rotarz(float ang)

{
MATRIZ aux,temp;
aux=identidad;
ang=ang*3.141516/180;
aux.v[0][0]=vcos;
aux.v[0][1]=-vsin;
aux.v[1][0]=vsin;
aux.v[1][1]=vcos;
temp=mt;
}
117
COMPOSICION DE TRANSFORMACIONES EN 3D
 Para transformar la línea P1P2 desde:
 hasta su nueva posición:
 Llevar P1P2 al origen (trasl. en -P1)

 Llevar P1P2 al plano YZ (rot. en Y)
 Llevar P1P2 al plano YZ (rot. En X)
118
TEMA 5
119
120
PROYECCIONES
OBJETIVOS
El estudiante será capaz de representar imágenes 3D en una pantalla de 2D, usando
los diferentes algoritmos de proyección.
El estudiante será capaz distinguir si una imagen es mostrada con un proyección en

perspectiva o paralela.
CONTENIDO
 QUE ES UNA PROYECCION?
 PROYECCIONES GEOMÉTRICAS PLANARES
 CLASIFICACIÓN DE LAS PROYECCIONES
 PROYECCIÓN EN PERSPECTIVA
 PROYECCIÓN PARALELA
QUE ES UNA PROYECCION?

 En general, transforman puntos en un espacio M-Dim a puntos en un espacio L-
Dim (L < M)
121
 En gráfica, transforman puntos en un espacio 3D a puntos en un espacio 2D
 La proyección de un objeto 3D es definida por “proyectores”, provenientes de un

“centro de proyección”.
PROYECCIONES GEOMÉTRICAS PLANARES

 Se aplica la proyección sobre un plano y no sobre una superficie curva
 Los proyectores son líneas rectas y no curvas
122
CLASIFICACIÓN DE LAS PROYECCIONES
Clasificación Simplificada
123
 Diferencia fundamental: Está en la relación del centro de proyección respecto del
plano de proyección
PROYECCIÓN EN PERSPECTIVA
 Tamaño varía inversamente con la distancia, visualización más realista. No se
preserva paralelismo
 Cuando la distancia entre el centro de proyección y el plano de proyección es
FINITA
 Note cómo las líneas, que en el espacio de mundo son paralelas, en esta
proyección se ven convergentes
124
Matemáticas de las Proyecciones en Perspectiva
 Consideraciones Previas:
o El plano de proyección se considerará normal al eje Z, en z = d
o Se usará el sistema de la mano izquierda
125
 La proyección puede definirse como una matriz de 4 x 4. Esto es conveniente,
dado que la matriz resultante puede componerse de varias matrices de
transformación.
 xs   1 0 0 0  x 
    
 ys   0 1 0 0  y 
 0  .
 z  0 0 0 0  z 
 
1    0 0 1/ d 1   1 
 d
126
 xs 
 
z
 xs   1  
   d 
y
 s   ys 
 0  z 
 z  1 
1    d 
 d  0 
 1 
 
• Se usa “d” como factor de escala de xp e yp.
• Note además la influencia de “z” sobre las expresiones de x p e yp: “z” ocasiona la
proyección
• Las expresiones anteriores pueden convertirse a matrices de transformación:
127
PROYECCIÓN PARALELA
 Visualización menos realista, apropiada para mediciones exactas. Preserva
paralelismo
 Cuando la distancia entre el centro de proyección y el plano de proyección es
INFINITA.
Matemáticas de las Proyecciones Paralelas Ortogonales
 Los proyectores son NORMALES al plano de proyección

 Las ecuaciones de transformación son directas.
128
 Descripción Gráfica en 3-D:
 De lo anterior:
o Xp = X;
o Yp = Y;
o Zp = d
 El valor original de Z se conserva para procesos de intensidad luminosa y
determinación de superficies visibles
129
 Las expresiones anteriores pueden convertirse a matrices de transformación:
Matemáticas de las Proyecciones Paralelas Oblicuas
 Los proyectores NO SON NORMALES al plano de proyección
130
• Descripción Gráfica en 3-D:
 Donde:
o Xp – X = L cos f
o Yp – Y = L sen f
o tan a = Z / L
 Por lo tanto:
o L = Z/tan a = Z cot a
o Xp = X + Z cot a cos f
131
o Yp = Y + Z cot a sen f
 Las expresiones anteriores pueden convertirse a matrices de transformación:
• Opciones comunes para el ángulo f son 30º y 45º, que despliegan una vista de
combinación de las parte frontal, lateral y superior (o inferior) de un objeto.
• Para a se emplean dos valores donde: tan a = 1 y tan a = 2.
Proyección CAVALLIER
 Cuando tan  = 1  = 45º (proyección CAVALLIER).

 Proyecciones Cavallier para  = 45º y 30 º. La profundidad del cubo se proyecta
con dimensiones equivalentes de ancho y alto:
132
Proyecta los datos “a” que se encuentran en 3 dimensiones a “b” en 2 dimensiones
void proyecta(VTX a, VTX &b)

{
float ang1=45.4*3.141516/180;
float ang2=45*3.141516/180;
b.x=a.x+a.z*cos(ang2)/tan(ang1);
b.y=a.y+a.z*sin(ang2)/tan(ang1);
}
Proyección CABINET
 Cuando tan  = 2  = 63,4º (proyección CABINET)

 Proyecciones Cabinet para  = 45º y 30 º. La profundidad del cubo se proyecta a la
mitad de ancho y alto:
Proyecta los datos “a” que se encuentran en 3 dimensiones a “b” en 2 dimensiones
void proyecta(VTX a, VTX &b)

{
float ang1=63.4*3.141516/180;
float ang2=45*3.141516/180;
b.x=a.x+a.z*cos(ang2)/tan(ang1);
b.y=a.y+a.z*sin(ang2)/tan(ang1);
}
133
134
135
TEMA 6
136
137
DETERMINACIÓN DE SUPERFICIES VISIBLES
OBJETIVOS
El estudiante será capaz de determinar que superficies de una imagen son visibles
para el observador.
El estudiante será capaz implementar los distintos algoritmos de determinación de

superficies visibles.
CONTENIDO
 SUPERFICIE VISIBLE
 APROXIMACIONES
 ALGORITMO DE PRECISIÓN DE OBJETO
 ALGORITMO DE PRECISIÓN DE IMAGEN
 DIFERENCIAS PRECISIÓN DE OBJETO VS PRECISIÓN DE IMAGEN
 CLASIFICACIÓN DE LOS ALGORITMOS
SUPERFICIE VISIBLE
 Al dibujar todas las lineas de una imagen, no es facil determinar la cara del frente y
el de atras.
138
 Tres formas de representar un objeto tridimensional: (a) se dibujan todas las
aristas; (b) se dibujan todas las aristas pero primero las más lejanas, y con líneas
segmentadas; (c) se dibujan solamente las aristas visibles
APROXIMACIONES
 Hay 2 aproximaciones fundamentales al problema.

o Precision espacio Object
 En los cálculos están involucrados polígonos
 Requiere de punto flotante: exacta
o Precision espacio Image
 Muestra la visibilidad de pixeles
 Usa precisión entera
ALGORITMO DE PRECISIÓN DE OBJETO

 Los algoritmos de precisión objeto realizan el proceso de cálculo en el sistema de
coordenadas del objeto
 Compara cada objeto directamente con los demás, eliminando objetos enteros o
aquellas partes que no son visibles
Algoritmo
Para cada objeto de la escena
139
Determinar que partes del objeto se ocultan
por otro objeto
por si mismo
Dibujar las partes visibles del color apropiado
 Este algoritmo es independiente del dispositivo de impresión. Si bien toda imagen

termina en una pantalla o impresora, el despliegue de la misma se hace en una
etapa posterior, cuando ya se conoce qué es lo que se va a dibujar y lo que no.
 Dado que cada objeto se compara con el resto, su complejidad es O(n2)

 La intersección entre polígonos es la operación más compleja
 Este tipo de algoritmo no ‘dibuja’
o se requiere de otro paso (algoritmo) para transformar las partes visibles
en mapa de pixeles
ALGORITMO DE PRECISIÓN DE IMAGEN

 Los algoritmos de precisión imagen se realizan en el sistema de coordenadas de la
imagen
 Aquí se determina cual de los ‘n’ objetos es visible en cada uno de los ‘p’ pixeles
de la imagen
Algoritmo:
Para cada píxel de la imagen
Determinar el objeto más cercano al observador y que intersecta con

el proyector que pasa por el píxel
Dibujar el píxel del color apropiado
 Este algoritmo depende del dispositivo utilizado y el tamaño de la ventana. Al

cambiar la cantidad de píxeles se deben rehacer los cálculos.
140
 Dado que debe comparar todos los objetos con cada pixel, este tipo de algoritmo
tiene un complejidad O(n*p)
 La operación más completa corresponde a la intersección de la recta con el objeto
DIFERENCIAS PRECISIÓN DE OBJETO VS PRECISIÓN DE IMAGEN

 En precisión de objeto no se considera la resolución de la pantalla para los cálculos
=> el dibujo en pantalla es el último paso.
 En precisión de imagen, al ampliar una imagen hay que rehacer todos los cálculos.
 Los algoritmos de precisión de objeto se hicieron inicialmente para sistemas
gráficos vectoriales.
 Los algoritmos de precisión de imagen se hicieron para sistemas gráficos de
barrido.
 Los algoritmos más recientes combinan la precisión de imagen y la precisión de
objeto.
CLASIFICACIÓN DE LOS ALGORITMOS

 Algoritmos de precisión imagen
o Zbuffer
o A-Buffer
o Ray-Casting
 Algoritmos de precisión objeto
o Algoritmo del pintor
o Árboles BSP
o Ordenamiento en Z
Algoritmo de z-buffer
Algoritmo de espacio imagen
141
• Muy simple de implementar:
– Por software
– Por hardware
• Requiere:
– Un buffer para los colores de los pixeles
– Un buffer (Z-Buffer) para almacenar la coordenada Z actual
• El buffer de colores es inicializado con el color de fondo
• El Z-buffer es inicializado con valor cero
– Valor del plano posterior en el clipping 3D
 Dado el z buffer vacío, tiene un cero asociado a cada celda (y pixel).

 Luego, se recorre un primer triángulo paralelo al plano z. Por tanto, todos las
celdas tienen el mismo valor.
142
 Luego, se recorre un segundo triángulo. Se compara esos valores con los ya
existentes. Si en el triángulo hay valores mayores que los equivalentes en el z-
buffer, entonces se ingresan dichos valores al z-buffer.
 ¿Considera que es práctico calcular el z de cada píxel para cada polígono? ¿Por qué
será el algoritmo elegido para ser implementado en las tarjetas gráficas?
void memoria_z
int pz; /*la z del polígono en las coord de pixel(x,y)*/
{
for (y = 0; y< YMAX; y++){
for (x = 0; x < XMAX; x++) {
esribir_pixel(x,y,valor_fondo);
escribir_Z(x,y,0);
}
}
for (cada poligono) {
for (cada pixel en la proyeccion del poligono){
pz = valor z del polig. En las coord. (x,y);
if (pz>= leer_Z(x,y)){
escribir_Z(x,y,pz);
escribir_pixel(x,y, color del polig en (x,y));
}
}
}
}
 Ventajas:
143
o Simple de implementar
o No requiere ordenamiento
o Complejidad ilimitada de la escena
 Desventajas
o Requiere de buffers (memoria)
o Gasta tiempo dibujando objetos ocultos
o Problemas de precisión en Z
o No maneja transparencias
Algoritmo de A-buffer
 Z-buffer no puede manejar transparencia de la superficie

 Variante del Z-Buffer que contempla la concurrencia de varias superficies sobre el
mismo pixel
 Para implementar este algoritmo se adiciona un estructura de datos (lista) que
mantiene un enlace con todas las superficies que contienen el punto
 Cálculo del color del pixel de atrás hacia adelante
Traza de rayos en superficies visibles
 Se basa en lanzar rayos desde el observador a los objetos, que pasen por el centro
de cada píxel.
 El objeto de intersección más cercana es el considerado.
144
Algoritmo
Seleccionar el centro de proyección y una ventana en el plano de vista;
For ( cada línea de rastreo en la imagen ) {
For ( cada píxel en la línea de rastreo ) {
hallar el rayo centro de proyección por el píxel;
For ( cada objeto en la escena ) {
If (  (objeto,rayo) y es el más cercano hasta ahora)
registrar intersección y nombre del objeto;
}
asignar color del píxel corresp. al del objeto más cercano;
}
}
¿Qué diferencia hay entre este algoritmo y el Z-buffer?
Algoritmo del pintor
 Un pintor dibuja sus cuadros partiendo desde el fondo hasta llegar a los objetos
más próximos al observador.
145
 El algoritmo del pintor utiliza este mismo razonamiento:
o Dibujar las superficies desde atrás hacia delante
 Las superficies más cercanas son dibujadas sobre las superficies de fondo
Ejemplo:
 Ventajas:
o Permite el manejo de transparencia
 Problema:
o La determinación del orden entre los elementos
146
Árboles BSP
 BSP: Binary partition algorithm
 Esta técnica subdivide recursivamente los semiplanos en frontales y posteriores
 La generación de un árbol BSP es un pre-proceso
 Este tipo de árbol permite generar imágenes desde cualquier punto de vista
 Algoritmo utilizado en el videojuego Doom.
 Aquí se tienen 5 objetos. Se toma uno como raíz y se subdivide el espacio en dos
(front y back). Paralelamente se genera una estructura de árbol donde se
especifican qué objetos están en qué semiespacio.
147
 Luego, en uno de los semiespacios se hace la misma tarea. Se toma un elemento
raíz y se subdivide el semiespacio en dos. Paralelamente se construye la estructura
de árbol. Se continua hasta que haya un objeto por nodo.
 Posible subdivisión espacial y árbol final.

 Luego de construido el árbol, lo que interesa es que rápidamente se puedan
dibujar los polígonos en el orden correcto según la posición del observador.
 Se recorre el árbol recursivamente. Se comienza por la raíz. Cómo el observador
está detrás del polígono 3 (observe la normal) entonces el orden correcto es:
recorrer primero el subárbol front, luego pintar el polígono raíz y luego recorrer el
subárbol back.
148
 Siga el algoritmo y verá que se pintan todos los polígonos en el orden correcto.
 El algoritmo es de orden n, luego de hallado el árbol.
 Otra posible posible subdivisión espacial y árbol final.
BSP Trees: Objects
149
150
renderBSP(BSPtree *T)
BSPtree *near, *far;
if (eye on left side of T->plane)
near = T->left; far = T->right;
else
near = T->right; far = T->left;
renderBSP(far);
if (T is a leaf node)
renderObject(T)
renderBSP(near);
151
Back-face culling
 Back-face culling (an object space algorithm) works on 'solid' objects which you
are looking at from the outside. That is, the polygons of the surface of the object
completely enclose the object.
 Which way does a surface point?

 Vector mathematics defines the concept of a surface’s normal vector.
 A surface’s normal vector is simply an arrow that is perpendicular to that surface.
 Every planar polygon has a surface normal, that is, a vector that is normal to the
surface of the polygon.
o Actually every planar polygon has two normals.
 Given that this polygon is part of a 'solid' object we are interested in the normal
that points OUT, rather than the normal that points in.
152
 Consider the 2 faces of a cube and their normal vectors.
 Vectors N1 and N2 are the normals to surfaces 1 and 2 respectively.
 Vector L points from surface 1 to the viewpoint.
 Depending on the angle between L, and N 1 & N2, they may or may not be visible to
the viewer.
 if we define  to be the angle between L and N.

 Then a surface is visible from the position given by L if:
 Can calculate Cos  using the formula:
L.N  L . N . cos 
153
Determining N:
• Can use cross product to calculate N
• N=AB
• NB. Vertices are given a counterclockwise order when looking at visible side.
Limitations:
It can only be used on solid objects…
Remove the top or front face of the cube, and suddenly we can see inside, and
our algorithm falls over.
It works fine for convex polyhedra but not necessarily for concave polyhedra.
154
example of a partially hidden face, that will not be eliminated by Back-face removal.
155
TEMA 6
156
157
PROGRAMACION EN AUTOLISP
Lisp.- LISt Processing (procesamiento por listas) Lenguaje Orientado a

implementaciones en el área de inteligencia artifical, cuya base se sustenta en la
manipulación de listas y símbolos, considerado dentro del paradigma funcional.
AutoLisp.- Es una adaptación del Lenguaje LISP, y forma parte integral del Auto-Cad. Un
Lenguaje de alto nivel, que no se considera ni compilador ni interprete sino esta dentro el rango
de intermedio.
Ventajas de programar en Auto-Lisp.
 Facilidad de manejar objetos heterogéneos, sin la necesidad de declararlos

previamente.
 Facilidad de interacción en un proceso de dibujo.
 Sencillez de aprendizaje y comprensión.
 Sencillez de sintaxis.
Tipos de Datos.-
 Listas – Objeto compuesto por: ( elementos separados por espacio )

 Elemento – Componentes de una lista.
 Símbolo – Elemento de una lista que no es un valor concreto: variable, función definida
por el usuario.
 Enteros – Valores numéricos, de 16 bits. [–32768 .. 32767]
 Reales Valores numéricos con punto flotante. Donde la inserción del punto es obligado.
 Cadenas – Valores textuales (longitud máxima 132 caracteres)
 Función de Usuario – Función definida por un usuario.
Funciones de librería y operadores (algunos ejemplos).-
158
(ABS num) Retorna el valor absoluto de num.
(FIX num-real) Retorna La parte entera de num-real.
(REM num-1 num-2) Retorna el resto de la división de num-1 entre num-2.
(SIN ang) Retorna el Seno de ang en radianes.
(COS ang) Retorna el coseno de ang en radianes.
(ATAN num) Retorna el arco tangente de num.
(SQRT num) Retorna la raiz cuadrada de num
(EXP num) Devuelve la constante e elevado a la potencia num.
(EXPT base pot) Devuelve la base elevado a la potencia pot.
(LOG num) Devuelve el logaritmo natural de num.
(GCD ent1 ent2) Devuelve el máximo común divisor de ent1 con ent2.
(MAX num1 num2 ...) Devuelve el mayor de la lista.
(MIN num1 num2 ...) Devuelve el menor de la lista.
Lógicos.- (AND exp), (OR exp), (EQUAL exp), (NOT exp).
Creación de Programas, en AutoLisp existen dos formas de construir el código:
i) En línea de Comandos.
Ejm.
159
Command: (defun seno (x) (setq xr(* PI (/ x 180.0)))
(setq s (sin xr))
entonces se habrá creado el comando seno (x en grados), dispuesto para ejecutarlo en

cualquier momento.
Command: (seno 30)
0.5
Ejm. Construir una definición para dibujar un triángulo, ingresando tres puntos (escribir
únicamente el texto en negrigllas en el prompt de AutoCad).
Command: (defun Triangulo()
(_> (setq p1(getPoint "Primer punto: "))(terpri)
(_> (setq p2(getPoint "Segundo punto: "))(terpri)
(_> (setq p3(getPoint "Tercer punto: "))(terpri)
(_> (command "line" p1 p2 p3 "c")
(_> )
TRIANGULO
Una vez construido la función Triangulo se la debe invocar (en cualquier instante mientras se
este interactuando con el AutoCad, permanece residente en la memoria). Se ingresa los tres
puntos, el programa automáticamente finalizará dibujando un triángulo, a través de la ejecución
del comando gráfico line.
160
Command: (triangulo)
Primer punto:
Segundo punto:
Tercer punto:
line Specify first point:
Specify next point or [Undo]:
Specify next point or [Undo]:
Specify next point or [Close/Undo]: c
Command: nil
En el caso de existir errores de definición de función no aparece el nombre de la función, sino

algún mensaje.
ii) En fichero de texto.

(load “nombre fichero”)
ejm. Si el fichero se denomina “miprog.lsp” se debe escribir incluyendo el path por

ejemplo.
(load “c:\\archivos de programa\\acad2014\\miprog”)
Si el fichero tiene errores entonces se emitirá un mensaje de error, de lo contrario se visualizará

el nombre de la función principal.
161
Comandos de programación.-
Debe recordarse que en este lenguaje no se diferencia entre mayúsculas o minúsculas,

entonces será lo mismo escribir por ejemplo Defun o defun o DEFUN, de la misma manera
con los identificadores (setq in 5), (setq In 5) o (setq IN 5) es el mismo dientifiacador.
DEFUN definir una función de usuario
(defun Nombre función (Lista de argumentos)
... cuerpo de la función
Una definición de función se ejecuta una vez cargado el fichero a la memoria, la función
permanecerá residente, dispuesta para su ejecución mientras permanezca el dialogo con
AutoCad, si la función esta antecedida por c: , significa que pueden existir en una escritura
varias funciones y esta será la principal, para su invocación no requiere de los paréntesis.
PROMPT.- Escribir texto en línea de comando
(prompt “Bienvenidos a Auto Lisp”)
TERPRI.- Salto a una nueva línea de escritura en línea de comando
(terpri) Solo se utilizará para acompañar a las funciones que involucren entradas con
GET...
162
SETQ.- Crear y atribuir valores a variables. En el momento de la asignación, el nombre_variable
se declara implícitamente bajo algún tipo, sin embargo puede no ser definitivo.
(setq nombre_variable expresión...)
ejm.
(setq x 5) ;; Asignación simple x = 5
(setq x 5 y “Hola” x ‘(a b) w (+ 25.3 12.5)) ;; Asignación múltiple x = 5; y = “Hola”;
x = ‘(a b); w = + 25.3 12.5
(setq x “Hola”) ;; x = “Hola” asume una nueva

declaración.
! vista del contenido de las variables (a no ser que se declaren locales)
COMMAND.- Acceso a los comandos de AutoCad
(command “Line” p1 p2 “”) ;; “” sirve de enter
Utilización de Listas.-
CAR.- Extrae el primer elemento de una lista (coordenada x, cuando la lista es un punto)
(CAR lista)
Ejm. (setq x (car pto))
163
CADR.- Extrae el Segundo elemento de una lista (coordenada x, cuando la lista es un punto)
(CADR lista)
Ejm. (setq y (cadr y))
CDR.- Retorna una sublista con todos los elementos a partir del segundo.
(CDR lista)
Ejm. (setq xs (cdr (list 1 2 3 4 5))) ;; xs = [2 3 4 5]
CADDR.- Retorna el tercer elemento de una lista.
(CADDR lista)
Ejm. (setq z (caddr pto))
LIST.- Crear listas
(LIST x y z))
Nota: aunque ya se utilizó líneas arriba el doble punto y coma ;; se utiliza para anotar un
comentario, hasta el final de la línea.
UTILIZACIÓN DE LAS FUNCIONES DEL TIPO GET...

GETPOINT.- Introduce un punto: ya sea por teclado, especificando los valores de las
coordenadas en el plano o espacio separados por comas o por el ratón.
164
(setq pto1 (GETPOINT “Introducir un Pto: ”))
GETCORNER.- Introducir un punto en diagonal, arrastrando un rectángulo elástico.
(GETCORNER pt1 “Otro punto”)
GETINT.- Introducir un entero
(setq n (GETINT “Un entero: ”))
GETREAL.- Introducir un número real.
(setq re (GETREAL “Un real: ”))
GETDIST.- Determina la distancia entre dos puntos.
(setq dis (GETDIST ‘(10 10) “Segundo Pto: ”))
GETANGLE.- Introducir un ángulo.
(GETANGLE pt1 “Angulo ”) ;; El sentido será antihorario.
GETSTRING.- Introducir una cadena de texto.
(setq cad(GETSTRING “Un_texto: ”)) ;; La cadena no aceptará espacios en

blanco.
165
(setq cad(GETSTRING T “Un texto: ”)) ;; La cadena acepta espacios e blanco.
INITGET.- Establecer modos para las funciones GET
(INITGET modo) ;; el modo puede ser combinación de las diferentes

opciones según la
necesidad.
Modo Concepto
1 No admite valores nulos, es decir INTRO.
2 No admite valor cero.
4 No admite valores negativos.
8 No verifica límites, aunque estén activados.
16 (No se utiliza)
32 Dibuja la línea o el rectángulo, con línea de trazos en vez de continúa
64 Hace que la función GETDIST devuelva distancia 2D
128 Permite introducir datos arbitrarios por teclado. Tiene prioridad sobre el valor 1
Ejm.
Si se desea introducir un número positivo mayor a cero.
(initget (+ 1 2)) ;; o (initget 3)
166
(initget (+ 1 2 4)) ;; o (initget 7)
(setq h (getreal “Altura total del cilindro: ”))
GETKWORD.- Introducir solo palabras clave.
(initget 1 “Sí No”)
(setq re(GETKWORD “Cerrar líneas Sí/No: ”))
En este caso se admitiría las respuestas s, sí, n o no (mayúsculas o

minúsculas.)
ESTRUCTURAS DE PROGRAMAS.-
Una definición puede iniciarse como (defun estrella() … , normalmente esta forma de escritura
se utiliza cuando se tiene una sola función, cuando una solución se resuelve con mas de una
función, entonces será recomendable escribir (defun c:estrella() … , que representa como a la
función principal.
i) Estructura secuencial.- SETQ, COMMAND, LIST, GET...

POLAR.- es una función que a partir de un punto de referencia, un ángulo
(radianes) y una distancia, retorna un nuevo punto.
Ejm. (setq p1(polar p0 (/ pi 2) 100)
Ejm. Dibujar una estrella de n puntas, dado un punto centro, el radio interno y el radio externo.
167
;; Dibujar una estrella de n puntas, dados los radios: interno y externo
(defun c:estrella()
(command "erase" "all" "")
(setq n(getInt "Número de puntas: "))(terpri)
(setq p0(getPoint "Ingrese punto centro: "))(terpri)
(setq ri(getInt "Radio Interno: "))(terpri)
(setq re(getInt "Radio Externo: "))(terpri)
(setq xc (car p0) yc (cadr p0))
(setq pex(list (+ xc re) yc))
(setq pin(list (+ xc ri) yc))
(setq ang(/ 360.0 n))
(setq anr(/ (* ang PI) 180.0))
(setq ai(/ anr 2.0))
(setq p1 (polar p0 ai ri))
(command "line" pex p1 "")
(setq p2 (polar p0 (- ai) ri))
(command "line" pex p2 "")
(command "Array" "all" "" "p" p0 n "" "")
(command "-view" "top")
168
Ejemplo. A partir del ingreso de un punto y el grosor de la cruz esvástica, desarrollar el código
para obtener dicha figura.
;; La Cruz Esvástica
(defun datos()
(setq p0(getPoint "Punto Inicio: "))(terpri)
(setq g (getInt "Grosor: "))(terpri)
(defun Puntos()
(setq p1(polar p0 0 g))
(setq p2(polar p1 (/ pi 2) (* 2 g)))
(setq p3(polar p2 0 g))
(setq p4(polar p3 (- (/ pi 2)) (* 2 g)))
(setq p5(polar p4 0 (* 3 g)))
(setq p6(polar p5 (/ pi 2) g))
(setq p7(polar p6 pi (* 2 g)))
(setq p8(polar p7 (/ pi 2) g))
(setq p9(polar p8 0 (* 2 g)))
(setq p10(polar p9 (/ pi 2) (* 3 g)))
169
(setq p11(polar p10 pi g))
(setq p12(polar p11 (-(/ pi 2)pi) (* 2 g)))
(setq p13(polar p12 pi g))
(setq p14(polar p13 (/ pi 2) (* 2 g)))
(setq p16(polar p15 (-(/ pi 2)pi) g))
(setq p17(polar p16 0 (* 2 g)))
(setq p18(polar p17 (-(/ pi 2)pi) g))
(command "pline" p0 p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11 p12 p13 p14 p15 p16 p17 p18 p19
p0 "")
(command "extrude" "l" "" (/ g 2))
(defun c:Cruz()
(datos)
(command "-view" "top")
(Puntos)
(command "-view" "swiso")
(command "vscurrent" "c")
170
Ejemplo. Problema para mostrar el empaquetamiento de varias copas de muchas filas y
muchas columnas, dados la altura y el radio de una copa.
;; Caja de copas de nf filas y nc columas, dado la altura y el radio de una copa.
(defun datos()
(setq rc(getReal "Radio (ext) de la copa<mm>: "))

(terpri)
(setq ha(getReal "Altura de la copa<mm>"))(terpri)
(setq nf(getInt "Cuantas filas: "))(terpri)
(setq nc(getInt "Cuantas columnas: "))(terpri)
(defun Dibujar()
(setq pc(list (+ rc 2) (+ rc 2)))
(command "cylinder" pc rc ha)
(setq c1(ssget "l"))
(setq pca(list (+ rc 2) (+ rc 2) 4))
(command "cylinder" pca (- rc 2) ha)
(command "subtract" c1 "" "l" "")
(command "array" "l" "" "r" nc nf (+(* 2 rc) 4) (+(* 2 rc) 4))
171
(setq p0(list 0 0 0))
(setq p1(list (+ (* (* 2 nf) rc)12) (+ (* (* 2 nc) rc)8)))
(command "box" p0 p1 (+ ha 8))
(setq b1(ssget "l"))
(setq p2(list (-(car p0) 2) (-(cadr p0) 2) (- 2)))
(setq p3(list (+(car p1) 2) (+(cadr p1) 2)))
(command "box" p2 p3 (+ ha 2))
(command "subtract" "l" "" b1 "")
(defun c:cajaCopa()
(command "view" "top")
(command "shademode" "2")
(Datos)
(Dibujar)
(command "view" "swiso")
(command "shademode" "g")
172
ii) Estructura condicional.-
a. Simple.
(if (cond )
(accion-verdad)
b. Doble
(if (cond)
(acción-verdad)
(acción-falso)
c. Múltiple
(cond ((= op “Opción-1”) (Acción-1))
((= op “Opción-2”) (Acción-2))
...
((= op “Opción-n”) (Acción-n))
Ejemplo.(parte de un programa)
(initget 1 “Ventana Puerta Muro Ninguno”)
(setq op (GETKWORD “Ventana/Puerta/Muro/Ninguno: ”))
( Cond ((= op “Ventana”) (InsVentana))
173
((= op “Puerta”) (InsPuerta))
((= op “Muro”) (InsMuro))
. ((= op “Ninguno”) (Ninguno))
PROGN.- Secuencia consecutiva, cuerpo de una salida, para el caso de tener más de una
instrucción.
Ejm.
(if (= n 1)
(PROGN (setq a (+ 1 n))
(prompt “Correcto”)
(terpri)
(PROMPT “Incorrecto”)
iii) Estructura repetitivas.-

REPEAT.- Repetir un número de veces (bucle automático)
(REPEAT número
exp-1
exp-2...
174
Ejemplo. Rastrear un triángulo equilátero, dado: el vértice de inicio y la longitud de un lado.
;; Triangulo Equilatero en base a Puntos
(defun Equi()
(setq p0(getPoint "Vertice Inicio: "))(terpri)
(setq l(getInt "Lado del triangulo: "))(terpri)
(setq x0(car p0) y0(cadr p0))
(setq ser(/ (* 60.0 pi)180.0))
(setq civ(/ (* 120.0 pi)180.0))
(setq d 0 p3(list (+ x0 l) y0))
(command "point" p0)
(repeat l
(setq d (+ d 1))
(setq p1(list (+ x0 d) y0))
(setq p2(polar p0 ser d))
(setq p4(polar p3 civ d))
175
)
WHILE.- Repetir según condición (bucle manual, requiere modificar la variable de control del
bucle dentro el cuerpo de lo contrario se convierte en bucle infinito)
(WHILE (cond)
exp-1
exp-2…
Ejemplo. Plotear una espiral en base a un punto de inicio y el radio del primer arco.
;; Espiral conocido Punto Inicio y primer radio
(defun espi()
(setq p0 (getPoint "Punto de Inicio: "))(terpri)
(setq r (getInt "Primer Radio: "))(terpri)
(setq n (getInt "Nro. de semi-vueltas: "))(terpri)
(setq x0 (car p0) y0 (cadr p0))
(setq di (* 2.0 r) d di)
176
(setq pu (list (+ x0 r) y0) pa p0)
(setq cv 1)
(repeat n
(setq p1 (list (+ x0 d) y0))
(command "arc" "c" pu p1 p0)
(setq p2 (list (- x0 di) y0))
(command "arc" "c" pa p2 p1)
(setq p0 p2 cv (+ cv 2))
(setq d (* cv di))
(setq x0 (car p0) y0(cadr p0))
Ejemplo. Este ejemplo muestra el diseño, con uso de la estructura repetitiva while, se
recomienda ingresar los datos cuidadosamente.
sugerencia:
Command: Ancho Interior <cm> : 15
Ancho Exterior <cm> : 20
Largo Grada <cm> : 80
Grueso de Grada <cm> : 5
177
Alt.Total Grada <cm> : 250
Radio del Soporte<cm> : 10
Alto de una grada<cm> : 20
;; Programa para diseñar gradas circulares.
(defun c:grada()
;; (command "erase" "All" "")
(command "_-view" "_top")
(setq in (getReal "Ancho Interior <cm> : "))(terpri)
(setq ex (getReal "Ancho Exterior <cm> : "))(terpri)
(setq la (getReal "Ancho Grada <cm> : "))(terpri)
(setq al (getReal "Grueso de Grada <cm> : "))(terpri)
(setq ha (getReal "Alt.Total Grada <cm> : "))(terpri)
(setq rc (getReal "Radio del Soporte<cm> : "))(terpri)
(setq co (getReal "Alto de una grada<cm> : "))(terpri)
(setq an 20.0)
(setq p0 (list 0.0 0.0))
(setq p1 (list 0.0 (/ in 2.0)))
(setq p2 (list la (/ ex 2.0)))
(setq p3 (list la (-(/ ex 2.0))))
(setq p4 (list 0.0 (-(/ in 2.0))))
178
(setq pe (list 0.0 0.0 co))
(setq c 0.0)
(command "cylinder" p0 rc ha)
(command "pline" p1 p2 p3 p4 "c")
(command "region" "l" "")
(command "extrude" "l" "" al "")
(while (<= c ha)
(command "copy" "l" "" p0 p0)
(command "rotate" "l" "" p0 an)
(command "move" "l" "" p0 pe)
(setq c (+ c co))
(command "_-view" "_seiso")
Ejemplo. Este ejemplo muestra como se manejan listas de mas de dos datos, se debe entender
cada línea del código para entender el programa completo. Es una generalización a partir del
triángulo de Sierpinski, ahora modificado para cualquier polígono de n lados, además la forma
de encadenar funciones, siendo la función principal Sierpi.
179
;; Generalización del Triangulo de Siarpinski.
(defun LeerPtos()
(setq n (getInt "Número de Vertices: "))(terpri)
(setq X Nil Y Nil pto (list 0 0)) ;; crear listas vacias
(repeat n
(setq pto (getPoint pto "Ingrese un Punto: "))(terpri)
(setq X (cons (car pto) X)) ;; inserta un elemento al inicio de una lista
(setq Y (cons (cadr pto) Y))
(setq X (reverse X) Y (reverse Y)) ;; invierte una lista
( defun DibuPoli()
(setq Xd X Yd Y)
(setq x0 (car Xd) y0 (car Yd)) ;; extrae el primer elemento de una lista
(setq p0 (list x0 y0) p (list x0 y0))
(setq p1 (list (cadr Xd) (cadr Yd))) ;; extrae el segundo elemento de una lista
(setq dis (distance p1 p0))
(repeat (- n 1)
(setq Xd (cdr Xd) Yd (cdr Yd)) ;; saca la cola de una lista
180
(setq x1 (car Xd) y1 (car Yd))
(setq p1 (list x1 y1))
(command "line" p0 p1 "")
(setq p0 p1)
(command "line" p1 p "")
(defun nuevasCoord()
(setq xu (car X) yu (car Y))
(setq Xi Nil Yi Nil)
(setq i 0)
(repeat (- n 1)
(setq xm (/ (+ (nth (+ i 1) X) (nth i X)) 2.0));; retorna el elemento de la
(setq ym (/ (+ (nth (+ i 1) Y) (nth i Y)) 2.0));; posición i
(setq Xi (cons xm Xi))
(setq Yi (cons ym Yi))
(if(= i 0) (setq Laux(list xm ym))) ;; Pto medio, para el texto i
(setq i (+ i 1))
(setq Xi (cons (/ (+ (nth i X) xu) 2) Xi))
181
(setq Yi (cons (/ (+ (nth i Y) yu) 2) Yi))
(setq X (reverse Xi) Y (reverse Yi))
(defun c:Sierpi()
(setq op (strcase (getString "Desea borrar todo [s/n]") T))(terpri)
(if (= op "s") (command "erase" "all" ""))
(LeerPtos)
(DibuPoli)
(setq np (getInt "Número de Subpoligonos: "))(terpri)
(setq ci 1) ;; contador visualizable de poligonos
(repeat np
(nuevasCoord)
(command "text" "j" "m" Laux (/ dis 10) "" (itoa ci))
(DibuPoli)
(setq ci (+ ci 1))
182
TEMA 7
183
184
Programación en DCL y AutoLISP
Para mejor comprensión de la Programación con DCL (Dialogue Control
Language o Lenguaje de Control de Diálogos) extensión por defecto de los
ficheros texto creados para este propósito, se recomienda tener base o cierta
familiaridad con AutoLisp, en lugar de reescribir lo que se puede encontrar en
los manuales (disponibles en las ayudas de la misma empresa AutoDesk), se
enfatiza en los ejemplos casi de forma intuitiva, con la ayuda de algún material
disponible en la red web.
Los archivos .DCL son archivos de texto llano, como los archivos .MNU o
.LSP. Desde un fichero de AutoLISP se invoca referencia a los archivos .DCL
para mejorar la comunicación con el usuario. Esta es la función del DCL,
facilitar el empleo de sus programas. Los archivos .DCL y .LSP operan de la
misma manera en los entornos DOS, Windows, Sun y Mac, a pesar que los
tamaños de los letreros variarán en función de las resoluciones de la pantalla.
Algunas veces será necesario reajustar un letrero para emplearlo en diferentes
plataformas. Para tener una idea de lo que estamos hablando emplee la orden
_DDMODIFY.
_DDMODYFY no es una orden en el sentido literal de la palabra. Es una rutina

externa en AutoLISP y su correspondiente archivo DCL que se cargan al
comienzo de una sesión de dibujo. Como cualquier otra rutina AutoLISP
cargada al comienzo de una sesión, puede dar al usuario la impresión de que se
trata de una orden. No obstante recibimos el mensaje «Inicializando...» cuando
empleamos la orden por primera vez. Se ha dispuesto de órdenes para
CAMBIAR entidades desde que AutoCAD nació, pero al aparecer nuevos
entornos, ha resultado más fácil comprender todas las opciones que algunas
órdenes necesitan. DCL proporciona un interfaz de aspecto similar al Windows
incluso para la versión DOS.
Empecemos creando nuestro primer letrero. Requerirá que creemos un archivo

ASCII llamado primero.DCL y otro primero.LSP. Comencemos por archivo
primer.LSP. Escriba lo siguiente:
185
(defun c:primer()
(setq dcl_id(load_dialog "primero.DCL"))
(new_dialog "dialog1" dcl_id)
(start_dialog)
(unload_dialog dcl_id)
(princ)
)
Veamos, la forma en que esto funciona es mediante una serie de nuevas

funciones en AutoLISP que describen como se deben comportar los letreros
DCL. La orden (load_dialog) solicita el nombre del archivo .DCL que se ha de
cargar. Devuelve el valor que asignamos a la variable dcl_id. La orden
(new_dialog) especifica cual del los letreros del archivo .DCL se empleara (los
archivos .DCL pueden contener varias definiciones de letreros diferentes. La
orden (start_dialog) indica que se realice la acción, y por último una vez que se
ha salido de la rutina, el letrero se descarga.
Generemos un archivo ASCII llamado primero.DCL:
dialog1 : dialog {
label = ”Titulo” ;
: button {
label = ”VALE”;
is_cancel = true;
}
}
El lenguaje DCL algo parecido al lenguaje C. “dialog1” es el nombre de la

secuencia del diálogo, a la que se ha hecho referencia anteriormente en la rutina
de AutoLISP con la orden (new_dialog). Lo que sigue a “dialog1” son los
componentes con atributos. Hay muchos tipos de componentes, de los que
hemos utilizado el componente de diálogo (:dialog) y la casilla de acción
(:button). Cada uno de los componentes emplea un formato similar a:
:<tipo de componente>{
186
<atributo>;
<atributo>;
<...>;
}
Si nos fijamos en el componente :dialog, vemos que tiene varios posibles

atributos incluyendo label, que es la cadena de texto que se muestra en la barra
de título. En el componente :button, vemos los atributos label y is_cancel.
Nótese que los atributos llevan el singo (;) tras de sí y que los componentes
emplean {} para indicar cuales son los atributos que les pertenecen.
Copie los dos archivos en su directorio de trabajo, e introduzca:
Orden: (load “primero”)
Orden: primer
Aparecerá un letrero de diálogo con el título que haya incluido en label y con un
botón con el mensaje que haya puesto en su label correspondiente. Cuando
pulse el botón se finalizará el letrero.
Ejercicio 1
Como es prudente comenzar sin prisas, modifique las cadenas de texto para ver
las diferencias. Intente lo siguiente:
dialog1 : dialog {
label = “Esta es mi primera rutina DCL” ;
: button {
label = “Funciona!”;
is_cancel = true;
}
}
Ejercicio 2
187
Modifique su archivo DCL como sigue:
dialog1:dialog
{ label = "Esta es mi primera rutina DCL.-";
:button
{ label = "Nada";
}
:button
{ label = "Nada tambien";
}
:button
{ label = "Cancelar";
is_cancel= true;
}
}¿Qué sucede? ¿Comprende por qué? El siguiente paso será crear botones que
realicen diferentes operaciones.
Como en una película, el DCL tiene un gran número de personajes, que se

denominan componentes. En el ejemplo anterior, se emplearon dos de ellos
:dialog y :button.
La sintaxis de :dialog. Verá que posee dos parámetros, label y value. Label
indica que si tiene asignada una cadena entre comillas (“Titulo”), la mostrará en
la barra de título de la ventana del letrero de diálogo.
Compruebe ahora la sintaxis para :button; comprobará que posee los parámetros
label, is_default, is_cancel. El último indica que si está establecido como true, el
usuario puede seleccionar dicho botón para cancelar el letrero. También se nos
indica que dentro de un letrero de diálogo solamente un botón puede tener esta
cacterística. label es el texto que muestra el botón.
Muchos de los componentes tienen atributos como label y value, pero cada uno
de ellos tiene sus reglas particulares por lo que deberá conocerlos todos. Todos
los componentes tienen un nombre personal que se llama key. Dando este
188
nombre particular a cada componente, podemos realizar tareas específicas
cuando nuestra rutina AutoLISP escucha la llamada a un nombre. En los
archivos DCL y LSP siguientes, note que hemos añadido un key a muchos
componentes. Esto le permitirá a la rutina LISP decir “¡eh, si oigo que llaman a
alguien, voy a hacer algo!. En ellos también se introduce otro tipo de
componente ... :text. Escriba lo siguiente como archivos segundo.DCL y
segundo.LSP:
dialog1:dialog
{ label = "Segundo Dialogo DCL.-";
:text
{ label = "El Boton #1:";
}
:button
{ label = "Boton-1";
key = "Tarzan";
is_default = true;
}
:text
{ label = "El Boton #2:";
}
:button
{ label = "Boton-2";
key = "Jane";
}
:text
{ label = "Pulse este boton para salir.";
}
:button
{ label = "Cancelar";
is_cancel= true;
}
}
189
(defun c:segundo()
(setq dcl_id(load_dialog "segundo.DCL"))
(new_dialog "dialog1" dcl_id)
(defun subr1()
(alert "Seleccionado Boton-1.")
)
(defun subr2()
(alert "Seleccionado Boton-2.")
)
(action_tile "Tarzan" "(subr1)")
(action_tile "Jane" "(subr2)")
(start_dialog)
(princ)
)
Veamos qué es lo que sucede en cada uno.

dialog1 : dialog {
label = ”Mi Segundo Dialogo” ;
[Hemos visto como funciona esta parte.]
: text {
label = “El boton #1:”;
}
[Este es un nuevo tipo de componente. Tiene un label únicamente. Este texto se
escribe por encima del boton 1 por que está primero.
: button {
label = “Boton #1”;
key = “Tarzan”;
is_default=true;
}
[Este componente tiene un key porque realizará alguna función más adelante
cuando sea seleccionado. También emplea el parámetro is_default de modo que
cuando arranque el programa, este botón será el botón de selección por defecto.
190
Si el usuario pulsa ENTER, se selecciona este botón. Al seleccionarlo DCL grita
“Tarzan”.]
: text {
label = ”El boton #2:”;
}
[Más texto.]
: button {
label = “Boton #2”;
key = “Jane”;
}
[Nuestro segundo botón tiene también un key. Cuando se selecciona, DCL le
grita “Jane” a la rutina AutoLISP.]
: text {
label = “Pulse este boton para salir.”;
}
[Más texto.]
: button {
label = “Cancelar”;
is_cancel=true;
}
[Este es nuestro botón de salida. Tiene el atributo is_cancel de modo que si se
pulsan ESC ó CTRL+C, finaliza la rutina.]
}
[Esto cierra el :dialog del comienzo.]
Veamos ahora la rutina AutoLISP:
(defun C:segundo ()
;; carga de los dcl y dialog adecuados
(setq dcl_id (load_dialog “segundo.dcl”))
(new_dialog “dialog1” dcl_id)
[Esto no ha cambiado desde nuestra primera rutina DCL.]
; qué deben hacer los botones al seleccionarlos
(defun subr1 ()
(alert “Seleccionado boton 1.”)
)
191
[Esta es una subrutina llamada “subr1” que se pondrá en funcionamiento cuando
se seleccione el Boton 1 y grite “Tarzan”.
(defun subr2 ()
(alert “Seleccionado boton 2 .”)
)
[Esta es una subrutina llamada “subr2” que se pondrá en funcionamiento cuando
se seleccione el Boton 2 y grite “Jane”.
; control de botones y rutina a ejecutar
(action_tile “Tarzan” “(subr1)”)
(action_tile “Jane” “(subr2)”)
[“action_tile” es una orden que se encuentra a la espera de que se llamen
nombres. Cuando se grita uno de los nombres, como “Tarzan”, le comunica a
AutoLISP que es lo que se debe hacer a continuación, en este caso ejecutar
“subrtn1”.
; que comience a rodar
(start_dialog)
[ Igual que antes.
(princ)
)
Por tanto el formato para esta rutina AutoLISP es:

a. inicializar el diálogo
b. describir las subrutinas
c. colocar “action_tiles” que permanezcan a la escucha
d. comenzar el letrero de diálogo
e. descargar el letrero
Prueba-2
midlg : dialog {
label = "Ejemplo de un cuadro
de diálogo";
192
: boxed_column {
label = "Componentes:";
: edit_box {
label = "&Cuadro de texto:";
key = "txtTexto";
edit_width = 20;
edit_limit = 100;
allow_accept = true;
}
: button {
label = " &Ver texto escrito...";
key = "cmdBoton";
}
}
ok_cancel_help_errtile ;
}
(defun c:Pruebadcl()
; Conectando con el archivo y la estructura.
(setq ind (LOAD_DIALOG "PruebaDCl.dcl"))
; Se carga en memoria
(NEW_DIALOG "midlg" ind)
; Procedimientos
(valores)
(acciones)
; Se visualiza el cuadro.
(if (= 1 (START_DIALOG))(alert "Este fue un pequeño ejemplo de
como \n utilizar cuadros de diálogo DCL con LSP."))
; Descargamos el cuadro
(UNLOAD_DIALOG ind)
(princ)
)
(defun valores ()
; Se define los valores por defecto.
(SET_TILE "txtTexto" "Construcgeek") (MODE_TILE "txtTexto" 2)
(SET_TILE "error" "Aqui se pueden visualizar mensajes de
error")
193
)
(defun acciones()
(ACTION_TILE "cmdBoton" "(MostrarMsg)")
(ACTION_TILE "accept" "(aceptar)")
(ACTION_TILE "cancel" "(cancelar)")
(ACTION_TILE "help" "(ayuda)")
)
(defun MostrarMsg()
(setq TextoIngresado (GET_TILE "txtTexto"))
(setq msg (strcat "El texto ingresado es: " TextoIngresado))
(alert msg)
)
(defun aceptar()
(Setq TextoIngresado (GET_TILE "txtTexto"))
(if (/= TextoIngresado "")
(DONE_DIALOG 1)
(SET_TILE "error" "Debes de ingresar un texto antes de
continuar.")
)
)
(defun cancelar()
(DONE_DIALOG)
(princ "\nSe canceló el programa.")
)
(defun ayuda()
(alert "\nSe indica un archivo de ayuda.")
)
Ejemplo: Dibujar un arbolito de Navidad, leído los datos de:

Alto Total, Largo de la rama y Número de ramas, en un letrero
"DatosArbol.dcl".
// Fichero DCL Ejemplo1.DCL

DatosArbol : dialog {
label = "Arbol
Navideño.-";
initial_focus = "Alto";
: column {
: edit_box {
key = "alto";
label = "Alto
total: ";
edit_width = 20;
194
value = "100";
}
: edit_box {
key = "rama";
label = "Largo Rama: ";
edit_width = 20;
value = "60";
}
: edit_box {
key = "nrora";
label = "Nro. de ramas: ";
edit_width = 20;
value = "15";
}
ok_cancel;
}
}
;; Arbolito Navideño
( defun Datos()
(setq at (atoi(get_tile "alto")))
(setq lr (atoi(get_tile "rama")))
(setq nr (atoi(get_tile
"nrora")))
)
(defun Dibujar()
(setq rt (/ at 30.0))
(setq rr (/ lr 30.0))
(setq p1 (list 0 0 (- at lr)))
(setq pp (list 0 at))
(command "cylinder" p1 rr lr)
(command "view" "front")
(command "rotate" "l" "" pp 35)
(command "array" "l" "" "p" "0,0"
nr "" "")
(command "cylinder" "0,0" rt at)
(command "union" "all" "")
)
(defun c:Arbol()
(setq dcl_id (load_dialog "DatosArbol.dcl"))
195
(if (not (new_dialog "DatosArbol" dcl_id)) (exit))
(action_tile "cancel" "(setq ddiag 1) (done_dialog)")
(action_tile "accept" "(setq ddiag 2) (Datos) (done_dialog)")
(start_dialog)
(if (= ddiag 1)
(princ "\n \n Ejemplo Cancelado...\n")
)
(if (= ddiag 2)
(Progn
(Dibujar)
(princ "\n \n Ejemplo completado...")
)
)
(command "view" "swiso")
(princ)
)
Ejemplo: Dibujar un rodamiento, leyendo los datos en un letrero:

Punto de inicio o entrada de las coordenadas x,y (como punto de
inicio), el radio externo, radio interno y grosor de cubierta.
// Fichero almacenado como: Roda.dcl

formRoda:dialog
{ label = "Rodamiento ";
:row
{ :button
{ label="Pto.Inicio";
key = "pto";
fixed_width =
true;
}
:edit_box
{ label = "Coor. X:
";
width = 10;
key = "xi";
fixed_width = true;
}
:edit_box
{ label = "Coor. Y: ";
width = 10;
key = "yi";
196
fixed_width = true;
}
}
:row
{ :edit_box
{ label = "Radio Interno:";
key = "ri";
width = 5;
fixed_width = true;
}
:edit_box
{ label = "Radio Externo:";
key = "re";
width = 5;
fixed_width = true;
}
}
:row
{ :edit_box
{ label = "grosor cubierta:";
key = "gc";
width = 5;
fixed_width = true;
}
}
ok_cancel_help;
}
;; Dibujar un Rodamiento, Llamando al fichero Roda.dcl

(defun datos()
(setq ddl(load_dialog "Roda"))
(setq a 4)
(while (> a 2)
(new_dialog "formRoda" ddl)
(if(= xi nil)(setq xi 0))
(if(= yi nil)(setq yi 0))
(set_tile "xi" (rtos xi 2 2))
(set_tile "yi" (rtos yi 2 2))
(set_tile "ri" "80.00")
(set_tile "re" "100.00")
(setq re(get_tile "re"))
(setq gr (/ (atof re) 20.0))
(set_tile "gc" (rtos gr 2 2))
197
(action_tile "pto" "(done_dialog 3)")
(action_tile "accept" "(lee)(done_dialog 1)")
(action_tile "cancel" "(done_dialog 0)")
(setq a (start_dialog))
(if(= a 3)(punto))
)
)
(defun punto()
(setq p0 (getpoint "Punto Inicio: "))
(setq xi(car p0) yi(cadr p0))
)
(defun lee()
(setq xi(get_tile "xi"))
(setq yi(get_tile "yi"))
(setq ri(get_tile "ri"))
(setq re(get_tile "re"))
(setq gr(get_tile "gc"))
(setq xi(atof xi))
(setq yi(atof yi))
(setq ri(atof ri))
(setq re(atof re))
(setq gr(atof gr))
)
(defun Construir()
(setq es(- re ri))
(setq p0 (list xi yi))
(command "cylinder" p0 (+ re
gr) es)
(prompt "Todo bien-1...")
(command "cylinder" p0 re es)
(setq pm (list (car p0) (cadr p0)(- (/ es 2))))
(command "move" "l" "" p0 pm)
(command "cylinder" p0 ri es)
(command "cylinder" p0 (- ri gr) es)
(command "move" "l" "" p0 pm)
(setq rm (/ (+ ri re) 2))
198
(setq la (* (* rm 2.0) PI))
(setq n (fix (/ la es)))
(setq p1 (list (+ rm (car p0)) (cadr p0)))
(command "sphere" p1 (/ es 2.0))
(command "array" "l" "" "p" p0 n "" "")
(command "-view" "swiso")
(command "vscurrent" "C")
)
(defun c:Rodar()
(command "-view" "front")
(command "vscurrent" "2D")
(setq op (strcase (getString "Desea borrar todo [s/n]") T))
(terpri)
(if (= op "s") (command "erase" "all" ""))
(datos)
(if(= a 1)(Construir))
)
Ejemplo: Escalera circular, leyendo los datos como muestra el

letrero correspondiente (las cajas de edición pueden contener
información por defecto).
// Fichero DCL Escalera Circular, escir.DCL

EscCirc : dialog {
label = "Datos Escalera-Circular.-";
initial_focus = "PaInt";
: column {
: edit_box {
key = "PaInt";
label = "Paso
Interior: ";
edit_width = 15;
value = "15";
}
: edit_box {
key = "PaExt";
label = "Paso
Exterior: ";
edit_width = 15;
value = "30";
}
: edit_box {
199
key = "AnGra";
label = "Ancho Grada: ";
edit_width = 15;
value = "80";
}
: edit_box {
key = "GrGra";
label = "Grosor Grada: ";
edit_width = 15;
value = "2.5";
}
: edit_box {
key = "AlTot";
label = "Altura Total: ";
edit_width = 15;
value = "300";
}
: edit_box {
key = "RaSop";
label = "Radio Soporte: ";
edit_width = 15;
value = "10";
}
: edit_box {
key = "Conpa";
label = "Contrapaso: ";
edit_width = 15;
value = "20";
}
ok_cancel;
}
}
;; Programa para diseñar gradas circulares.

( defun DatosEC()
(setq in (atof(get_tile "PaInt")))
(setq ex (atof(get_tile "PaExt")))
(setq la (atof(get_tile "AnGra")))
(setq al (atof(get_tile "GrGra")))
(setq ha (atof(get_tile "AlTot")))
(setq rc (atof(get_tile "RaSop")))
(setq co (atof(get_tile "Conpa")))
200
)
(defun DibGraCi()
(command "erase" "All" "")
(command "_-view" "_top")
(setq an 20.0)
(setq p0 (list 0.0 0.0))
(setq p1 (list 0.0 (/ in 2.0)))
(setq p2 (list la (/ ex 2.0)))
(setq p3 (list la (-(/ ex 2.0))))
(setq p4 (list 0.0 (-(/ in 2.0))))
(setq pe (list 0.0 0.0 co))
(setq c 0.0)
(command "cylinder" p0 rc ha)
(command "pline" p1 p2 p3 p4 "c")
(command "region" "l" "")
(command "extrude" "l" "" al "")
(while (<= c ha)
(command "copy" "l" "" p0 p0)
(command "rotate" "l" "" p0 an)
(command "move" "l" "" p0 pe)
(setq c (+ c co))
)
(command "_-view" "_seiso")
)
(defun c:grada()
(setq dcl_id (load_dialog "escir.dcl"))
(if (not (new_dialog "EscCirc" dcl_id)) (exit))
(action_tile "cancel" "(setq ddiag 1) (done_dialog)")
(action_tile "accept" "(setq ddiag 2) (DatosEC)
(done_dialog)")
(start_dialog)
(if (= ddiag 1)
(princ "\n Ejemplo Finalizado...\n")
)
(if (= ddiag 2)
(Progn
(DibGraCi)
(princ "\n \n Ejemplo completado...")
)
)
)
201
Ejemplo Transformación Geométrica, incluye las operaciones de
transformación como Traslación, Rotación y Escalación, cada uno
permite ingresar datos en letreros particulares, se deja como
ejercicio de complemento las operaciones de reflexión y
estiramiento.
// Fichero almacenado como: transdcl.dcl

ope2D:dialog
{ label = "Transformación Geométrica 2D.-";
:column
{ :button {label="Sel_Objeto:"; key="sel";}
:boxed_column
{ label="Operación:"; key= "opcion";
:radio_button {label="Trasladar"; key="tra";}
:radio_button {label="Rotar"; key="rot";}
:radio_button {label="Escalar"; key="sca";}
:radio_button {label="Reflejar"; key="ref";}
:radio_button {label="Estirar"; key="est";}
}
}
ok_cancel;
}
traslada:dialog
{ label = "Parámetros de
Traslación:";
:row
{:edit_box
{ label = "tx: ";
width = 6;
key = "tx";
fixed_width = true;
}
:edit_box
{ label = "ty: ";
width = 6;
key = "ty";
fixed_width = true;
}
}
ok_cancel;
}
202
rota:dialog
{ label = "Angulo de rotación:";
:edit_box
{ label = "Angulo(grados):";
key = "ang";
width = 6;
fixed_width = true;
}
}
escala:dialog
{ label = "Parámetro de escalación:";
:edit_box
{ label = "Parámetro de
Escalación:";
key = "sxy";
width = 6;
fixed_width = true;
}
ok_cancel;
}
;; Operaciones de transformación en 2D, Llamando al fichero

TransDCL.dcl
(defun form1()
(setq ddl(load_dialog "OpeTra"))
(setq a 7)
(while (> a 5)
(new_dialog "ope2D" ddl)
(action_tile "sel" "(done_dialog 6)")
(action_tile "tra" "(done_dialog 1)")
(action_tile "rot" "(done_dialog 2)")
(action_tile "esc" "(done_dialog 3)")
(action_tile "accept" "(done_Dialog 1)")
(cond ((= b 3)(traslacion) (if(/= b 3)(setq

a(start_dialog))))
((= b 4)(rotacion) (if(/= b 4)(setq
a(start_dialog))))
((= b 5)(escalacion)(if(/= b 5)(setq
a(start_dialog))))
203
;; ((= b 6)(reflexion)(if(/= b 6)(setq
a(start_dialog))))
;; ((= b 7)(estiramiento)(if(/= b 7)(setq
a(start_dialog))))
(T (setq a (start_dialog)))
)
(cond ((= a 6)(objetos))
((= a 1)(traslacion))
((= a 2)(rotacion))
((= a 3)(escalacion))
)
)
)
(defun objetos()
(setq obj(ssget))
)
(defun traslacion()
(new_dialog "traslada" ddl)
(if(= tx nil)(setq tx 0.0))
(if(= ty nil)(setq ty 0.0))
(set_tile "tx"(rtos tx 2 2))
(set_tile "ty"(rtos ty 2 2))
(action_tile "accept" "(trasla)") ;;(done_dialog 1)")
(setq b(start_dialog))
;;(if(= b 3)(done_dialog))
)
(defun trasla()
(setq tx(get_tile "tx"))
(setq ty(get_tile "ty"))
(setq tx(atof tx))
(setq ty(atof ty))
(setq p1 (list tx ty))
)
(defun rotacion()
(new_dialog "rota" ddl)
(if(= ang nil)(setq ang 0.0))
(set_tile "ang"(rtos ang 2 2))
(action_tile "accept" "(rot)(done_dialog 1)")
204
)
(defun rot()
(setq ang(get_tile "ang"))
(setq ang(atof ang))
)
(defun escalacion()
(new_dialog "escala" ddl)
(if(= sxy nil)(setq sxy 1))
(action_tile "accept" "(esca)(done_dialog 1)")
)
(defun esca()
(setq sxy(get_tile "sxy"))
(setq sxy(atof sxy))
)
(defun c:OT1()
(form1)
(if(= a 1)(command "move" obj "" "0,0" p1))
(if(= a 2)(command "rotate" obj "" "0,0" ang))
(if(= a 3)(command "scale" obj "" "0,0" sxy))
)
205

Linea

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Linea

Загружено:

Авторское право:

Доступные форматы

2015

TEXTO GUÍÍA RECOPÍLADO:

Programacioó n Graó fica

Sistemas e Informatica - F.N.I.

EL PROCESO DE OBTENCIÓN DE IMÁGENES..........................................................................27

ESPECIFICACIÓN DE UNA DISCRETIZACION...........................................................................42

DIBUJO DE LÍNEAS RECTAS................................................................................................... 42

ALGORITMOS BASICOS PARA CIRCULOS...............................................................................62

ALGORITMOS PARA ELIPSES................................................................................................ 74

TRANSFORMACIONES GEOMETRICAS EN 2-D..............................................82

QUE ES UNA TRANSFORMACION?.......................................................................................82

TRANSFORMACIÓN VENTANA-ÁREA DE VISTA...................................................................100

VISION TRIDIMENSIONAL................................................................................ 108

COORDENADAS HOMOGENEAS......................................................................................... 108

SISTEMA DE LA MANO DERECHA.......................................................................................109

SISTEMA DE LA MANO IZQUIERDA.....................................................................................110

TRANSFORMACIONES EN 3D............................................................................................. 110

COMPOSICION DE TRANSFORMACIONES EN 3D.................................................................118

QUE ES UNA PROYECCION?............................................................................................... 121

PROYECCIONES GEOMÉTRICAS PLANARES.........................................................................122

CLASIFICACIÓN DE LAS PROYECCIONES..............................................................................123

PROYECCIÓN EN PERSPECTIVA........................................................................................... 124

PROYECCIÓN PARALELA..................................................................................................... 127

DETERMINACIÓN DE SUPERFICIES VISIBLES............................................137

SUPERFICIE VISIBLE........................................................................................................... 137

ALGORITMO DE PRECISIÓN DE OBJETO..............................................................................138

ALGORITMO DE PRECISIÓN DE IMAGEN.............................................................................139

DIFERENCIAS PRECISIÓN DE OBJETO VS PRECISIÓN DE IMAGEN.........................................140

CLASIFICACIÓN DE LOS ALGORITMOS................................................................................140

Comandos de programación.-............................................................................................ 159

Utilización de Listas.-......................................................................................................... 160

UTILIZACIÓN DE LAS FUNCIONES DEL TIPO GET..................................................................161

Programación en DCL y AutoLISP.................................................................180

El estudiante conocerá los pasos a realizar para el proceso de obtención de una

o “Imaging”: Cómo representar imágenes en 2D.

o Proyecto para entrenamiento en lanzamiento de bombas (líder: Jay Forrester)

1949: “Pistola de Luz” (Computador SAGE)

o SAGE: Semi-Automatic Ground Environment

1956: TX-0 y TX-2 (MIT)

1963: Sketchpad (tesis doctoral)

o Software para TX-2

1962: Society for Information Display (SID): Investigación, diseño, manufactura,

1963: DAC SYSTEM (General Motors)

o DAC: Design Augmented by Computers – primer sistema de dibujo para

1964: Tableta gráfica (RAND Corp.)

1972: “PONG” (ATARI)

1977: APPLE II (APPLE)

 Computador con texto y gráficos en la misma pantalla

INICIOS DE LOS 80’

 Revolución de la microminiaturización de componentes

Diseño asistido por computador

– Técnica habitual: diseño basado en primitivas constructivas.

– Como característica común, el computador es usado para la visualización

– Uso de los gráficos para producción de ilustraciones de soporte a informes y

– En este campo se producen imágenes con un fin artístico o comercial:

Inicios: Uso de dispositivos Vectoriales (Caligráficos).

Se basan en la tecnología del Tubo de Rayos Catódicos (TRC o CRT)

Tecnología de Salida: Raster-Scan

• El cañón emite electrones (cátodo).

• La intensidad del rayo se controla con la rejilla.

• El enfoque hace que los electrones describan una trayectoria convergente.

• El rayo impacta contra el fósforo que emite luz.

• La emisión del fósforo decae rápidamente, por lo que se necesita un refresco

Caracteristicas de la Tecnología de Salida: Raster-Scan