Curva di Bézier

Da Wikipedia, l'enciclopedia libera.

(Reindirizzamento da Curva Bézier)

Nel campo matematico della analisi numerica una curva di Bézier è un'importante curva parametrica usata nella computer grafica. Un metodo numericamente stabile per calcolare le curve di Bézier è l'algoritmo di de Casteljau.

Una generalizzazione delle curve di Bézier in tre dimensioni è chiamata superficie di Bézier di cui il triangolo di Bézier è uno specifico caso.

Indice

1 Storia
2 Analisi dei casi
3 Generalizzazione
- 3.1 Terminologia
- 3.2 Note
4 Costruzione delle curve di Bézier
5 Applicazioni nella computer grafica
- 5.1 Applicazione in Visual Basic 6
6 Curve di Bézier razionali
7 Voci correlate
8 Bibliografia
9 Collegamenti esterni

[modifica] Storia

Le curve di Bézier furono largamente pubblicizzate nel 1962 dall'ingegnere francese Pierre Bézier che le usò per disegnare le carrozzerie delle automobili. Le curve furono realizzate nel 1959 da Paul de Casteljau usando l'algoritmo di de Casteljau.

Bézier stabilì un modo di realizzare le curve che partiva da due punti e una linea vettoriale appunto, un sistema innovativo che permette ancora oggi agli operatori grafici di realizzare disegni curvilinei bellissimi e precisi. Le curve di Bézier possono essere realizzate da molti programmi di grafica vettoriale come Inkscape, Gimp, Corel Draw, Illustrator o FreeHand.

[modifica] Analisi dei casi

[modifica] Curve di Bézier lineari

Dati i punti P₀ e P₁, una curva di Bézier lineare è una linea retta che li attraversa. La curva è data da

$\mathbf{B}(t)=(1-t)\mathbf{P}_0 + t\mathbf{P}_1 \mbox{ , } t \in [0,1].$

[modifica] Curve di Bézier quadratiche

Una curva di Bézier quadratica è il percorso tracciato tramite la funzione B(t), dati i punti P₀, P₁, e P₂,

$\mathbf{B}(t) = (1 - t)^{2}\mathbf{P}_0 + 2t(1 - t)\mathbf{P}_1 + t^{2}\mathbf{P}_2 \mbox{ , } t \in [0,1].$

I fonts TrueType usano le spline di Bézier composte da curve di Bézier quadratiche.

[modifica] Curve di Bézier cubiche

I quattro punti P₀, P₁, P₂ e P₃ nel piano o in uno spazio tridimensionale definiscono una curva di Bézier cubica. La curva ha inizio in P₀ si dirige verso P₁ e finisce in P₃ arrivando dalla direzione di P₂. In generale, essa non passa dai punti P₁ o P₂; questi punti sono necessari solo per dare alla curva informazioni direzionali. La distanza tra P₀ e P₁ determina quanto la curva si muove nella direzione di P₂ prima di dirigersi verso P₃.

La forma parametrica della curva è:

$\mathbf{B}(t)=\mathbf{P}_0(1-t)^3+3\mathbf{P}_1t(1-t)^2+3\mathbf{P}_2t^2(1-t)+\mathbf{P}_3t^3 \mbox{ , } t \in [0,1].$

I moderni sistemi di imaging come PostScript, METAFONT e GIMP usano le spline di Bézier composte da curve di Bézier cubiche per disegnare forme curve.

[modifica] Generalizzazione

La curva di Bézier di grado $n$ può essere generalizzata come segue. Dati i punti P₀, P₁,..., P_n, La curva di Bézier è:

$\mathbf{B}(t)=\sum_{i=0}^n {n\choose i}\mathbf{P_i}(1-t)^{n-i}t^i =\mathbf{P}_0(1-t)^n+{n\choose 1}\mathbf{P}_1(1-t)^{n-1}t+\cdots+\mathbf{P}_nt^n \mbox{ , } t \in [0,1].$

Per esempio, per $n = 5$ :

$\mathbf{B}(t)=\mathbf{P}_0(1-t)^5+5\mathbf{P}_1t(1-t)^4+10\mathbf{P}_2t^2(1-t)^3+10\mathbf{P}_3t^3(1-t)^2+5\mathbf{P}_4t^4(1-t)+\mathbf{P}_5t^5 \mbox{ , } t \in [0,1].$

[modifica] Terminologia

Un po' di terminologia è associata a queste curve parametriche. Abbiamo

$\mathbf{B}(t)=\sum_{i=0}^n {n\choose i}\mathbf{P_i}(1-t)^{n-i}t^i,\quad t\in[0,1]$

I polinomi

${n\choose i}(1-t)^{n-i}t^i$

sono conosciuti come polinomi di base di Bernstein di grado n e sono definiti da

$b_{i,n}(t):= {n \choose i} t^i (1-t)^{n-i},\qquad i=0,\ldots n.$

definito 0⁰ = 1.

I punti P_i sono chiamati punti di controllo per la curva di Bézier. Il poligono formato connettendo i punti attraverso linee rette, iniziando da P₀ e finendo con P_n è l'insieme convesso contentente i punti P_i . Questo poligono è chiamato poligono di Bézier, ed esso contiene la curva di Bézier.

[modifica] Note

La curva inizia in P₀ e termina in P_n; questa è chiamata la proprietà della interpolazione di punto finale.
La curva è una linea retta se e solo se tutti i punti di controllo giacciono sulla curva, similmente, la curva di Bézier è una linea retta se e solo se i punti di controllo sono collineari.
L'inizio (fine) della curva è tangente al primo (ultimo) lato del poligono di Bézier.
Una curva può essere spezzata in qualsiasi punto in 2 sottocurve, o in un arbitrario numero di sottocurve, ognuna delle quali è essa stessa una curva di Bézier.
Un cerchio non può essere esattamente formato da una curva di Bézier, come neanche un arco di cerchio. Comunque una curva di Bézier è un'adeguata approssimazione di un arco circolare abbastanza piccolo.

[modifica] Costruzione delle curve di Bézier

[modifica] Curve lineari

Animazione di una curva di Bézier lineare, t in [0,1]

Il t nella funzione di una curva di Bézier lineare può essere pensato come la descrizione del tragitto di B(t) da P₀ a P₁. Per esempio quando t=0.25, B(t) è un quarto del percorso da P₀ a P₁. Al variare di t da 0 a 1, B(t) descrive l'intero segmento compreso tra P₀ e P₁.

[modifica] Curve quadratiche

Per le curve quadratiche di Bézier si possono costruire punti intermedi Q₀ e Q₁ al variare di t da 0 a 1:

Il punto Q₀ varia da P₀ a P₁ e descrive una curva lineare di Bézier.
Il punto Q₁ varia da P₁ a P₂ e descrive una curva lineare di Bézier.
Il punto B(t) varia da Q₀ to Q₁ e descrive una curva quadratica di Bézier.


Costruzione di una curva quadratica di Bézier		Animazione di una curva quadratica di Bézier, t in [0,1]

[modifica] Curve cubiche e di ordine superiore

Per curve di ordine superiore è necessario un maggior numero di punti intermedi.

Per una curva cubica si possono costruire i punti Q₀, Q₁ e Q₂ che descrivono una curva di Bézier lineare, e i punti R₀ e R₁ che descrivono una curva di Bézier quadratica:


Costruzione di una curva cubica Bézier		Animazione di una cubica di Bézier, t in [0,1]

Per curve di quarto ordine è possibile costruire i punti intermedi Q₀, Q₁, Q₂ e Q₃ che descrivono curve di Bézier lineari, i punti R₀, R₁ e R₂ che descrivono curve quadratiche di Bézier, e i punti S₀ e S₁ che descrivono una curva di Bézier cubica:


Costruzione di una curva di Bézier di quarto ordine		Animazione di una curva di Bézier di quarto ordine, t in [0,1]

[modifica] Applicazioni nella computer grafica

Progetto di uno Yacht tramite curve di Bézier

Le curve di Bézier sono largamente usate nella computer grafica per modellare curve smussate. Dato che la curva è contenuta completamente nell'insieme convesso dei suoi punti di controllo, i punti possono essere visualizzati graficamente ed usati per manipolare la curva intuitivamente. Trasformazioni geometriche come traslazione, omotetia e rotazione possono essere applicate alla curva applicando le rispettive trasformazioni sui punti di controllo della curva.

Le più importanti curve di Bézier sono le quadratiche e cubiche. Curve di grado più alto sono molto più costose da valutare. Quando sia necessario realizzare forme più complesse, più curve di secondo o terzo ordine sono "incollate" insieme (obbedendo a certe condizioni di smooth) in forma di spline di Bézier.

Il codice seguente è un semplice e pratico esempio che mostra come disegnare una curva di Bézier cubica in C. Da notare che viene semplicemente calcolato il coefficiente del polinomio e si cicla su una serie di valori di t da 0 a 1 - in pratica questo è come viene effettivamente fatto, anche se esistono altri metodi come l'algoritmo di de Casteljau che sono spesso citati in discussioni sulla grafica. Questo perché in pratica un algoritmo lineare come questo è veloce e meno costoso di uno ricorsivo come quello di de Casteljau.

/******************************************************
 Codice per generare una curva di Bézier cubica
 Attenzione - codice non testato
*******************************************************/

 typedef struct
 {
	float x;
	float y;
 }
 Point2D;

/******************************************************
 cp è un array di 4 elementi dove:
 cp[0] è il punto iniziale
 cp[1] è il primo punto di controllo
 cp[2] è il secondo punto di controllo
 cp[3] è il punto finale

 t è il valore del parametro, 0 <= t <= 1
*******************************************************/

 Point2D PointOnCubicBezier( Point2D* cp, float t )
 {
	float   ax, bx, cx;
	float   ay, by, cy;
	float   tSquared, tCubed;
	Point2D result;
	
	/* calcolo dei coefficienti del polinomio */
	
	cx = 3.0 * (cp[1].x - cp[0].x);
	bx = 3.0 * (cp[2].x - cp[1].x) - cx;
	ax = cp[3].x - cp[0].x - cx - bx;
	
	cy = 3.0 * (cp[1].y - cp[0].y);
	by = 3.0 * (cp[2].y - cp[1].y) - cy;
	ay = cp[3].y - cp[0].y - cy - by;
	
	/* calcolo del punto della curva in relazione a t */
	
	tSquared = t * t;
	tCubed = tSquared * t;
	
	result.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + cp[0].x;
	result.y = (ay * tCubed) + (by * tSquared) + (cy * t) + cp[0].y;
	
	return result;
 }

/*****************************************************************************
 ComputeBezier riempe un array di strutture Point2D  con i punti della curva 
 generati dai punti di controllo cp. Il chiamante deve allocare memoria 
 sufficiente per il risultato che è <sizeof(Point2D) * numeroDiPunti>
******************************************************************************/

 void	ComputeBezier( Point2D* cp, int numberOfPoints, Point2D* curve )
 {
	float   dt;
	int	  i;
	
	dt = 1.0 / ( numberOfPoints - 1 );
	
	for( i = 0; i < numberOfPoints; i++)
		curve[i] = PointOnCubicBezier( cp, i*dt );
 }

[modifica] Applicazione in Visual Basic 6

'Inserire il tutto in un form con il name form2

'Option Explicit

Type BezierPoint

   X As Single
   Y As Single

End Type

Public Sub iDrawBez() Dim iPoint(5) As BezierPoint

   'Il primo e l'ultimo indice determinano il Piniziale e il Pfinale
   iPoint(0).X = 1000
   iPoint(0).Y = 1000
   iPoint(1).X = 6500
   iPoint(1).Y = 5500
   iPoint(2).X = 4000
   iPoint(2).Y = 5000
   iPoint(3).X = 9000
   iPoint(3).Y = 3000
   iPoint(4).X = 12200
   iPoint(4).Y = 4000
   iPoint(5).X = 5200
   iPoint(5).Y = 3400
       
   DrawBezier iPoint()

End Sub

Private Sub DrawBezier(iPoint() As BezierPoint)

   Dim ax As Single, bx As Single, cx As Single, ay As Single, by As Single, cy As Single, xt As Single, yt As Single
   Dim axN As Single, bxN() As Single, cxN() As Single, ayN As Single, byN() As Single, cyN() As Single, xtN As Single, ytN As Single
   
   Dim t As Single, I As Integer
   Dim iTotPoints As Integer
   Dim X As Integer
   
   iTotPoints = UBound(iPoint)
   
   ReDim bxN(iTotPoints) As Single
   ReDim cxN(iTotPoints) As Single
   ReDim byN(iTotPoints) As Single
   ReDim cyN(iTotPoints) As Single
   
   Form2.Cls
   Form2.DrawWidth = 1
   'Draws control lines
   Form2.ForeColor = vbBlue
   
   For X = 0 To iTotPoints - 1
       Form2.Line (iPoint(X).X, iPoint(X).Y)-(iPoint(X + 1).X, iPoint(X + 1).Y)
   Next X
   
   
   Form2.ForeColor = vbRed
   
   'The following is the core of the program.
   ' All others are just for dragging.
   cxN(0) = 0
   For X = 1 To iTotPoints - 1
       cxN(X) = iTotPoints * (iPoint(X).X - iPoint(X - 1).X) - cxN(X - 1)
   Next X
       
   'Calcolo di ax
   axN = iPoint(iTotPoints).X - iPoint(0).X
   For X = 1 To iTotPoints - 1
       axN = axN - cxN(X)
   Next X
   
   cyN(0) = 0
   For X = 1 To iTotPoints - 1
       cyN(X) = iTotPoints * (iPoint(X).Y - iPoint(X - 1).Y) - cyN(X - 1)
   Next X
       
   'Calcolo di ay
   ayN = iPoint(iTotPoints).Y - iPoint(0).Y
   For X = 1 To iTotPoints - 1
       ayN = ayN - cyN(X)
   Next X
       
   For t = 0 To 1 Step 0.0001
       xtN = axN * t ^ iTotPoints
       ytN = ayN * t ^ iTotPoints
   
       For X = iTotPoints - 1 To 1 Step -1
           xtN = xtN + cxN(X) * t ^ X
           ytN = ytN + cyN(X) * t ^ X
       Next X
       
       xtN = xtN + iPoint(0).X
       ytN = ytN + iPoint(0).Y
   
       Form2.PSet (xtN, ytN) 'Draw Lines for a finer curve
   Next t

   Form2.ForeColor = vbYellow
   Form2.DrawWidth = 4

   For I = 0 To 3
       Form2.PSet (iPoint(I).X, iPoint(I).Y)
       'Debug.Print " (x" & I & ", y" & I & ")"
   Next I

End Sub

[modifica] Curve di Bézier razionali

Alcune curve che sembrano semplici, come il cerchio, non possono essere descritte da una curva di Bézier, quindi abbiamo bisogno di maggiori gradi di libertà.

La curva di Bézier razionale aggiunge pesi che possono essere aggiustati. Il numeratore è una curva di Bézier in forma di Bernstein pesata e il denominatore è una somma pesata di polinomi di Bernstein

Dati n+1 punti di controllo P_i, la curva di Bézier razionale è data da:

$\mathbf{B}(t) = \frac{ \sum_{i=0}^n b_{i,n}(t) \mathbf{P}_{i}w_i } { \sum_{i=0}^n b_{i,n}(t) w_i }$

o semplicemente

$\mathbf{B}(t) = \frac{ \sum_{i=0}^n {n \choose i} t^i (1-t)^{n-i}\mathbf{P}_{i}w_i } { \sum_{i=0}^n {n \choose i} t^i (1-t)^{n-i}w_i }.$

[modifica] Voci correlate

[modifica] Bibliografia

Paul Bourke: Bézier curves, http://astronomy.swin.edu.au/~pbourke/curves/bezier/
Donald Knuth: Metafont: the Program, Addison-Wesley 1986, pp. 123-131. Eccellente discussione sui dettagli implementativi; disponibile gratuitamente come parte della distribuzione T_EX.
Dr. Thomas Sederberg, BYU Bézier curves, http://www.tsplines.com/resources/class_notes/Bezier_curves.pdf

[modifica] Collegamenti esterni

Living Math Bézier applet
Living Math Bézier applets of different spline types, JAVA programming of splines in An Interactive Introduction to Splines
Don Lancaster's Cubic Spline Library descrive come approssimare un cerchio (o un arco di cerchio o una iperbole) con una curva di Bézier;
Bezier Curves Program permette di trovare la formula di una curva di Bézier dati i punti di inizio, fine e controllo.
Implementazione in C dell'algoritmo per disegnare Curve di Bezier di arbitrario grado su file BMP.
Applicazione flash per disegnare Curve di Bezier di grado arbitrario.

Portale Matematica: accedi alle voci di Wikipedia che trattano di matematica