UNIVERSIDAD TECNOLÓGICA DE PANAMÁ

CENTRO REGIONAL DE CHIRIQUÍ

FACULTAD DE INGENIERÍA DE SISTEMAS COMPUTACIONALES
DEPARTAMENTO DE COMPUTACIÓN Y SIMULACIÓN DE COMPUTADORAS
GUÍA DE LABORATORIO N°2

Facilitadora: _Licda. Gabriela Caballero de Hislop, M.Sc.__ Asignatura: _Herramientas de Computación Gráfica
Fecha: _4-10-2022__ Grupo:_2IL131_
Estudiante(s): __Cesar Marquinez

A. TÍTUL0 DE LA EXPERIENCIA: Algoritmos de discretización de primitivas geométricas

B. TEMAS: Esta es una asignación introductoria correspondiente al punto 2 del Módulo II del curso.
2. Algoritmos de discretización de primitivas geométricas.
2.1. Algoritmo DDA
2.2. Algoritmo de Bresenham
2.3. Algoritmo del punto medio para círculos
2.4. Algoritmo del punto medio para elipses

C. OBJETIVOS:

Objetivo General:
 Implementar los algoritmos para el dibujo de líneas utilizando Visual C++ con OpenGL.

Objetivos Específicos:
 Comprender los pasos que sigue el algoritmo analizador diferencial digital (DDA, Digital Differential
Analyzer), basado en la ecuación de la recta.
 Crear un proyecto en Visual C++ que permita implementar el algoritmo DDA con OpenGL.

D. METODOLOGÍA: La asignación es individual y se debe desarrollar durante la sesión de clases.

E. PROCEDIMIENTO O ENUNCIADO DE LA EXPERIENCIA:

 Identifica los objetivos de la actividad.

 Lee con atención las indicaciones en el documento que contiene el laboratorio a realizar.
 Aplica el procedimiento demostrado en clases para crear proyectos Visual C++ con OpenGL.
 Escribe tus observaciones sobre el desarrollo del Laboratorio al final de la rúbrica de evaluación,
detallando los logros, las dificultades y los aprendizajes.
 Subir un archivo comprimido que contenga el proyecto puesto a punto y la Guía del Laboratorio. (Ver
rúbrica de evaluación del trabajo de laboratorio.)
F. RECURSOS:
Los estudiantes utilizarán los equipos computacionales disponibles en el laboratorio o en su defecto, los propios,
así como los recursos disponibles en la plataforma Moodle.
G. RESULTADOS: Es de esperar que cada estudiante:
 Implemente un programa C++ con OpenGL, que cumpla con los requisitos del enunciado.
 Guarde en una carpeta propia el programa creado, pues será utilizado como referencia en la tarea que
debe desarrollar aplicando el algoritmo estudiado en este laboratorio.
 Complete la guía didáctica de actividad (apartado H) para esta asignación y la adjunte a los archivos
entregados.

H. CONSIDERACIONES FINALES: (Incluya en este apartado su opinión sobre el logro de los objetivos y el desarrollo de la
asignación. Cada grupo debe subir esta guía, así como el documento escrito de su trabajo y la presentación )
__Se debe tener en cuenta la función glbegin ya se con el parámetro LINES o POINTS para ejecutar
tanto el algoritmo DDA como el dibujo de una línea. ___

J. BIBLIOGRAFIA: (Pueden ampliar los recursos bibliográficos. Anótenlos en esta sección.)

1. Hearn, Donald y Pauline Baker. Gráficos por Computadora con OpenGL. Editorial Pearson/Prentice
Hall, 2006.

K. RÚBRICAS:
Evaluación:
Archivo del proyecto 40 puntos
Guía de la actividad completa 10 puntos
Total 50 puntos

Usaremos la rúbrica de evaluación presentada a continuación para evaluar la realización eficiente de este
Laboratorio.
 RÚBRICA PARA EVALUAR TAREAS/LABORATORIOS PROGRAMADOS INDIVIDUALMENTE

PRESENTACIÓN

Criterios de Excelente Bueno Regular Deficiente Ineficiente

Evaluación 4 3 2 1 0
Entrega en la
Entrega en la fecha Entrega con un Entrega con dos Entrega con tres
1. Puntualidad fecha, pero no a
y hora señalada día de atraso. días de atraso. días de atraso.
la hora señalada
En el programa se En el programa se En el programa El programa no
En el programa se
identifican identifican no se identifican identifica los
identifican
adecuadamente adecuadamente la mayoría de los procedimientos y
adecuadamente los
la mayoría de los la mayoría de los procedimientos y no describe su
2. Organización procedimientos y
procedimientos y procedimientos y no se describe su función mediante
se describe su
se describe su se describe su función mediante comentarios
función mediante
función mediante función mediante comentarios
comentarios
comentarios comentarios
Presenta uno o Presenta tres o Presenta cinco o Presenta muchos
Mantiene buena
3. Ortografía dos errores cuatro errores seis errores errores
ortografía.
ortográficos. ortográficos. ortográficos. ortográficos.
DESARROLLO
Criterios de
Excelente Bueno Regular Deficiente Ineficiente
Evaluación
La ejecución del La ejecución del La ejecución del La ejecución del La ejecución del
proyecto cumple al proyecto cumple proyecto cumple proyecto cumple proyecto no
1. Solución del
100% con lo que se con 80% de lo con 60% de lo con 40% de lo cumple con lo
problema
solicita en el que se solicita en que se solicita en que se solicita en que se solicita en
(Eficiencia)
enunciado. el enunciado. el enunciado. el enunciado. el enunciado.
20 15 10 5 0
El proyecto posee El proyecto no El proyecto no El proyecto no
El proyecto una buena posee una buena posee una buena posee una
muestra una muy estructura, estructura, y no estructura, lo que estructura
buena estructura aunque no facilita facilita mucho la dificulta la identificable, lo
2. Estructura de
que permite la mucho la legibilidad y legibilidad y que dificulta la
la solución
legibilidad y legibilidad y comprensión del comprensión del legibilidad y
planteada
comprensión del comprensión del mismo. mismo. comprensión del
mismo. mismo. mismo.
8 6 0
4 2
 UNIVERSIDAD TECNOLÓGICA DE PANAMÁ
FACULTAD DE INGENIERÍA DE SISTEMAS COMPUTACIONALES
DEPARTAMENTO DE COMPUTACIÓN Y SIMULACIÓN
HERRAMIENTAS DE COMPUTACIÓN GRÁFICA

Laboratorio No. 2
Tema: Algoritmo DDA para discretización de líneas
Descripción de la actividad:
En este laboratorio deberá crear un programa con C++ y OpenGL. Utilice como base la estructura del
programa visto en el laboratorio anterior.
El objetivo es implementar el algoritmo DDA, por lo tanto, asegúrese de que comprende las
instrucciones del mismo. Es fundamental entender qué hace cada una de las funciones del programa y
de las líneas de instrucción que las conforman. Lea detenidamente los comentarios que acompañan al
segmento de código que corresponde al algoritmo y pregunte a la docente si tiene dudas.
Algoritmo DDA:
El código siguiente dibuja un segmento bidimensional definiendo sus extremos con coordenadas
cartesianas enteras.
/**************************
* Includes adicionales
**************************/
#include <stdlib.h>
#include <math.h>

/*** Declaración de la función de redondeo ***/

inline int round (const float a) {return int (a + 0.5);}

//
/***** Incluya aquí la función init()*****/
//

/************************************
* La función setPixel dibuja un punto del segmento de línea en la ventana de visualización;
* se le llama cada vez que se determina un nuevo valor de coordenadas x, y.
************************************/
void setPixel (int xCoord, int yCoord)
{
glBegin (GL_POINTS);
glVertex2i(xCoord, yCoord);
glEnd();
}

/************************************
* La función lineDDA implementa el algoritmo en estudio.
************************************/
void lineDDA (int x0, int y0, int xEnd, int yEnd)
{
int dx=xEnd – x0, dy=yEnd – y0, steps, k;
float xIncrement, yIncrement, x = x0, y = y0;

if (abs(dx) > abs (dy))

steps = abs (dx);
else
steps = abs(dy);

xIncrement = float (dx) / float (steps);

yIncrement = float (dy) / float (steps);

setPixel (round (x), round(y));

for (k=0; k< steps;k++) {
x+= xIncrement;
y+= yIncrement;
setPixel (round (x), round(y));
}
}

/*************************************
* Finalmente, el procedimiento "dibuja" contiene la llamada al algoritmo de generación de líneas que
* queremos implementar y es el procedimiento que será referenciado por glutDisplayFunc
*************************************/
void dibuja(void)
{
glClear (GL_COLOR_BUFFER_BIT); // Borra la vent. de visualización
glColor3f (1.0, 0.0, 0.0); // Establece el color para el segmento de línea en rojo

/**** asigne los valores iniciales a las coordenadas de los extremos del segmento de línea****/
int x0, y0, xEnd, yEnd; // Estos son los parámetros que debe enviar al procedimiento DDA. Inícielos.
lineDDA(x0, y0, xEnd, yEnd); // llamada a la función lineDDA con paso de parámetros
glFlush(); // Procesa todas las subrutinas OpenGL tan rápidamente como sea posible
}

//
/***** Incluya aquí la función main()*****/
//
Este algoritmo acepta como entrada dos posiciones enteras correspondiente a los dos extremos del
segmento de línea (las cuales usted debe inicializar en la función dibuja). Las diferencias
horizontales y verticales entre los dos extremos se asignan a los parámetros dx y dy. La diferencia
con mayor valor absoluto determina el valor del parámetro steps. Partiendo de la posición (x0, y0),
determinaremos el desplazamiento requerido en cada paso para generar el siguiente píxel de la
línea. Este proceso se ejecuta en un bucle (ciclo for) un número de veces igual a steps. Si el módulo
(residuo) de dx es superior al módulo de dy y x0 es inferior a xEnd, los valores de los incrementos
en la direcciones x e y son 1 y m, respectivamente. Si el cambio mayor se realiza en la dirección x,
pero x0 es superior a xEnd, entonces se utilizan los decrementos -1 y -m para generar cada nuevo
punto en la línea. En los restantes casos, utilizamos un incremento (o decremento) unitario en la
dirección y, y un incremento (o decremento) para x igual a 1/m.
Su programa debería imprimir cuatro líneas como las que se muestran a continuación (llamar a la función DDA 4 veces).

Compare la línea generada a través del algoritmo con una paralela en cada caso (ver líneas rojas), impresa con las
coordenadas que usted desee, pero usando la función GL_LINES, como la del programa base del laboratorio 1.
 UNIVERSIDAD TECNOLÓGICA DE PANAMÁ
CENTRO REGIONAL DE CHIRIQUÍ
FACULTAD DE INGENIERÍA DE SISTEMAS COMPUTACIONALES
DEPARTAMENTO DE COMPUTACIÓN Y SIMULACIÓN DE COMPUTADORAS
CUADRO DE CALIFICACIÓN PARA EVALUAR TAREAS/LABORATORIOS DE PROGRAMACIÓN
GUÍA DEL ESTUDIANTE

TAREA/LABORATORIO No.: _2_

TEMA: __ Algoritmo DDA
Estudiante: ___Cesar Marquínez____ Cédula: __4-809-1830___

Criterios de evaluación de la actividad. (Puntos totales 40)

Elemento a Evaluar Puntaje máximo Puntaje obtenido

1. Puntualidad 4
Presentació
2. Organización 4
n
3. Ortografía 4
1. Solución del problema
20
(Eficiencia)
Desarrollo
2. Estructura de la solución
8
planteada
Entregó la guía de la Actividad completa 10

Total

Fecha___________________________________

Observaciones del estudiante (detalle logros, dificultades y aprendizajes ) _______Las líneas porporcionadas
por el comando de glbegin Lines dibuja mejor las líneas que el mismo algortimo por puntos de DDA
____________________________________________________________________________________________
____________________________________________________________________________________________
____________________________________________________________________________________________
____________________________________________________________________________________________
____________________________________________________________________________________________
_
 Ejecución del código

Código fuente
#include <windows.h>
#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>

/*** Declaración de la función de redondeo ***/

inline int round(const float a) { return int(a + 0.5); }

//
void init(void)
{
glClearColor(1.0, 1.0, 1.0, 0.0); // Establece el color de la ventana de visualización
glMatrixMode(GL_PROJECTION); // Establece los parámetros de
gluOrtho2D(0.0, 180.0, 0.0, 150.0); // proyección
}
//

/************************************
* La función setPixel dibuja un punto del segmento de línea en la ventana de visualización;
* se le llama cada vez que se determina un nuevo valor de coordenadas x, y.
************************************/
void setPixel(int xCoord, int yCoord)
{
glBegin(GL_POINTS);
glVertex2i(xCoord, yCoord);
glEnd();
}

/************************************
* La función lineDDA implementa el algoritmo en estudio.
************************************/
void lineDDA(int x0, int y0, int xEnd, int yEnd)
{
int dx = xEnd - x0, dy = yEnd - y0, steps, k;
float xIncrement, yIncrement, x = x0, y = y0;

if (abs(dx) > abs(dy))

steps = abs(dx);
else
steps = abs(dy);

xIncrement = float(dx) / float(steps);

yIncrement = float(dy) / float(steps);

setPixel(round(x), round(y));
for (k = 0; k < steps;k++) {
x += xIncrement;
y += yIncrement;
setPixel(round(x), round(y));
}
}

/*************************************
* Finalmente, el procedimiento "dibuja" contiene la llamada al algoritmo de generación de líneas que
* queremos implementar y es el procedimiento que será referenciado por glutDisplayFunc
*************************************/
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT); // Borra la vent. de visualización
glColor3f(1.0, 0.0, 0.0); // Establece el color para el segmento de línea en rojo
/**** asigne los valores iniciales a las coordenadas de los extremos del segmento de línea****/
int x0, y0, xEnd, yEnd; // Estos son los parámetros que debe enviar al procedimiento DDA. Inícielos.

lineDDA(20, 20, 20, 100); // linea vertical azul

lineDDA(27, 40, 70, 40);// linea horizontal azul
lineDDA(65, 20, 110, 60);// linea diagonal inclinacion a la derecha azul
lineDDA(106,86 ,155 ,40);// linea diagonal inclinacion a la izquierda azul

glColor3f(0, 0, 1);
glBegin(GL_LINES);

glVertex2f(15, 20);//linea azul vertical

glVertex2f(15, 100);

glVertex2f(27,45 );//linea azul horizontal

glVertex2f(70, 45);

glVertex2f(65, 25);//linea azul diagonal inclinado derecho

glVertex2f(110, 65);

glVertex2f(106, 90);//linea azul diagonal inlcinado izquierdo

glVertex2f(155, 44);

glEnd();
 glFlush(); // Procesa todas las subrutinas OpenGL tan rápidamente como sea posible
}

//
int main(int argc, char** argv)
{
glutInit(&argc, argv); // Incializa GLUT
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB); // Establece el modo de visualización
glutInitWindowPosition(50, 100); // Posición de la esquina sup. izqda. de la ventana de visualización
glutInitWindowSize(400, 300); // Ancho y altura de la ventana de visualización
glutCreateWindow("Programa OpenGL de Ejemplo"); // Crea la ventana de visualización
init(); // Ejecuta el procedimiento de inicialización
glutDisplayFunc(dibuja); // Envía los gráficos a la ventana de visualización
glutMainLoop(); // Muestra todo y espera
}