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°3

Facilitadora: _Licda. Gabriela Caballero de Hislop, M.Sc.__ Asignatura: _Herramientas de Computación Gráfica
Fecha: ______________ Grupo:_2IL131_
Estudiante(s): ____________________________________ ____________________________________

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 de Bresenham para la discretización de líneas, basado en la
ecuación de la recta.
 Crear un proyecto en Visual C++ que permita implementar el algoritmo de Bresenham 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 )
____________________________________________________________________________________
____________________________________________________________________________________
____________________________________________________________________________________
____________________________________________________________________________________
____________________________________________________________________________________

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. 3
Tema: Algoritmo de Bresenham 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 de Bresenham, 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 de Bresenham:
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 lineBresenham implementa el algoritmo en estudio.
************************************/
void lineBresenham (int x0, int y0, int xEnd, int yEnd)
{
int dx = fabs (xEnd – x0);
int dy = fabs (yEnd – y0);
int p = 2 * dy – dx;
int twoDy = 2 * dy;
int twoDyMinusDx = 2 * (dy – dx);
int x, y;

/* Determinar qué extremo usar como posición inicial */

if (x0 > xEnd) {
x = xEnd;
y = yEnd;
xEnd = x0;
}
else {
x = x0;
y = y0;
}
setPixel (x, y);

while (x < xEnd) {

x++;
if (p < 0)
p += twoDy;
else {
y++;
p += twoDyMinusDx;
}
setPixel(x,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.
lineBresenham(x0, y0, xEnd, yEnd); // llamada a la función lineBresenham con paso de parámetros
glFlush(); // Procesa todas las subrutinas OpenGL tan rápidamente como sea posible
}

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

.....
Como en el laboratorio anterior, su programa debería imprimir cuatro líneas como las que se muestran a continuación
(llamando a la función Bresenham 4 veces).
 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.: _3_

TEMA: ___ Algoritmo de Bresenham___
Estudiante: ___Cesar Marquinez_______ 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 ) _______Se realizaron cambios en el
algoritmo bresenham para poder graficar las retactas verticales
____________________________________________________________________________________________
___________________________________________
 Código fuente

#include <windows.h>
#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>
/*** Declaración de la función de redondeo ***/

//
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, 170.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 lineBresenham implementa el algoritmo en estudio.
************************************/

void lineBresenham(int x1, int x2, int y1, int y2) {

int dx, dy, i, e;
int incx, incy, inc1, inc2;
int x, y;

dx = x2 - x1;
dy = y2 - y1;

if (dx < 0) dx = -dx;

if (dy < 0) dy = -dy;
incx = 1;
if (x2 < x1) incx = -1;
incy = 1;
if (y2 < y1) incy = -1;
x = x1; y = y1;
if (dx > dy) {
setPixel(x, y);
e = 2 * dy - dx;
inc1 = 2 * (dy - dx);
inc2 = 2 * dy;
for (i = 0; i < dx; i++) {
 if (e >= 0) {
y += incy;
e += inc1;
}
else
e += inc2;
x += incx;
setPixel(x, y);
}

}
else {
setPixel(x, y);
e = 2 * dx - dy;
inc1 = 2 * (dx - dy);
inc2 = 2 * dx;
for (i = 0; i < dy; i++) {
if (e >= 0) {
x += incx;
e += inc1;
}
else
e += inc2;
y += incy;
setPixel(x, 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
glPointSize(3.0);
/**** asigne los valores iniciales a las coordenadas de los extremos del segmento de línea****/
// Estos son los parámetros que debe enviar al procedimiento DDA. Inícielos.
lineBresenham(20, 20, 20, 80);
lineBresenham(27, 70, 40, 40);
lineBresenham(65,110 ,20 , 60);
lineBresenham(106, 155,86 , 40); // llamada a la función lineBresenham con paso de parámetros
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
}
//

Ejecución del código