INSTITUTO TECNOLÓGICO DE CIUDAD JUÁREZ.
Graficación
Unidad 2. Graficación 2D
Practica 4: Curvas de Bezier
Maestro: Ing. Noé Ramón Rosales.
Arreola Cardona Valeria Jazmin.
Lares Valtierra Diana.
Índice
Contents
Índice ................................................................................................................................................. 2
Introducción..................................................................................................................................... 3
Desarrollo ......................................................................................................................................... 4
Anexos .............................................................................................................................................. 6
Conclusiones................................................................................................................................... 9
Bibliografía ..................................................................................................................................... 10
Introducción
Las más importantes curvas que se usan actualmente en el diseño computacional son las
curvas de Bézier.
Esto se debe a su fácil lógica matemática, a diferencia de otros métodos para generar
curvas.
Son utilizadas para modelados de figuras que requieren de curvas y no solo figuras
básicas.
Desarrollo
Curvas de Bezier
Las más importantes curvas que se usan actualmente en el diseño computacional son las
curvas de Bézier y los B-Splines. Es gracias al trabajo de dos matemáticos franceses,
Bézier y de Casteljau, que se desarrollan aplicaciones para el incipiente diseño
computacional de los años 60, bajo el alero de la industria automotriz.
El problema general surge ante la necesidad trazar curvas con mucha precisión, para
lograr distintas piezas que puedan ensamblar correctamente.
Para ello, los diseñadores de la época solían ocupar procedimientos de dibujo, por
ejemplo, para trazar una aproximación de una curva que une dos puntos, usando las
llamadas reglas francesas, o bien curvaban listones para generar lo que ahora se
denomina «spline» (astilla, en inglés).
Pero de tal forma, no siempre se lograba la precisión necesaria; aunque ambos métodos
ahora tienen su equivalente computacional, respectivamente, las Curvas de Bézier y las
Splines, ambos elementos fundantes del diseño vectorial.
La primera versión de las curvas de Bézier fue en realidad tridimensional, un esquema
basado en curvas cuadráticas construidas dentro de un cubo, método que le permitirá
describir cualquier curva de grado 2 a partir de sólo cuatro puntos.
Con el tiempo este esquema se simplificará más, de manera que pueda describir curvas
cuadráticas a partir de sólo tres puntos, y curvas de grado n con sólo n+1 puntos.
Permiten la representación de cualquier forma curvada y evitan la complicación
innecesaria de cálculos matemáticos que se produciría usando polinomios de mayor
grado.
Cualquier trazado de estas características está definido por una serie de puntos por los
que pasa la curva y otros exteriores a ella que definen sus puntos de inflexión, es decir,
aquellos en que cambia de curvatura, pasando de cóncava a convexa o viceversa.
En un trazado Bézier existen "manejadores" en cada uno de sus nodos de manera que se
puede alterar la curvatura a voluntad para adaptar el trazo a cualquier forma imaginable,
controlando la suavidad de las zonas de transición.
𝑛
𝑝(𝑡) = ∑ 𝑝𝑘 𝐵𝑘,𝑛 (𝑡) 0 ≤ 𝑡 ≤ 1
𝑘=0
Donde pk corresponde a los puntos de control
𝑝𝑘 = (𝑥𝑘 , 𝑦𝑘 𝑧𝑘 )
𝐵𝑘,𝑛 (𝑡) = 𝐶(𝑛, 𝑘)𝑡 𝑘 (1 − 𝑡)𝑛−𝑘
Y donde, C(n,k) representa los coeficientes binomiales:
𝑛!
𝐶(𝑛, 𝑘) =
𝑘! (𝑛 − 𝑘)!
Utilizando cuatro puntos de control (Pi), el polinomio de Bézier es:
𝑝(𝑡) = 𝑃0 (1 − 𝑡)3 + 𝑃1 3𝑡(1 − 𝑡)2 + 𝑃2 3𝑡 2 (1 − 𝑡) + 𝑃3 𝑡 3
Este polinomio tiene una representación matricial:
−1 3 −3 1 𝑃0
𝑃(𝑡) = 𝑇𝐵𝑃 = [𝑡 3 𝑡 2 𝑡1] [ 3 −6 3 0 ] [𝑃1]
−3 3 0 0 𝑃2
1 0 0 0
Anexos
#pragma once
#include "gl/glut.h"
#include <math.h>
// Asiganar el tamaño inicial de la ventana de visualizacion
GLsizei winWidht=600, winHeight=600;
//Asignat el tamaño de la ventana der recorte en coordenadas universales
GLfloat xwcMin=-50.0, xwcMax=50.0;
GLfloat ywcMin=-50.0, ywcMax=50.0;
class wcPt3D
{
public:
GLfloat x, y, z;
};
void init(void)
{
//asginar el color de la ventana de visualiazcion a blanco
glClearColor(1.0, 1.0, 1.0, 0.0);
}
void plotPoint(wcPt3D bezCurvePt)
{
glBegin(GL_POINTS);
glVertex2f(bezCurvePt.x, bezCurvePt.y);
glEnd();
}
//Calcula los coeficientes binomiales C par aun valor dado de n
void binomialCoeffs(GLint n, GLint* C)
{
GLint k, j;
for ( k = 0; k <=n; k++)
{
//Compute n!/(k!(n-k)!)
C[k] = 1;
for ( j = n; j >=k+1; j--)
{
C[k] *= j;
}
for ( j = n-k; j >=2; j--)
{
C[k] /= j;
}
}
}
void computeBezPt(GLfloat u, wcPt3D* bezPt, GLint nCtrlPts, wcPt3D* ctrlPts, GLint*
C)
{
GLint k, n = nCtrlPts - 1;
GLfloat bezBlendFcn;
bezPt->x = bezPt->y = bezPt->z = 0.0;
/* Calcula las funciones de combinacion y los puntos de control de
combinacion*/
for ( k = 0; k < nCtrlPts; k++)
{
bezBlendFcn = C[k] * pow(u, k) * pow(1 - u, n - k);
bezPt->x += ctrlPts[k].x * bezBlendFcn;
bezPt->y += ctrlPts[k].y * bezBlendFcn;
bezPt->z += ctrlPts[k].z * bezBlendFcn;
}
}
void bezier(wcPt3D* ctrlPts, GLint nCtrlPts, GLint nBezCurvePts)
{
wcPt3D bezCurvePt;
GLfloat u;
GLint* C, k;
/*Reserva espacio para los coeficientes binomiales*/
C = new GLint[nCtrlPts];
binomialCoeffs(nCtrlPts - 1, C);
for ( k = 0; k <=nBezCurvePts; k++)
{
u = GLfloat(k) / GLfloat(nBezCurvePts);
computeBezPt(u, &bezCurvePt, nCtrlPts, ctrlPts, C);
plotPoint(bezCurvePt);
}
delete [] C;
}
void displayFcn(void)
{
/*Establece un número de puntos de control de ejemplo y un numero de
puntos de curva que se deben dibujar a lo largo de la curva de Bezier*/
GLint nCtrlPts = 4, nBezCurvePts = 1000;
wcPt3D ctrlPts[4] = { {-40.0,-40.0,0.0},{-10.0,200.0,0.0},
{10.0,-200.0,0.0},{40.0,40.0,0.0} };
glClear(GL_COLOR_BUFFER_BIT); //Limpiamos la pantalla principal
glPointSize(4);
glColor3f(0.6, 0.2, 0.7);// asignamos el color del punto a rojo
bezier(ctrlPts, nCtrlPts,nBezCurvePts);
glFlush();
}
void winReshapeFcn(GLint newWidth, GLint newHeight)
{
/*Mantiene una relacion de aspecto de valor 1.0*/
glViewport(0, 0, newHeight, newHeight);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(xwcMin,xwcMax,ywcMin,ywcMax);
glClear(GL_COLOR_BUFFER_BIT);
}
void main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(50, 50);
glutInitWindowSize(winWidht,winHeight);
glutCreateWindow("Curva de bezier");
init();
glutDisplayFunc(displayFcn);
glutReshapeFunc(winReshapeFcn);
glutMainLoop();
}
Conclusiones
Las curvas de Bézier son una aplicación que reduce los cálculos matemáticos
necesarios para realizar curvas.
En la graficación tienen mucho uso para modelados de piezas que requieren
precisión, como diseños de piezas automovilísticas.
Aplicado a OpenGL fue necesario determinar los coeficientes binomiales, los
puntos de la curva y los puntos de control, que se iban guardando en un arreglo
dinámico que guarda las posiciones de cada coordenada de los puntos.
Finalmente, se obtiene una curva como la marcada en los anexos, la cual podría
servir como plantilla base para otras implementaciones.
La práctica fue interesante de realizar, se debió estudiar la teoría matemática
detrás del código y entenderlo físicamente, antes de hacerlo en código.
Bibliografía
(s.f.). Obtenido de [Link]
