OpenGL es una API multiplataforma y multilenguaje para renderizar gráficos vectoriales 2D y 3D . Se utiliza para realizar una gran cantidad de diseño y animación utilizando OpenGL . En este artículo, discutiremos el concepto y la implementación de Bezier Curves OpenGL .
Curvas de Beizer :
Las curvas de Béziers son una de las curvas paramétricas más utilizadas en gráficos por computadora y fueron desarrolladas de forma independiente para el diseño de automóviles asistido por computadora por dos ingenieros, ambos trabajando para compañías automotrices francesas: Pierre Bézier, que era ingeniero de Renault, y Paul de Casteljau, que era ingeniero de Citroën.
- El concepto de curvas de Bezier fue descubierto por el ingeniero francés Pierre Bézier .
- Las curvas de Bezier se utilizan básicamente en gráficos por computadora para dibujar formas, para animación CSS y en muchos otros lugares.
- Estas son las curvas que se generan bajo el control de algunos otros puntos, también llamados puntos de control.
Propiedades de las curvas de Bezier :
- Una propiedad muy importante de las curvas de Bezier es que siempre pasan por el primer y último punto de control.
- El grado del polinomio que define el segmento de la curva es siempre uno menos que el número de puntos del polígono que lo definen. Entonces, por ejemplo, si tenemos 4 puntos de control, entonces el grado del polinomio es 3, es decir, polinomio cúbico.
- En las curvas Bezier, mover un punto de control altera la forma de toda la curva.
- Una curva Bezier generalmente sigue la forma del polígono que la define.
- Una curva siempre está dentro del casco convexo de los puntos de control.
A continuación se muestra el programa C++ para implementar las curvas Bezier:
C++
// C++ program to implement Bezier Curves
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <stdlib.h>
int i;
// Function to initialize the Beizer
// curve pointer
void init(void)
{
glClearColor(1.0, 1.0, 1.0, 1.0);
}
// Function to draw the Bitmap Text
void drawBitmapText(char* string, float x,
float y, float z)
{
char* c;
glRasterPos2f(x, y);
// Traverse the string
for (c = string; *c != '\0'; c++) {
glutBitmapCharacter(
GLUT_BITMAP_TIMES_ROMAN_24, *c);
}
}
// Function to draw the shapes
void draw(GLfloat ctrlpoints[4][3])
{
glShadeModel(GL_FLAT);
glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4,
&ctrlpoints[0][0]);
glEnable(GL_MAP1_VERTEX_3);
// Fill the color
glColor3f(1.0, 1.0, 1.0);
glBegin(GL_LINE_STRIP);
// Find the coordinates
for (i = 0; i <= 30; i++)
glEvalCoord1f((GLfloat)i / 30.0);
glEnd();
glFlush();
}
// Function to display the curved
// drawn using the Beizer Curve
void display(void)
{
int i;
// Specifying all the control
// points through which the
// curve will pass
GLfloat ctrlpoints[4][3]
= { { -0.00, 2.00, 0.0 },
{ -2.00, 2.00, 0.0 },
{ -2.00, -1.00, 0.0 },
{ -0.00, -1.00, 0.0 } };
draw(ctrlpoints);
GLfloat ctrlpoints2[4][3]
= { { 0.0, -1.00, 0.0 },
{ 0.55, -0.65, 0.0 },
{ 0.65, -0.25, 0.0 },
{ 0.00, 0.70, 0.0 } };
draw(ctrlpoints2);
GLfloat ctrlpoints3[4][3]
= { { 0.0, 0.70, 0.0 },
{ 0.15, 0.70, 0.0 },
{ 0.25, 0.70, 0.0 },
{ 0.65, 0.700, 0.0 } };
draw(ctrlpoints3);
GLfloat ctrlpoints4[4][3]
= { { 0.65, 0.70, 0.0 },
{ 0.65, -0.90, 0.0 },
{ 0.65, -0.70, 0.0 },
{ 0.65, -1.00, 0.0 } };
draw(ctrlpoints4);
GLfloat ctrlpoints5[4][3]
= { { 1.00, -1.00, 0.0 },
{ 1.00, -0.5, 0.0 },
{ 1.00, -0.20, 0.0 },
{ 1.00, 1.35, 0.0 } };
draw(ctrlpoints5);
GLfloat ctrlpoints6[4][3]
= { { 1.00, 1.35 },
{ 1.10, 1.35, 0.0 },
{ 1.10, 1.35, 0.0 },
{ 1.90, 1.35, 0.0 } };
draw(ctrlpoints6);
GLfloat ctrlpoints7[4][3]
= { { 1.00, 0.50, 0.0 },
{ 1.10, 0.5, 0.0 },
{ 1.10, 0.5, 0.0 },
{ 1.90, 0.5, 0.0 } };
draw(ctrlpoints7);
GLfloat ctrlpoints8[4][3]
= { { 3.50, 2.00, 0.0 },
{ 1.50, 2.00, 0.0 },
{ 1.50, -1.00, 0.0 },
{ 3.50, -1.00, 0.0 } };
draw(ctrlpoints8);
GLfloat ctrlpoints9[4][3]
= { { 3.50, -1.00, 0.0 },
{ 4.05, -0.65, 0.0 },
{ 4.15, -0.25, 0.0 },
{ 3.50, 0.70, 0.0 } };
draw(ctrlpoints9);
GLfloat ctrlpoints10[4][3]
= { { 3.50, 0.70, 0.0 },
{ 3.65, 0.70, 0.0 },
{ 3.75, 0.70, 0.0 },
{ 4.15, 0.700, 0.0 } };
draw(ctrlpoints10);
GLfloat ctrlpoints11[4][3]
= { { 4.15, 0.70, 0.0 },
{ 4.15, -0.90, 0.0 },
{ 4.15, -0.70, 0.0 },
{ 4.15, -1.00, 0.0 } };
draw(ctrlpoints11);
GLfloat ctrlpoints12[4][3]
= { { -2.0, 2.50, 0.0 },
{ 2.05, 2.50, 0.0 },
{ 3.15, 2.50, 0.0 },
{ 4.65, 2.50, 0.0 } };
draw(ctrlpoints12);
GLfloat ctrlpoints13[4][3]
= { { -2.0, -1.80, 0.0 },
{ 2.05, -1.80, 0.0 },
{ 3.15, -1.80, 0.0 },
{ 4.65, -1.80, 0.0 } };
draw(ctrlpoints13);
GLfloat ctrlpoints14[4][3]
= { { -2.0, -1.80, 0.0 },
{ -2.0, 1.80, 0.0 },
{ -2.0, 1.90, 0.0 },
{ -2.0, 2.50, 0.0 } };
draw(ctrlpoints14);
GLfloat ctrlpoints15[4][3]
= { { 4.650, -1.80, 0.0 },
{ 4.65, 1.80, 0.0 },
{ 4.65, 1.90, 0.0 },
{ 4.65, 2.50, 0.0 } };
draw(ctrlpoints15);
// Specifying the colour of
// text to be displayed
glColor3f(1, 0, 0);
drawBitmapText("Bezier Curves "
"Implementation",
-1.00, -3.0, 0);
glFlush();
}
// Function perform the reshaping
// of the curve
void reshape(int w, int h)
{
glViewport(0, 0, (GLsizei)w,
(GLsizei)h);
// Matrix mode
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w <= h)
glOrtho(-5.0, 5.0, -5.0
* (GLfloat)h / (GLfloat)w,
5.0 * (GLfloat)h / (GLfloat)w, -5.0, 5.0);
else
glOrtho(-5.0 * (GLfloat)w / (GLfloat)h,
5.0 * (GLfloat)w / (GLfloat)h,
-5.0, 5.0,
-5.0, 5.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
// Driver Code
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(
GLUT_SINGLE | GLUT_RGB);
// Specifies the window size
glutInitWindowSize(500, 500);
glutInitWindowPosition(100, 100);
// Creates the window as
// specified by the user
glutCreateWindow(argv[0]);
init();
// Links display event with the
// display event handler(display)
glutDisplayFunc(display);
glutReshapeFunc(reshape);
// Loops the current event
glutMainLoop();
return 0;
}
Producción:
Publicación traducida automáticamente
Artículo escrito por patidarakshay999 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA