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°5
Facilitadora: _Licda. Gabriela Caballero de Hislop, M.Sc.__ Asignatura: _Herramientas de Computación Gráfica
Fecha: _8-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 un algoritmo para la generación de elipses utilizando Visual C++ con OpenGL.
Objetivos Específicos:
Comprender los pasos que sigue el algoritmo del punto medio para la generación de elipses.
Crear un proyecto en Visual C++ que permita implementar el algoritmo del punto medio para la
generación de elipses 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 estudiante/grupo debe subir esta guía, así como el documento escrito de su trabajo y la presentación )
__Es necesario tener en cuenta los cuadrantes al momento de modificar para así no cometer un error
de impresión no deseada_
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. 5
Tema: Algoritmo del punto medio para la generación de elipses
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 del punto medio para la generación de elipses, 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 del punto medio para la generación de elipses:
En términos simples, una elipse es un círculo alargado. También podemos describir una elipse como un
círculo modificado cuyo radio varía desde un valor máximo en una dirección hasta un valor mínimo en
la dirección perpendicular. Los segmentos de línea recta trazados en el interior de la
elipse en estas dos direcciones perpendiculares se denominan eje mayor y menor de
la elipse.
Al igual que con el algoritmo del círculo, pueden utilizarse consideraciones de
simetría para reducir los cálculos. Una elipse en posición estándar presenta simetría
entre los distintos cuadrantes, pero, a diferencia del círculo, los dos octantes de cada
cuadrante no son simétricos. El método del punto medio para la elipse se aplica en
dos partes para todo el primer cuadrante. La figura muestra la división del primer cuadrante de
acuerdo con la pendiente de una elipse con rx < ry. Se procesa este cuadrante tomando pasos unitarios
en la dirección x allí donde la pendiente de la curva tenga una magnitud inferior a 1.0 y luego tomando
pasos unitarios en la dirección y cuando la pendiente tenga una magnitud superior a 1.0.
En el siguiente segmento de código, se proporcionan procedimientos de ejemplo para la
implementación del algoritmo del punto medio para el cálculo de una elipse. Es necesario introducir en
el procedimiento ellipseMidpoint los parámetros de la elipse Rx, Ry, xCenter, e yCenter. Entonces se
calculan las posiciones a lo largo de la curva del primer cuadrante y dichas posiciones se pasan al
procedimiento ellipsePlotPoints. Se utilizan consideraciones de simetría para obtener las posiciones de
la elipse en los otros tres cuadrantes, y la rutina setPixel, asigna el color de la elipse a las posiciones del
búfer de imagen correspondientes a estas posiciones de pantalla.
/**************************
* Use como referencia de este algoritmo el código que se incluye en las páginas 119-120 del libro de Hearn
* y Baker, cuya bibliografía aparece en el documento Guía de Laboratorio.
**************************/
inline int round (const float a) {return int(a + 0.5);}
/* El siguiente procedimiento acepta valores que definen el centro
de la elipse y sus semiejes mayor y menor, calculando las
posiciones de la elipse mediant3e el algoritmo del punto medio.
*/
void setPixel (GLint xCoord, GLint yCoord)
{
glBegin (GL_POINTS);
glVertex2i (xCoord, yCoord);
glEnd ( );
}
void ellipseMidpoint (int xCenter, int yCenter, int Rx, int Ry)
{
int Rx2 = Rx * Rx;
int Ry2 = Ry * Ry;
int twoRx2 = 2 * Rx2;
int twoRy2 = 2 * Ry2;
int p;
int x = 0;
int y = Ry;
int px = 0;
int py = twoRx2 * y;
void ellipsePlotPoints (int, int, int, int)
/* Dibujar el punto inicial en cada cuadrante. */
ellipsePlotPoints (xCenter, yCenter, x, y);
/* Región 1. */
p = round (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;
}
ellipsePlotPoints (xCenter, yCenter, x, y);
}
/* Región 2. */
p = round (Ry2 *(x + 0.5) * (x + 0.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;
}
ellipsePlotPoints (xCenter, yCenter, x, y);
}
}
void ellipsePlotPoints (int xCenter, int yCenter, int x, int y);
{
setPixel (xCenter + x, yCenter + y);
setPixel (xCenter - x, yCenter + y);
setPixel (xCenter + x, yCenter - y);
setPixel (xCenter - x, yCenter - y);
. . . . . . . .
Una vez puesto a punto el programa que genera la elipse, guárdelo. Haga una copia de ese programa y
modifíquelo para que genere la siguiente salida:
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.: _5_
TEMA: __ Algoritmo del punto medio para elipses_
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 )
____________________________________________________________________________________________
____________________________________________________________________________________________
____________________________________________________________________________________________
____________________________________________________________________________________________
____________________________________________________________________________________________
___________________________________________________________________________________
Ejecución del Código
Código
#include <windows.h>
#include <GL/glut.h>
#include <stdlib.h>
#include <math.h>
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, 250.0, 0.0, 150.0); // proyección
}
void setPixel(GLint xCoord, GLint yCoord)
{
glBegin(GL_POINTS);
glVertex2i(xCoord, yCoord);
glEnd();
}
inline int round(const float a) { return int(a + 0.5); }
// 1/4 elipse izquierda
void ellipsePlotPoints(int xCenter, int yCenter, int x, int y)
{
setPixel(xCenter + x, yCenter + y);
}
void ellipseMidpoint(int xCenter, int yCenter, int Rx, int Ry)
{
int Rx2 = Rx * Rx;
int Ry2 = Ry * Ry;
int twoRx2 = 2 * Rx2;
int twoRy2 = 2 * Ry2;
int p;
int x = 0;
int y = Ry;
int px = 0;
int py = twoRx2 * y;
void ellipsePlotPoints(int, int, int, int);
/* Dibujar el punto inicial en cada cuadrante. */
ellipsePlotPoints(xCenter, yCenter, x, y);
/* Región 1. */
p = round(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;
}
ellipsePlotPoints(xCenter, yCenter, x, y);
}
/* Región 2. */
p = round(Ry2 * (x + 0.5) * (x + 0.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;
}
ellipsePlotPoints(xCenter, yCenter, x, y);
}
}
// 1/2 elipse abajo
void ellipsePlotPoints1(int xCenter, int yCenter, int x, int y)
{
setPixel(xCenter + x, yCenter - y);
setPixel(xCenter - x, yCenter - y);
void ellipseMidpoint1(int xCenter, int yCenter, int Rx, int Ry)
{
int Rx2 = Rx * Rx;
int Ry2 = Ry * Ry;
int twoRx2 = 2 * Rx2;
int twoRy2 = 2 * Ry2;
int p;
int x = 0;
int y = Ry;
int px = 0;
int py = twoRx2 * y;
void ellipsePlotPoints1(int, int, int, int);
/* Dibujar el punto inicial en cada cuadrante. */
ellipsePlotPoints1(xCenter, yCenter, x, y);
/* Región 1. */
p = round(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;
}
ellipsePlotPoints1(xCenter, yCenter, x, y);
}
/* Región 2. */
p = round(Ry2 * (x + 0.5) * (x + 0.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;
}
ellipsePlotPoints1(xCenter, yCenter, x, y);
}
}
// 1/2 elipse arriba
void ellipsePlotPoints2(int xCenter, int yCenter, int x, int y)
{
setPixel(xCenter + x, yCenter + y);
setPixel(xCenter - x, yCenter + y);
}
void ellipseMidpoint2(int xCenter, int yCenter, int Rx, int Ry)
{
int Rx2 = Rx * Rx;
int Ry2 = Ry * Ry;
int twoRx2 = 2 * Rx2;
int twoRy2 = 2 * Ry2;
int p;
int x = 0;
int y = Ry;
int px = 0;
int py = twoRx2 * y;
void ellipsePlotPoints2(int, int, int, int);
/* Dibujar el punto inicial en cada cuadrante. */
ellipsePlotPoints2(xCenter, yCenter, x, y);
/* Región 1. */
p = round(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;
}
ellipsePlotPoints2(xCenter, yCenter, x, y);
}
/* Región 2. */
p = round(Ry2 * (x + 0.5) * (x + 0.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;
}
ellipsePlotPoints2(xCenter, yCenter, x, y);
}
}
// 1/4 elipse derecha
void ellipsePlotPoints3(int xCenter, int yCenter, int x, int y)
{
setPixel(xCenter - x, yCenter + y);
}
void ellipseMidpoint3(int xCenter, int yCenter, int Rx, int Ry)
{
int Rx2 = Rx * Rx;
int Ry2 = Ry * Ry;
int twoRx2 = 2 * Rx2;
int twoRy2 = 2 * Ry2;
int p;
int x = 0;
int y = Ry;
int px = 0;
int py = twoRx2 * y;
void ellipsePlotPoints3(int, int, int, int);
/* Dibujar el punto inicial en cada cuadrante. */
ellipsePlotPoints3(xCenter, yCenter, x, y);
/* Región 1. */
p = round(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;
}
ellipsePlotPoints3(xCenter, yCenter, x, y);
}
/* Región 2. */
p = round(Ry2 * (x + 0.5) * (x + 0.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;
}
ellipsePlotPoints3(xCenter, yCenter, x, y);
}
}
void dibuja(void)
{
glClear(GL_COLOR_BUFFER_BIT); // Borra la vent. de visualización
glPointSize(3.0);
//1
glColor3f(1.0, 0.0, 0.0);
ellipseMidpoint(20, 50, 10,25);
//2
glColor3f(0.15, 0, 1);
ellipseMidpoint1(40, 50, 10, 25);
//3
glColor3f(0, 1, 0.02);
ellipseMidpoint2(60, 50, 10, 30);
//4
glColor3f(0.65, 0, 1);
ellipseMidpoint1(80, 50, 10, 25);
//5
glColor3f(1, 0.73, 0);
ellipseMidpoint2(100, 50, 10, 30);
//6
glColor3f(0, 1, 0.95);
ellipseMidpoint1(120, 50, 10, 25);
//7
glColor3f(1, 0, 0.73);
ellipseMidpoint3(140, 50, 10, 25);
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 punto medio para la generación de círculos"); // 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
}
