SPLINE disegno di linee e superfici definite da un insieme di punti dati, approssimanti una linea (o superfice) ideale definita dai punti dati, linea interpolante i punti...

spline per modellare una superficie non facilmente esprimibile con facce piane (triangoli) o con una superficie quadrica o cubiche si usa una tecnica di approssimazione: dato un insieme di punti si puo' definire una curva ottenuta da spezzoni di curve polinomiali che : approssima i punti dati (passa vicino ad essi) passa per i punti dati (interpolazione)

spline in 2D: dato un insieme di punti si puo' definire una curva ottenuta da spezzoni di curve polinomiali che passa oppure approssima i punti dati (interpola oppure passa vicino ad essi) la parola spline originariamente indicava una asticella flessibile usata dagli artigiani per ottenere una curva interpolante alcuni punti dati ( l' asticella veniva ancorata a questi punti, e per la sua flessibilita' essa "passava" per questi punti) oggi una linea spline si intende una linea approssimante ottenuta da spezzoni di polinomiali (normalmente cubiche) CON IL VINCOLO di essere continua e di avere la derivata prima (talvolta anche la seconda) continue

definizione della parola inglese : SPLINE definizione della parola inglese : spline |splīn| |splaɪn| |splʌɪn|noun 1 a rectangular key fitting into grooves (scanalature) in the hub (centro) and shaft (asse) of a wheel, esp. one formed integrally with the shaft that allows movement of the wheel on the shaft.･ a corresponding groove in a hub along which the key may slide. 2 a slat (asticella, es. parte di una tenda veneziana) a flexible wood or rubber strip used esp. in drawing large curves - 3 (also spline curve) Mathematics a continuous curve constructed so as to pass through a given set of points and have a certain number of continuous derivatives.

spline dati 4 punti si puo' definire una curva ottenuta da spezzoni di curve polinomiali che * passa per i punti dati (interpolazione), nella figura a destra a destra una linea interpolante (Bezier) 4 punti, oppure che * approssima i punti dati (passa vicino ad essi), nella figura a sinistra una linea approssimante (BSpline),

spline dati n punti si puo' definire una curva ottenuta da spezzoni di curve polinomiali che * passa per i punti dati (interpolazione) oppure che * passa vicino i punti dati (approssimazione) in figura una linea approssimante (BSpline),

spline in 3D: per modellare una superficie non facilmente esprimibile con * facce piane (triangoli) o con * superfici quadriche o cubiche (una faccia, una sagoma d'automobile) si usa una tecnica di approssimazione: dato un insieme di punti si puo' definire una superficie ottenuta da spezzoni di superfici polinomiali che * passano per i punti dati (interpolazione) oppure * approssimano i punti dati (passa vicino ad essi) nella pagina seguente un esempio di superficie costruita con frammenti di superfici cubiche approssimanti un insieme di punti dati (punti di controllo)

Vedremo in seguito il caso 3D spline nello spazio tridimensionale - in figura a destra una superficie ottenuta con frammenti di superfici cubiche approssimanti dei punti dati (non visualizzati) disegnata in tre modalita' diverse * a linee * a punti * a triangoli pieni i dati di partenza sono un reticolo di 4 x 4 punti, ( x[i]=x0+i*dx, y[j]=y0+j*dy, e z[i,j]=f(x[i],y[j]) ) (nella pagina seguente sono segnati anche i punti di controllo); Vedremo in seguito il caso 3D

spline in figura una superficie approssimante un insieme di 4x4 punti dati (punti di controllo) - nota: i punti sono a distanza dx e dy costante, come si vede a destra - ma cambia z=f(x,y) [sotto] vista da sopra nota: due punti di controllo stanno sotto la superfice vista di fianco (anche qui alcuni punti di controllo non sono visibili)

esempio di modello 3D di una faccia questa figura "Oscar" (derivata dal modello "Geoface" da rete) e'stata usata per simulare i movimenti dei muscoli del viso in sincronia con un parlato sintetico di un programma che legge ad alta voce un testo scritto e fornisce tramite la faccia anche un aiuto visivo (Righetti, tesi apr.2008) la "resa" della superficie del viso e' fatta con la libreria OpenGL usando metodi di illuminazione e di tessitura standard; (lavoro iniziato da uno studente del corso EGD del 2006)

dati ad es. 3 punti come in figura spline ritorniamo al caso 2D: vediamo l' idea di base: dati ad es. 3 punti come in figura a fianco sopra posso definire una linea continua che approssimi oppure interpoli i tre punti; aggiungendo un punto, in totale 4 punti dati, la linea e' ottenuta da tre spezzoni, raccordati in modo da essere continui e avere la stessa tangente nel punto di raccordo (derivata prima continua) in basso, 5 punti dati, linea formata da quattro spezzoni di curve cubiche raccordate x x x x x

spline vediamo l'idea di base: 4 punti dati (p.ti di controllo) linea fatta da tre spezzoni raccordati (continui e con la stessa tangente nel punto di raccordo o; importante: la linea (cubica) e' tracciata come una polyline, ovvero come una linea spezzata di piccoli segmenti di retta !! i vertici dei singoli segmentini (i punti neri in fig.) sono calcolati (funzione cubica) dai punti dati vicini (in figura, dai primi tre punti dati); i segmentini sono "abbastanza" corti da non vederli,

spline con piu' punti di controllo posso ottenere una curva generica, ad es. come in figura, ottenuta in forma parametrica; si noti come i punti di controllo funzionano da "attratori" della linea complessiva; spostando un punto la linea "segue" localmente lo spostamento. la linea viene approssimata con una spezzata a tratti (segmenti) tanto corti da apparire una linea curva continua, e qui e' scelta in modo da passare vicino ai punti dati (punti di controllo)

modellazione con curve e superfici interpolanti Due mini esempi di figure costruite con interpolanti: con estensione a 3D (e con un po' di software) si possono ottenere immagini altrimenti difficilmente ottenibili, e che sono facilmente editabili (spostando un o piu' punti di controllo). Nota che a sinistra la curva passa vicino per i punti di controllo, a destra passa per i punti di controllo (algorit.diversi)

L' algoritmo di De Casteljau Con 3 punti ho una curva approssimante con due passi di interpolazione lineare: sul segmento P1-P2 ho il punto A = P1*(1-u) + P2*u, (A==P1 se u=0, A==P2 se u=1), sul segmento P2-P3 ho B = P2*(1-u) + P3*u; (qui u vale 0,3) cosi' da tre punti passo a due; ripeto l'interpolazione per il segmento A-B, e ho P = A*(1-u) + B*u NB: P, punto della curva, comincia da P1 per u=0 (u=0 -> A==P1 e B==P2) e alla seconda interpol. tra A e B, P==A==P1) e poi percorre [u da 0 a 1] la curva fino a P3 (con u=1, P==B==P3); per disegnare la curva si approssima con nsegmenti di retta. La fig.e'data da: www2.mat.dtu.dk/people/J.Gravesen/cagd/decast.html

L' algoritmo di De Casteljau u=0.3 a sinistra, u=0.5 in mezzo, u=0.7 a dest.; qui sono dati 4 punti di controllo o, i passi di interpolazione sono tre, uno piu' di prima. www2.mat.dtu.dk/people/J.Gravesen/cagd/decast.html NOTA: l' algoritmo di De Casteljau e' molto semplice (vedremo) ma usa tutti i punti di controllo per fare un punto generico della curva, per tale motivo non e' molto usato; il progr. EGD_4B non riesce a disegnare una curva con Casteljau se vi sono piu' di 20 punti controllo.

L' algoritmo di De Casteljau Ancora due esempi sull' algoritmo De Casteljau: in figura con 4 punti di controllo (rosso e verde), un punto della curva segnato in giallo, e disegnati i segmenti interpolanti al primo e al secondo livello interpolazione, con il fattore di controllo u (qui t) a valore 0.5 www2.mat.dtu.dk/people/J.Gravesen/cagd/decast.html

L' algoritmo di De Casteljau ancora, curva con 9 pti di controllo e con 8 segmenti, e con 8=9-1 passi di interpolazione lineare che vanno da 9 pti (8 seg) (1) a 8 pti (7 seg) (2) a 7 pti (6 seg) (3) a 6 pti (5 seg) (4) a 5 pti (4 seg) (5) a 4 pti (3 seg) (6) a 3 pti (2 seg) (7) a 2 pti (1 seg) (8) a 1 punto o che sta sulla curva

L' algoritmo di De Casteljau - //nota:struct tpunto{float x;floaty;}; void casteljau ( float PTabX[ ],float PTabY[ ], int PointCount, int nseg ) { int k; float kf,u; tpunto punti[NN]; tpunto p; if(PointCount>NN) exit(71); for (k=0; k<PointCount; k++) { // cambia formato punti[k].x = PTabX[k]; // pti punti[k].y = PTabY[k]; } // for glBegin( GL_LINE_STRIP ); glVertex2f( punti[0].x, punti[0].y ); // 1.o for (k = 0; k<= nseg; k++ ){ kf = k; u = kf/nseg; //<< nota fattore u !! p = castel( punti, 0, PointCount -1, u); // ricorsiva Pointcount volte (segue) glVertex2f( p.x, p.y ); // punto da fattore u } // for k glEnd(); } // casteljau

L' algoritmo di De Casteljau ... struct tpunto { float x; float y; }; ... tpunto castel(tpunto punti[ ],int i,int NumPun, float u) { tpunto p,p1,p2; if( NumPun == 1 ) { // punto della curva ! p.x =(1.0-u) *punti[i].x + u *punti[i+1].x; p.y =(1.0-u) *punti[i].y + u *punti[i+1].y; } else { // interpola tra due punti dati a // loro volta da 2 pti interpolan.a livello.. p1 = castel( punti, i, NumPun-1, u ); p2 = castel( punti, i+1, NumPun-1, u ); p.x = (1.0-u) * p1.x + u * p2.x; // e questo p.y = (1.0-u) * p1.y + u * p2.y; // e'il punto } // if NumPun return p; } // castel

spline vediamo meglio il procedimento dati n punti P k esistono vari tipi di funzioni che passano per i punti dati, ad es. polinomiali, trigonometriche, esponenziali ecc; in grafica sono usate le funzioni interpolanti / approssimanti di tipo polinomiale, in genere sono curve cubiche: y = f(x) (nel piano), qui usiamo la forma parametrica x = fx(u), y = fy(u), z = fz(u) scelta utile se si vogliono rappresentare linee del tipo in figura, dove per alcuni x posso avere piu' valori y... se ho n punti Pk posso esprimere una linea come somma di termini, ciascuno relativo ad un punto Pk : P(u) = somma(per i da 1 a n) Pi * Bi(u) ovvero separatamente: fx(u) = somma(per i da 1 a n) xi * Bi(u) fy(u) = somma(per i da 1 a n) yi * Bi(u)

le Bi sono dette Blending Functions: spline dati n punti P k f(x) funzioni polinomiali che passano per/vicino i punti dati: y = f(x), oppure, meglio, in forma parametrica x = fx(u), y = fy(u), (u = parametro che individua un punto della curva) se ho n punti Pk esprimo una linea come somma delle coordinate dei punti pesate con una funzione opportuna B(u): fx(u) = ∑i=1,n xi * Bi(u) fy(u) = ∑i=1,n yi * Bi(u) le Bi sono dette Blending Functions: per ogni u le Bi danno l' influenza del i-esimo punto lungo la curva la Bi esprime "la forza" con cui il punto Pi attrae la la curva; blend -> ORIGIN Middle English : probably of Scandinavian origin and related to Old Norse blanda = to mix.

spline per disegnare la curva approssimante i punti Pk dati, x = fx(u), y = fy(u), z = fz(u) se ho n punti Pk posso esprimere una linea come somma di termini, ciascuno relativo ad un punto: fx(u) = somma(per i da 1 a n) xi * Bi(u) fy(u) = somma(per i da 1 a n) yi * Bi(u) le Bi = Blending Functions danno l' influenza del i-esimo punto Pk lungo la curva; ogni Bi esprime "la forza" con cui il punto Pi attrae la la curva; se abbiamo tutte le Bi tali che per qualunque u per j != i risulta Bj (u) == 0 e solo per j==i Bi (u) ==1 allora la curva passera' per tutti i punti Pi P1 P2 P3

spline curva generica data in forma parametrica: fx(u) = somma(per i da 1 a n) xi * Bi(u) Bi = Blending fy(u) = somma(per i da 1 a n) yi * Bi(u) Functions scegliamo le Bi in modo che per j != i vale Bj(u) == 0 e che per j==i vale Bi(u) ==1 (per qualunque u) allora la curva passa per il punto Pi ovvero per i punti di controllo; le funzioni che possono soddisfare a questa richiesta sono tipo: u(u-1)(u-2)...(u-(n-2)) aggiungo fattore tale che Bi (u) ==1, e ho: B1(u) = u(u-1)(u-2)...(u-(n-2)) / (-1)(-2)(-3)..(1-n) che vale 1 per u == -1, poi applico un fattore di scala (denominat.) in modo che: Bi(u) = (u+1)(u)(u-1)..(u-(i-3)) (u-(i-1)) ..(u-(n-2 )) vale 1 per u==i-2 / ( (i-1)(i-2)..(1) (-1) (-2) .. (i-n) ) e vale 0 u==k in questo caso ogni punto controllo partecipa alla curva (come in Casteljau) ... cosa in genere non pratica

fx(u) = somma(per i da 1 a n) xi * Bi(u) spline fx(u) = somma(per i da 1 a n) xi * Bi(u) fy(u) = somma(per i da 1 a n) yi * Bi(u) fz(u) = somma(per i da 1 a n) zi * Bi(u) vediamo un esempio con 4 punti: scelgo u tale che se u==-1 sono su P1, e ho B1(u)= u(u-1)(u-2) / (-1)(-2)(-3) B1(u) vale 1 se u== -1, e vale 0 se u=0,1,2 se u==0 sono su P2, e ho B2(u)= (u+1)(u-1)(u-2) / (1)(-1)(-2) B2(u) vale 1 se u == 0, e vale 0 se u=-1,1,2 se u==1 sono su P3, e ho B3(u)= (u+1)u(u-2) / (2)(1)(-1) B3(u) vale 1 se u == 1, e vale 0 se u=-1,0,2 se u==2 sono su P4, e ho B4(u)= (u+1)u(u-1) / (3)(2)(-1) B4(u) vale 1 se u == 2 e vale 0 se u=-1,0,1 P2 P3 u=0 u=1 P1 P4 u=-1 u=2

B1(u)= (u(u-1)(u-2))/((-1)(-2)(-3)) B1(u) vale 1 se u== -1, e spline con 4 punti: se u==-1 sono su P1, e ho B1(u)= (u(u-1)(u-2))/((-1)(-2)(-3)) B1(u) vale 1 se u== -1, e vale zero se u=0,1,2 se u==0 sono su P2, e ho B2(u)=((u+1)(u-1)(u-2))/((1)(-1)(-2)) B2(u) vale 1 se u == 0, e vale zero se u=-1,1,2 se u==1 sono su P3, e ho B3(u)= ((u+1)u(u-2)) /((2)(1)(-1)) B3(u) vale 1 se u == 1, e ... se u==2 sono su P4, e ho B4(u)= ((u+1)u(u-1))/((3)(2)(-1)) B4(u) vale 1 se u == 2 , e ... Pj P2 P3 u=0 u=1 P1 P4 u=-1 u=2 x=somma in k di (xk*Bk(u)) y=somma in k di (yk*Bk(u)) z=somma in k di (zk*Bk(u)) la curva approssima la curva ideale che interpola i 4 punti al meglio nell'intervallo P2-P3, dove posso ricavare altri punti Pj per u che sta tra 0 e 1, ad es nove punti per valori 0,1/8,2/8,.. fino a 7/8 e 8/8, e quindi ho 8 segmenti nell'intervallo P2-P3

B1(u)= (u(u-1)(u-2))/((-1)(-2)(-3)) B1(u) vale 1 se u== -1 spline con 4 punti: B1(u)= (u(u-1)(u-2))/((-1)(-2)(-3)) B1(u) vale 1 se u== -1 B2(u)=((u+1)(u-1)(u-2))/((1)(-1)(-2)) B2(u) vale 1 se u == 0 B3(u)= ((u+1)u(u-2)) /((2)(1)(-1)) B3(u) vale 1 se u == 1 B4(u)= ((u+1)u(u-1))/((3)(2)(-1)) B4(u) vale 1 se u == 2 lo schema (cubiche) e' applicabile al caso di n punti: per ogni tratto Pk - Pk+1 si considerano i 4 punti da Pk-1 a Pk+2 ovvero: nel tratto P2-P3 uso i punti P1-P4 , nel tratto P3-P4 uso i punti P2-P5 , nel tratto P4-P5 uso i punti P3-P6 ecc P2 P3 u=0 u=1 P1 P4 u=-1 u=2 P3 P4 u=0 u=1 P2 P5 u=-1 u=2 P4 P5 u=0 u=1 P3 P6 u=-1 u=2

spline - cubiche approssimanti vediamo in dettaglio lo schema e la realizzazione con procedure ad-hoc di una spline approssimante con funzioni di blending cubiche:

blending functions per curva approssimante, somma sempre 1

Bezier approssimanti con 3, 4, 4, 4, 5 punti di controllo

una proprieta' delle curve di Bezier approssimanti: all' inizio (e alla fine) curva la tangente e' data dai primi (ultimi) due punti

blending functions periodiche (fatte da quadriche) con controllo piu' locale (a segmenti u1,u2,u3..[knots] uniformi)

vediamo una procedura con b-spline cubiche (prog.EGD_4BSPLINE) procedure b-spline vediamo una procedura con b-spline cubiche (prog.EGD_4BSPLINE) /* bspline globals [static!] */ const int nb=6; /* 6 line section = knots number */ float b[4][nb]; /*6*4=24 blending values=pesi per xx,yy*/ float xx[100]; /* copia degli nd+5 punti dati */ float yy[100]; /* punto iniziale triplice, quindi +2, punto finale quadruplo, quindi +3 */ bool first_time=true; // la procedura principale e' la bspline: void bspline ( float x[], float y[], int nd, /*dati*/ float LineWidth, float r,float g, float b, float a ); // bspline usa altre due procedure: void setbval( ){ // prepara i coeff. del blending, void make_one ( int k ) // disegna un tratto di curva: vediamo >>

procedura b-spline void bspline ( float x[], float y[], int nd, /*dati*/ float myLineWidth, float r,float g, float b, float a ){ if(first_time) /* prepara i coefficienti b[i][j] */ { setbval(); first_time=false; } if(nd<=1) { return; } /* niente da disegnare */ if(nd==2) { ... disegna un segmento e poi ... return; } for( i=0; i< nd; i++ ){ /* fa prima una copia locale */ xx[i+2]=x[i]; yy[i+2]=y[i]; } /* e prepara il punto iniziale triplo, il finale quadr */ xx[0]=x[0]; yy[0]=y[0]; xx[1]=x[0]; yy[1]=y[0]; for(int k=2;k<5;k++) // k=2,3,4 { xx[nd+k]=x[nd-1]; yy[nd+k]=y[nd-1]; } xm=xx[0]; ym=yy[0]; /*used in make_one as previous pt*/ for(i=1; i< nd+2; i++ ) /* finalmente disegna i */ make_one( i ); /* singoli tratti tra i pti dati */ } /*bspline */

procedure b-spline: prepara i coefficienti b setbval prepara i coefficenti b per il calcolo di P(u): (cfr con B0=(1-u)^3, B1=3u(1-u)^2, B2=3u^2(1-u), B3=u^3 void setbval( ){/* prepare blend values for nn lines */ float u, u2, u3, u_1Alla3, b0,b1,b2,b3, Fact_b2; if(first_time) { for (int i=0; i<nb; i++) { /*nb=6=nr segm per sezione*/ u = i/fnb; u2 = u*u; u3 = u2*u; /* u da 0 a 1-1/6 */ u_1Alla3 = (1 - u) * (1 - u) * (1 - u); Fact_b2 = (((1 - u) * u +1) * u +1.0/3.0) / 2.0; b0= u_1Alla3/6.0; // b0= (1.0-u)*(1.0-u)*(1.0-u)/6.0; b2= Fact_b2; // b2= (-3*u3 + 3*u2 +3*u +1)/6.0; b3= u3 / 6.0; // b3= u^3/6.0; b1= 1-b0 -b2 -b3; // b1= (3*u3 - 6*u2 +4 )/6.0; b[0][i]= b0; b[3][i]= b3; b[2][i]= b2; b[1][i]= b1; } /* for i */ first_time=false; } /* if first_time */ } /* setbval */ } /* setbval */

proc fa un tratto di spline void make_one(int k){ /*draw line section xx[k]..xx[k+1] b[0][j],b[1][j]..,b[3][j]=blending weights for xx data, j is the "u parameter", here from 0 to 5(nb=6 knots)*/ int i, j; float xl, yl; if(k<=0) return; glLineWidth(myLineWidth); glColor4f(myr,myg, myb, mya ); /* line strip red */ for (j=0; j<nb; j++){ /* nb=6=linesegment sections nr*/ xl=0; yl=0;/*4 addendums for each point xl,yl,given by points xx[k-1],xx[k],xx[k+1],xx[k+2] */ for (i=0; i<4; i++) { xl=xl+xx[k+i-1] * b[i][ j]; yl=yl+yy[k+i-1] * b[i][ j]; } /* for i */ /* now draw a line */ glBegin(GL_LINE_STRIP); glVertex2f( xm,ym ); glVertex2f( xl,yl ); glEnd(); xm = xl; ym = yl; /*remember current for previous*/ } /* for j */ } /* make */

spline 3 4 es di spline con nb = numero segmenti per tratto di linea x 3 4 x x x x es di spline con nb = numero segmenti per tratto di linea uguale a 3 (qui sopra) e, a destra, 4(sopra) e 6(sotto) * con 6 segmenti quasi non si nota l'approssimazione della curva con una spezzata 6

spline segue un esempio di codice OpenGL per uso delle procedure previste dalla libreria, che sono la prepara coefficienti : glMap1f( GL_MAP1_VERTEX_3, 0, 1, 3, 5, &(PuntiContr[0][0]) ); // umin=0, umax=1, stride=3, order=6-1 e al posto della make_one abbiamo: glBegin( GL_LINE_STRIP); /*UN tratto di 6 segm*/ for (k=0; k<=nseg; k++) glEvalCoord1f((float)k/nsegf); glEnd();

stride, /* =3, e'4 se coordinate omogenee, altro bsplineOGL(float PTabX[], float PTabY[], int PointCount, float LineW, float r,float g, float b, float a ) { .. kb=0; while( kb < PointCount ) { /* fa PointCount tratti */ /*prepara la matrice coefficenti per disegno seguente:*/ glMap1f( GL_MAP1_VERTEX_3, uMin, uMax, /*0 e 1 */ stride, /* =3, e'4 se coordinate omogenee, altro se uso anche il colore: e' la distanza tra due punti di controllo nell'array PuntiContr */ order, /* =6 qui */ &(PuntiContr[0][0]) ); ...glBegin( GL_LINE_STRIP); /* fa UN tratto di 6 segm*/ for (k=0; k<=nseg; k++) glEvalCoord1f((float)k/nsegf); glEnd(); /* glEval gives the b-spline approxim */ kb = kb+order-1; /*avanza di 5=order-1 posiz */ } /* while kb*/ glDisable( GL_MAP1_VERTEX_3 ); } /* drawOGLSpline */

bsplineOGL(float PTabX[], float PTabY[], int PointCount, float LineW, float r,float g, float b, float a ) { /* prepare Bezier param */ const int PntCountMax=200; ... float PuntiContr[PntCountMax][3]; if(PointCount<=2)return;... kb=0; /*nel while alla fine c'e' kb=kb+order-1 */ while( kb < PointCount ) { /* fa PointCount tratti */ kptLim = order; if( kptLim+kb > PointCount ) kptLim=PointCount-kb; for (kpt=0; kpt<kptLim; kpt++) { PuntiContr[kpt][0] = PTabX[kb+kpt]; /* X */ PuntiContr[kpt][1] = PTabY[kb+kpt]; /* Y */ PuntiContr[kpt][2] = 0.0; /* Z */ } /* for */ glMap1f(GL_MAP1_VERTEX_3,0,1,3,5,&(PuntiContr[0][0])); glEnable( GL_MAP1_VERTEX_3 ); ...glBegin( GL_LINE_STRIP); /* fa UN tratto di 6 segm*/ for (k=0; k<=nseg; k++) glEvalCoord1f((float)k/nsegf); glEnd(); /* glEval gives the b-spline approxim */ kb = kb+order-1; /*avanza di 5=order-1 posiz */ } /* while kb*/ glDisable( GL_MAP1_VERTEX_3 ); } /* drawOGLSpline */

quattro esempi di curve spline (6 punti controllo dati) Spline Cubica, OpenGLspline,Casteljau, Bezier

quattro esempi di curve spline (7 punti controllo dati) Spline Cubica, OpenGLspline,Casteljau, Bezier

spline nel caso 3D i 4 punti di controllo diventano 16, e le blending-functions diventano somme a due indici, : P(u,v) = somma di Pku,kv*Bku(u)*Bkv(v) in ku e in kv che e' un punto del frammento di superfice definito dai punti di controllo, anche qui, si possono ottenere buone approssimazioni considerando un reticolo di 4x4 punti per disegnare il rettangolino in mezzo; il reticolo si "sposta" lungo il reticolo dato dei punti di controllo, e del reticolo 4x4 interessa ad ogni passo solo la parte centrale, per u e v da 0 a 1 ...

fine