This project, completed as part of the coursework at the Benemérita Universidad Autónoma de Puebla, focuses on graphing a polar function using the Bresenham algorithm in the Code::Blocks IDE. The aim is to visualize a polar function, specifically a Rose Curve, while optimizing computational efficiency through the use of the Bresenham line algorithm.
The Bresenham algorithm is a precise and efficient method for generating rasterized lines using only integer calculations. It can be adapted to display circles and other curves, making it suitable for plotting polar functions with reduced computational cost.
- Implement and visualize a polar function using the Bresenham algorithm in OpenGL.
- Apply learned concepts to optimize graph plotting by minimizing floating-point operations.
- Develop an understanding of the Bresenham algorithm and its applications in computer graphics.
- Initialization: Set up the OpenGL environment and window properties.
- Bresenham Algorithm: Calculate and plot points efficiently using integer calculations.
- Graphing Function: Convert polar coordinates to Cartesian coordinates and plot the Rose Curve.
- Color Variation: Implement a color scheme for visual distinction.
The project includes the following main components:
This function sets up the OpenGL environment, defining the color of the window and the projection parameters.
void init(void) {
glClearColor(0.0, 0.0, 0.0, 1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(-200, 200, -200, 200);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
This function implements the Bresenham algorithm to efficiently determine the points to be plotted for a given line segment.
void Bresenham(int x0, int y0, int x1, int y1) {
int x, y, dx, dy, p, 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;
glBegin(GL_POINTS);
glVertex2i(x0, y0);
glEnd();
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;
}
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
}
} 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;
}
glBegin(GL_POINTS);
glVertex2i(x, y);
glEnd();
}
}
}
This function draws the graph by converting polar coordinates to Cartesian coordinates and utilizes the Bresenham algorithm to plot lines between calculated points.
void dibujaGrafica() {
glClear(GL_COLOR_BUFFER_BIT); // Clear the display window
GLfloat rpolar, angulo, diff;
GLint xt, yt, x0, y0, x1, y1, first;
first = 1;
glPointSize(1);
diff = 360 / 120;
for (i = 0; i < 240; i++) {
rpolar = 6 * cos(4 * rad); // Rose Curve formula
xt = rpolar * cos(rad) * 25;
yt = rpolar * sin(rad) * 25;
glColor3f(0.255, 0, 0.700); // Set color
if (first == 1) { // First point
x0 = xt;
y0 = xt;
x1 = xt;
y1 = xt;
first = 0;
} else { // Subsequent points
x0 = x1;
y0 = y1;
x1 = xt;
y1 = yt;
if (i > 1) {
Bresenham(x0, y0, x1, y1);
}
}
angulo = angulo + diff;
rad = angulo * (M_PI / 180);
}
glFlush();
}
This function initializes the graphics window and starts the main loop.
int main(int argc, char** argv) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(100, 100);
glutInitWindowSize(400, 400);
glutCreateWindow("Curva Rosa (Bresenham)");
init();
glutDisplayFunc(dibujaGrafica);
glutMainLoop();
return 0;
}
The project initializes a graphical window and plots a Rose Curve using the Bresenham algorithm. This approach reduces computational costs by minimizing floating-point operations, resulting in an efficient and accurate graph plotting.