Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Laboratorio de Computación Visual 2018 - 2
Curva de Bézier
Laboratorio 06
Curva de Bézier
Modelado con curvas de Bézier
Objetivo: El objetivo de esta práctica, es que el alumno pueda efectuar la construcción de la curva de
Bézier; posteriormente, puede emplear las herramientas anteriores para una mejor manipulación de
esta curva, como por ejemplo la lectura de los puntos de control por pantalla y el empleo de listas de
visualización.
Duración de la Práctica: 2 Horas.
Lugar de realización: Laboratorio de cómputo.
El conocimiento requerido para realizar esta práctica es de haber asimilado los conceptos básicos
de C/C++ y OpenGL.
El desarrollo tendrá la siguiente estructura de temas:
1. Curva de Bézier
2. Definición
3. Programa ejemplo con OpenGL
4. Ejercicios propuestos
5. Referencias
Mg. Johnny R. Avendaño Q. Pag. No. 1
Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Laboratorio de Computación Visual 2018 - 2
Curva de Bézier
1. CURVA DE BÉZIER ([Link]
Se denomina curvas de Bézier a un sistema que se desarrolló hacia los años 1960, para el trazado de
dibujos técnicos, en el diseño aeronáutico y de automóviles. Su denominación es en honor a Bézier,
quien ideó un método de descripción matemática de las curvas que se comenzó a utilizar con éxito en
los programas de CAD.
Las curvas de Bézier fueron publicadas, por primera vez en 1962 por el ingeniero de origen francés
Pierre Bézier, que las usó posteriormente, con profusión, en el diseño de las diferentes partes de los
cuerpos de un automóvil, en sus años de trabajo en la Renault. Por otra parte, también fueron
desarrolladas por Paul de Casteljau usando el algoritmo que lleva su nombre, el cual se trata de un
método numéricamente estable para evaluar las curvas de Bézier.
Posteriormente, los inventores del PostScript, lenguaje que permitió el desarrollo de sistemas de
impresión de alta calidad desde el ordenador, introdujeron en ese código el método de Bézier para la
generación del código de las curvas y los trazados. El lenguaje PostScript sigue empleándose
ampliamente y se ha convertido en un estándar de calidad universal; por ello, los programas de diseño
vectorial como Adobe Illustrator, el extinto Macromedia FreeHand, Corel Draw, tres de los más
importantes programas de dibujo vectorial y otros como Inkscape, denominan como "bézier" a algunas
de sus herramientas de dibujo, y se habla de "Trazados Bézier", "pluma Bézier", "lápiz Bézier", etc. Su
facilidad de uso la ha estandarizado en el diseño gráfico, extendiéndose también a programas de
animación vectorial como Adobe Flash, y retoque fotográfico (bitmap) como Photoshop y Gimp, donde
se usa para crear formas cerradas o selecciones.
2. DEFINICIÓN
La curva de Bézier se define como:
%
𝑃 𝑢 = 𝐵%,' 𝑢 𝑃'
'()
%!
Donde: 𝐵%,' = 𝑢' 1 − 𝑢 %+'
'! %+' !
y los puntos de control (en 2 dimensiones):
𝑃' = 𝑥' , 𝑦' ; 𝑖 = 0,1, ⋯ , 𝑛
3. PROGRAMA EJEMPLO CON OPENGL (referencial)
El siguiente código debe servir de referencia para posteriores actividades previa modificaciones:
#include <stdlib.h>
#include <GL/glut.h>
#include <stdio.h>
#include<conio.h>
#include <math.h>
void dibujarEjes(void);
void init(void);
void display(void);
void reshape(int,int);
void keyboard(unsigned char, int, int);
void graficaCurvaBezier(void);
float CoeficienteNewton(int,int);
float factorial(int);
float CurvaBezier(float,int);
void graficaPuntosBezier(void);
Mg. Johnny R. Avendaño Q. Pag. No. 2
Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Laboratorio de Computación Visual 2018 - 2
Curva de Bézier
float dim=400;
float pcontrol[7][2]={{-10.0,0.0},{-10.0,10.0},{10.0,10.0},{10.0,0.0},{10.0,-10.0},{0.0,-0.0},{0,0}};
int N=7,paso=0;
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(dim,dim);
glutInitWindowPosition(100,100);
glutCreateWindow("Grafico de una curva de Bezier 2D");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
/********************/
void dibujarEjes(void)
{
glBegin(GL_LINES);
glVertex2f(-20,0);
glVertex2f(20,0);
glVertex2f(0,-20);
glVertex2f(0,20);
glEnd();
}
/********************/
void init(void)
{
// parametros: rojo, amarillo y azul, el cuarto es el parametro alpha
// color de fondo
glClearColor(0.0,0.5,0.5,.0);
glShadeModel(GL_FLAT);
}
/********************/
void display(void)
{
glClear(GL_COLOR_BUFFER_BIT);
// salva el estado actual de la matriz
glPushMatrix();
glColor3f(1.0,0.0,0.0);
dibujarEjes();
glColor3f(0.0,0.0,1.0);
if (paso==1)
{
glPointSize(5);
graficaPuntosBezier();
glPointSize(1);
glColor3f(0.0,1.0,0.0);
graficaCurvaBezier();
}
glPopMatrix();
// reecupera el estado del matriz
glFlush();
}
/********************/
void keyboard(unsigned char key, int x, int y)
Mg. Johnny R. Avendaño Q. Pag. No. 3
Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Laboratorio de Computación Visual 2018 - 2
Curva de Bézier
{
switch (key)
{
case 'b': paso=1;
// se grafica la curva de Bezier
glutPostRedisplay();
break;
case 'n': paso=0;
// No se grafica la curva de Bezier
glutPostRedisplay();
break;
case 27: exit(0);
break;
}
}
/********************/
void reshape(int w, int h)
{
glViewport(0,0,(GLsizei)w, (GLsizei)h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-20.0,20.0,-20.0,20,-1.0,1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
/********************/
void graficaPuntosBezier(void)
{
float x,y;
glBegin(GL_POINTS);
for(int i=0;i<N;i++)
{
x=pcontrol[i][0];
y=pcontrol[i][1];
glVertex2f(x,y);
}
glEnd();
}
/********************/
void graficaCurvaBezier(void)
{
float x,y;
glBegin(GL_LINE_STRIP);
for(float u=0.0;u<=1;u+=0.01)
{
x=CurvaBezier(u,0);
y=CurvaBezier(u,1);
glVertex2f(x,y);
}
glEnd();
}
/********************/
float CoeficienteNewton(int n,int k)
{
return factorial(n)/(factorial(k)*factorial(n-k));
}
/********************/
float factorial(int n)
{
float p=1;
Mg. Johnny R. Avendaño Q. Pag. No. 4
Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Laboratorio de Computación Visual 2018 - 2
Curva de Bézier
for(int i=1;i<=n;i++)
p=p*(float)i;
return p;
}
/********************/
float CurvaBezier(float u,int coordenada)
{
float suma=0.0;
for(int i=0;i<N;i++)
{
suma=suma+pcontrol[i][coordenada]*CoeficienteNewton(N-1,i)*pow(u,N-1-
i)*pow(1.0-u,i);
}
return suma;
}
/********************/
4. EJERCICIOS PROPUESTOS
Ejercicio 01:
Modifique su programa empleando menús jerárquicos para una mejor interacción y claridad del
algoritmo, además de incorporar el zoom y las rotaciones deseadas.
Ejercicio 02:
Implemente el algoritmo de Casteljau para el diseño de la curva de Bézier, el cual viene definida
recursivamente como:
𝑷𝒊,𝒋 = 𝟏 − 𝒖 𝑷𝒊+𝟏,𝒋 + 𝒖 𝑷𝒊+𝟏,𝒋<𝟏 ; 𝒊 = 𝟏, 𝟐, … . , 𝒏 ; 𝒋 = 𝟎, 𝟏, … , 𝒏 − 𝒊
Emplee esta versión y otra haciendo uso de un arreglo matricial, para comparar el tiempo de respuesta
en el renderizado (optativo):
Mg. Johnny R. Avendaño Q. Pag. No. 5
Universidad Nacional Mayor de San Marcos
Facultad de Ingeniería de Sistemas e Informática
E.P. Ingeniería de Sistemas
Laboratorio de Computación Visual 2018 - 2
Curva de Bézier
Ejercicio 03:
Modifique su programa para graficar la Curva de Bézier en 3 dimensiones, los puntos de control
pueden ser representados por pequeñas esferas sólidas.
Ejercicio 04:
Modifique su programa de tal manera que se puedan ingresar los puntos de control de
directamente sobre la ventana gráfica (sólo en 2 dimensiones), posteriormente deberá poder cambiar
de posición cualquiera de ellas, redibujándose la curva de forma automática.
Ejercicio 05:
Considere su aplicación anterior y realice las consideraciones del caso para el empleo de menús
jerárquicos en todas las acciones del caso.
5. REFERENCIAS
1. Principles and Practice (Second Edition). Foley J. D., [Link] Dam, [Link] and J.F. Hughes
Computer Graphics. Addison-Wesley. 1990
2. OpenGL Superbible. R. Wright and M. Sweet. Waite Group, Inc 1996
3. The OpenGL Utility Toolkit (GLUT) Programming Interface (API Version 3). Mark J. Kilgard,
Silicon Graphics, Inc 1996
4. The OpenGL Graphics System: A Specification (Version 1.2). Mark segal & Kurt Akeley. Silicon
Graphics, Inc 1998
5. Wikipedia, la enciclopedia libre. (enlace) [Link]
Mg. Johnny R. Avendaño Q. Pag. No. 6
