Courbes de Beziers

**venomelektro** · 08/12/2004, 11h51

Hello,

dans mon moteur , j ai de quoi faire des courbes de beziers , l une des utilité que j en ai est de les utiliser pour des trejectoires de camera

c tres joli , seulement voila , ma fonction de courbe de beziers n a que 4 points de controle ( je sais pas si c possible de faire plus ??)

donc pour faire un chemin de camera de plus de 4 points je fais comme ca :

je calcule ou j en suis dans le chemin (0 -> 1 ) et en fonction de ca je calcule mon point sur une courbe de beziers de 4 points

donc jusqu au point 3 je prends les 4 premiers points (0,1,2,3) apres je prends les 3,4,5,6 ..etc...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
 
struct PathPoint {
 
    Vector3 position;
    Vector3 lookat;
};
 
 
Vector3 PointOnCurve(Vector3 &p1, Vector3 &p2, Vector3 &p3, Vector3 &p4, float t)
{
	float var1, var2, var3;
 
    Vector3 vPoint;
 
    var1 = 1 - t;
    var2 = var1 * var1 * var1;
    var3 = t * t * t;
 
    vPoint.x = var2*p1.x + 3*t*var1*var1*p2.x + 3*t*t*var1*p3.x + var3*p4.x;
    vPoint.y = var2*p1.y + 3*t*var1*var1*p2.y + 3*t*t*var1*p3.y + var3*p4.y;
    vPoint.z = var2*p1.z + 3*t*var1*var1*p2.z + 3*t*t*var1*p3.z + var3*p4.z;
 
    return(vPoint);				
}
 
 
Vector3 PointOnCurvePath(vector <PathPoint> &pnt,float t ,int pos ) {
 
    if (pnt.size() == 0 ) return ( Vector3(0,0,0) );
 
    float nt,rt;
 
    int ipt0,ipt1,ipt2,ipt3,index;
 
    nt  =  t *  (float)(pnt.size() - 1 );
	nt /=  3.0f ;
 
	index = 0;
 
	rt = nt-floor(nt);
 
	while (floor(nt)>0) {
 
		nt--;
		index+=3;
 
	}
 
	ipt0 = index;
	ipt1 = index + 1;
	ipt2 = index + 2;
	ipt3 = index + 3;
 
	if (ipt1  >= pnt.size() ) ipt1 = ipt1 - pnt.size();
	if (ipt2  >= pnt.size() ) ipt2 = ipt2 - pnt.size();
	if (ipt3  >= pnt.size() ) ipt3 = ipt3 - pnt.size();
 
	if (pos == VGL_POSITION) {
return PointOnCurve(pnt[ipt0].position,pnt[ipt1].position,pnt[ipt2].position,pnt[ipt3].position,rt);
	}
 
	else {
return PointOnCurve(pnt[ipt0].lookat,pnt[ipt1].lookat,pnt[ipt2].lookat,pnt[ipt3].lookat,rt);	
	}
 
}

donc ca ca marche pas trop mal j ai bien une courbe continue quel que soit le nombre de points dans mon path mais le probleme , c que tous les 4 points la courbe a une "cassure angulaire" quand on change de points ( eg passage de 0 1 2 3 à 3 4 5 6 ..)

screenshot :

http://schafik.free.fr/img/path.jpg

bon est ce que quelqu un a deja fait des trucs dans le style et a une idée du moyen d eviter ce probleme

**LeGreg** · 09/12/2004, 06h05

Tu peux faire des courbes de Bezier a autant de points de controles que tu veux puisque ce sont de simples courbes polynomiales. (il faut augmenter leur degré pour chaque nouveau point de controle).

Pour le raccordement c'est normal si tu te contentes de coller des courbes qui n'ont qu'un seul point commun entre elle. On parle de continuité C0 ("C Zéro") dans ce cas, et toi ce que tu veux c'est une continuité C1 ("C un").

L'avantage des courbes de Bezier c'est que la continuité C1 est très facile à obtenir. Il suffit que si tu as deux courbes C et C', raccordé en un point Pn == P'0. Cela te garantit la continuité C0, mais c'est ce que tu as déjà. Pour avoir la continuité C1, tu choisis le point précédent Pn-1 et le point suivant P'1 dans un alignement parfait avec le point Pn/P'0.

J'avais écrit un article il y a TREEEES longtemps qui expliquait un peu les caractéristiques des courbes de Bezier et des polynomes de Bernsein.
http://www.massal.net/article/courbes.htm

Hope that helps,
A+
LeGreg

**venomelektro** · 09/12/2004, 08h10

Salut et merci pour ta réponse

Je vais lire ton article

effectivement je comprends bien pourquoi il a cette angle , c vrai qu en mettant des courbes a 4 points bout a bout c est logique ,

Pour avoir la continuité C1, tu choisis le point précédent Pn-1 et le point suivant P'1 dans un alignement parfait avec le point Pn/P'0.

si j ai bien compris , dès que j' ai dépasé un point sur la courbe , je prends le dernier point derriere moins comme premier point de la courbe et ainsi de suite , donc je serais toujours entre le premier et le deuxieme point d une courbe non .? ( ou alors je comprends rien lol

)

Il me semble que j avais deja essayé de faire ca et que ca marchait pas ( la courbe n etais pas continue) mais peut etre avais je fais une connerie

Je vais reessayer dans ce sens

A+

**venomelektro** · 09/12/2004, 10h29

A ba non en fait

j y arrive pas , la j ai bien une courbe continue mais pas du tout du beziers c presque linéaire

je suis parti du raisonnement que je calcule une courbe de beziers a 4 points de controle , en partant du dernier point derriere moi et les trois points suivant,

je code donne ca , je crois pas avoir fait d erreur de calcul mais peut etre que le raisonnement est faux

pour precision mon temps t en entré est 0 au debut du path et 1.0f a la fin

Greg je comprends pas trop cette partie

Pour avoir la continuité C1, tu choisis le point précédent Pn-1 et le point suivant P'1 dans un alignement parfait avec le point Pn/P'0.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
Vector3 PointOnCurvePath(vector <PathPoint> &pnt,float t ) {
 
    if (pnt.size() == 0 ) return ( Vector3(0,0,0) );
 
    float nt = t;
 
    int ipt0,ipt1,ipt2,ipt3,index;
 
    index = ipt0 = ipt1 = ipt2 = ipt3 = 0;
 
    float interval = ( 1.0f / ((float)pnt.size() - 1 ) );
 
	while ( nt > interval) {
 
		nt-=interval;
		index++;
 
	}
 
	ipt0 = index;
	ipt1 = index + 1;
	ipt2 = index + 2;
	ipt3 = index + 3;
 
	if (ipt1  >= pnt.size() ) ipt1 = ipt1 - pnt.size();
	if (ipt2  >= pnt.size() ) ipt2 = ipt2 - pnt.size();
	if (ipt3  >= pnt.size() ) ipt3 = ipt3 - pnt.size();
 
	return PointOnCurve(pnt[ipt0].position,pnt[ipt1].position,pnt[ipt2].position,pnt[ipt3].position,nt);
	}

:

**LeGreg** · 09/12/2004, 11h17

C'est pas clair ?

**LeGreg** · 09/12/2004, 11h23

En gros, quand tu positionnes tes points de controles, après avoir placé P0,P1,P2,P3. P'1 n'est plus libre.

Tu dois modifier ton programme pour que si ton utilisateur modifie P2, P'1 bouge pour rester aligné, de meme s'il modifie P'1 alors P2 doit bouger pour rester aligner. C'est le seul moyen de conserver les tangentes alignées.

**venomelektro** · 09/12/2004, 13h46

ok,

rassure toi c pas que c pas clair c moins qui suis nul lol

j ai compris la avec ce que tu viens de me dire mais le probleme c que la pour l instant je me servait pour les path de point placés arbitrairement par l utilisateur sans aucune contraite donc ca pouvait pas fonctionner

Merci pour ton aide.

**venomelektro** · 09/12/2004, 14h14

Pour en rajouter une couche ,

voila un zoli schema que m a fait un ami graphiste :

pour le path du haut c est ce dont tu parle LeGreg

mais pour celui du bas ?

dans le soft on peut bouger les points verts independamment les uns des autres , comment faire ce type de path alors ?

**Laurent Gomila** · 09/12/2004, 15h21

Pourquoi ne pas calculer directement un seul Bézier avec tous tes points plutôt que d'en raccorder plusieurs ? Sinon tu as aussi les B-splines (qui sont une généralisation des Béziers, avec un contrôle local) et les splines cubiques. Ces dernières ne sont pas très dures à implémenter, c'est ce que j'utilisais dans mon moteur 3D.

**venomelektro** · 10/12/2004, 08h09

pour les petits mouvements de camera , je me contente effectivement d une simple courbe de beziers a 4 points,

mais par exemple pour faire un chemin de quelques centaines de points ( par exemple une camera qui survole un terrain ) ca ne contient pas

je vais regarder de ce coté ca me semble pas mal

http://www.mvps.org/directx/articles/catmull/

A+

**Blowih** · 23/12/2004, 00h29

Salut,
pour rester avec des courbes de bezier à n points, le probleme c que tu obtien un polynome de bernstein de degres n-1, par example, avec 100 points ton polynome sera de degres 99, a commence à etre lourd en calcul...
tu peu voir du coté de l'algo de casteljau, avec une recursion assez simple, tu obtien le meme resultat que le polynome de bernstein, mais il n'y a pas de factoriel dans les calcul, et une pour une centaine de points ç devien bcp plus gerable.

En esperant que ça te donne des idées
Ciao!

Courbes de Beziers

OpenGL

Discussions similaires

Partager

Partager