Curva di Bézier

Da Wikipedia, l'enciclopedia libera.

Una curva di Bézier è una particolare curva parametrica, che ha grande applicazione 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.

Storia[modifica | modifica sorgente]

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 a partire da due punti e una linea vettoriale, un sistema innovativo che permette ancora oggi agli operatori grafici di realizzare disegni curvilinei precisi. Le curve di Bézier possono essere realizzate da molti programmi di grafica vettoriale come Inkscape, Gimp, Corel Draw, Adobe Illustrator, Adobe Photoshop, Adobe After Effects o FreeHand, o di cartografia piana come OCAD.

Analisi dei casi[modifica | modifica sorgente]

Curve di Bézier lineari[modifica | modifica sorgente]

Dati i punti P0 e P1, una curva di Bézier lineare è il segmento avente come estremi i punti dati. Tale curva è data da

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

Curve di Bézier quadratiche[modifica | modifica sorgente]

Una curva di Bézier quadratica è il percorso tracciato tramite la funzione B(t), dati i punti P0, P1, e P2,

\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 così come la grafica vettoriale di Adobe Flash usano le spline di Bézier composte da curve di Bézier quadratiche.

Curve di Bézier cubiche[modifica | modifica sorgente]

Bezier curve.svg

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

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. Anche uno strumento semplice come Paint incluso in Windows dispone di semplici curve di Bézier cubica.

Generalizzazione[modifica | modifica sorgente]

La curva di Bézier di grado n può essere generalizzata come segue. Dati i punti P0, P1,..., Pn, 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].

Terminologia[modifica | modifica sorgente]

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 00 = 1.

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

Note[modifica | modifica sorgente]

  • La curva inizia in P0 e termina in Pn; 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.

Costruzione delle curve di Bézier[modifica | modifica sorgente]

Curve lineari[modifica | modifica sorgente]

Animazione di una curva di Bézier lineare, t in [0,1]
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 P0 a P1. Per esempio quando t=0.25, B(t) è un quarto del percorso da P0 a P1. Al variare di t da 0 a 1, B(t) descrive l'intero segmento compreso tra P0 e P1.

Curve quadratiche[modifica | modifica sorgente]

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

  • Il punto Q0 varia da P0 a P1 e descrive una curva lineare di Bézier.
  • Il punto Q1 varia da P1 a P2 e descrive una curva lineare di Bézier.
  • Il punto B(t) varia da Q0 a Q1 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]
Costruzione di una curva quadratica di Bézier Animazione di una curva quadratica di Bézier, t in [0,1]

Curve cubiche e di ordine superiore[modifica | modifica sorgente]

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

Per una curva cubica si possono costruire i punti Q0, Q1 e Q2 che descrivono una curva di Bézier lineare, e i punti R0 e R1 che descrivono una curva di Bézier quadratica:

Costruzione di una curva di Bézier cubica Animazione di una curva di Bézier cubica, t in [0,1]
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 Q0, Q1, Q2 e Q3 che descrivono curve di Bézier lineari, i punti R0, R1 e R2 che descrivono curve quadratiche di Bézier, e i punti S0 e S1 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]
Costruzione di una curva di Bézier di quarto ordine Animazione di una curva di Bézier di quarto ordine, t in [0,1]

Applicazioni nella computer grafica[modifica | modifica sorgente]

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 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 );
  }

Applicazione in Visual Basic 6[modifica | modifica sorgente]

'Option Explicit
'questo deve essere inserito in un modulo'
Type BezierPoint
    X As Single
    Y As Single
End Type
 
'Inserire il tutto in un form con il name form2
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

Curve di Bézier razionali[modifica | modifica sorgente]

Alcune curve che sembrano semplici, come la circonferenza, 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 Pi, 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 
}.

Bibliografia[modifica | modifica sorgente]

Voci correlate[modifica | modifica sorgente]

Collegamenti esterni[modifica | modifica sorgente]