Discussion :

[Ubum]

Bonjour,

Comme marqué dans le titre je debute en Opengl .

Apres avoir cherché longuement sur internet et fait de nombreux echec je viens ici pour poser ma question:

Je veut realiser une surface de bezier a partir de 4 courbes de bezier (ou meme 3 si c'est possible) et ceci a partir d'un tableau de coordonnées.

J'ai trouvé ce bout de code sur un site:

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
 
        static GLfloat ctrlpoints[4][4][3] = {
            {{-1.5, -1.5,   4.0-15.0}, {-0.5, -1.5,  2.0-15.0},
             { 0.5, -1.5, -1.0-15.0}, { 1.5, -1.5,  2.0-15.0}}, 
            {{-1.5, -0.5,   1.0-15.0}, {-0.5, -0.5,  3.0-15.0}, 
             { 0.5, -0.5,   0.0-15.0}, { 1.5, -0.5, -1.0-15.0}}, 
            {{-1.5,  0.5,   4.0-15.0}, {-0.5,  0.5,  0.0-15.0}, 
             { 0.5,  0.5,   3.0-15.0}, { 1.5,  0.5,  4.0-15.0}}, 
            {{-1.5,  1.5, -2.0-15.0}, {-0.5,  1.5, -2.0-15.0}, 
             { 0.5,  1.5,   0.0-15.0}, { 1.5,  1.5, -1.0-15.0}}
        };
        glEnable(GL_LINE_SMOOTH);
        glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, &ctrlpoints[0][0][0]);
        glEnable(GL_MAP2_VERTEX_3);
        glRotatef(float(180.0*sin(tt/1000)), 0.0, 0.0, 1.0);
        glColor3f(1.0, 1.0, 1.0);
        glMapGrid2f(9, 0.0, 1.0, 9, 0.0, 1.0);
        glEvalMesh2(GL_LINE, 0, 9, 0, 9);
        glDisable(GL_MAP2_VERTEX_3);

Ce bout de code me covient parfaitement car il a l'air simple a premiere vue mais apres l'avoir decortiquer je m'apercois que je ne le comprend pas.
Ce que je ne comprend pas en premier lieu c'est le tableau de coordonnée.
Quel est l'ordre de celui ci ? Quel sotn els point qui terminent les courbes et quels sont les points intermediaires ?
Dans quel ordre dois je mettre mes courbes.

Aussi je m'apercois que dans ce tableau, aucun point n'est present deux fois alors que pour moi si une zone est delimitée par 4 courbes alors cchacune de ces courbes a ses 2 extremités en partagés avec deux autres courbes qui la touchent. (les extremités doivent apartenir a deux courbes) ?

Si vous pouvez me donner le mode de fonctionnement de ce code ou me donner un exemple de code qui fonctionne ausis bien, je suis preneur.

Merci.[/code]

[Crapouille]

Je veut realiser une surface de bezier a partir de 4 courbes de bezier (ou meme 3 si c'est possible) et ceci a partir d'un tableau de coordonnées.
Si vous pouvez me donner le mode de fonctionnement de ce code ou me donner un exemple de code qui fonctionne ausis bien, je suis preneur.

J'ai un peu etudie les courbes de beziers. Voici je ce j'ai compris:
Les courbes de Bezier sont des courbes a fonctions parametriques x(t) et y(t) de degre trois, c’est a dire qu'elles secrivent sous la forme :
x(t) = a0 + b0 * t + c0 * t^2 + d0 * t^3 et :
y(t) = a1 + b1 * t + c1 * t^2 + d1 * t^3.

Une courbe de Bezier est definie par :
--> ses deux extremites de position respectifs :
(x0, y0) = (x(0), y(0)) et :
(x1, y1) = (x(1), y(1))
--> et ses deux demi tangentes :
(u0, v0) = (x'

[Crapouille]

Desole je suis damne avec non explorateur :

--> et ses deux demi tangentes :
(u0, v0) = (x'(0), y'(0)) et (u1, v1) = (x'(1), y'(1))

Pour calculer les coef a0 b0 c0 et d0 faut resoudre le systeme suivant :

x(0) = b0
x'(0) = a0
x(1) = a0 + b0 + c0 + d0
x'(1) = b0 + 2c0 + 3d0

ce ki donne :

a0 = x0
b0 = u0
c0 = 3x1 - 3x0 -2u0 -u1
d0 = u1 - 2x1 +2x0 + u0

on fait de meme pour les coef de y(t).

[bigquick]

Salut,

Je passe juste par là rapidement, mais voilà le code que j'utilise pour afficher des carreaux de béziers (de taille N*M):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Variables:
 
float*	m_aPoints;				// points de controle
int		m_iNbPointsParCourbe;	// nombre de points par courbe
int		m_iNbCourbes;			// nombre de courbes
int		m_iPrecision;			// precision d'affichage
 
// coordonnées de texture
static GLfloat aTexCoords[2][2][2] =
{
	{ {0.0, 0.0}, {0.0, 1.0} },
	{ {1.0, 0.0}, {1.0, 1.0} }
};

et

Code :

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

m_aPoints = new float[m_iNbPointsParCourbe * m_iNbCourbes * 3];

et enfin

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
	glColor3f(1,1,1);
 
	glMap2f(GL_MAP2_VERTEX_3, 0, 1, 3*m_iNbCourbes, m_iNbPointsParCourbe, 0, 1, 3, m_iNbCourbes, m_aPoints);
	glMap2f(GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, &aTexCoords[0][0][0]);
 
	glEnable(GL_MAP2_VERTEX_3);
	glEnable(GL_MAP2_TEXTURE_COORD_2);
	glEnable(GL_AUTO_NORMAL);
 
	glColor3f(1,1,1);
	glMapGrid2f(m_iPrecision, 0.0, 1.0, m_iPrecision, 0.0, 1.0);
	glEvalMesh2(GL_FILL, 0, m_iPrecision, 0, m_iPrecision);
 
	glDisable(GL_MAP2_VERTEX_3);
	glDisable(GL_MAP2_TEXTURE_COORD_2);

et (re)enfin (ce qui t'expliquera tu dois utiliser ton tableau de points de contrôle)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
// _t = numéro de la courbe, _v = numéro du piont sur la courbe
float* getPositionPointDeControle(int _v, int _t)
{
	// un pointeur sur les coordonnées du point _v,_t
	return & m_aPoints[  ( _v * m_iNbCourbes )*3 + _t*3 ];
}
 
à utiliser comme ceci:
 
float *p = getPositionPointDeControle(v,t);
p[0] = x;
p[1] = y;
p[2] = z;

J'espère que ça t'aidera un peu, normalement ca fonctionne pour toutes les tailles D'ailleurs si ac fonctionne pas ca m'intéresse de le savoir
A+

bigquick

[soubre]

Bonjour,

pour plus de précisions, les courbes de bézier peuvent être de degré quelconques (et non uniquement de degré 3).

Son allule (et son degré) dépend de son nombre de points de contrôle.

Tu devrais chercher l'algorithme de De Casteljau, qui fonctionne aussi bien pour une courbe ou une surface (à une dimension près).

Pour information, leur fonctionnement est très peu différent des courbes de bézier rationnelles, des b-splines et des nurbs (et leur implémentation n'est qu'une variante de De Casteljau).

Voilà

[shenron666]

Ce que je ne comprend pas en premier lieu c'est le tableau de coordonnée.
Quel est l'ordre de celui ci ? Quel sotn els point qui terminent les courbes et quels sont les points intermediaires ?
Dans quel ordre dois je mettre mes courbes.

Aussi je m'apercois que dans ce tableau, aucun point n'est present deux fois alors que pour moi si une zone est delimitée par 4 courbes alors cchacune de ces courbes a ses 2 extremités en partagés avec deux autres courbes qui la touchent. (les extremités doivent apartenir a deux courbes) ?

Si vous pouvez me donner le mode de fonctionnement de ce code ou me donner un exemple de code qui fonctionne ausis bien, je suis preneur.

Merci.[/code]

En fait c'est simple, le tableau que tu vois est de taille :
[4][4][3] = [4][4][xyz]
soit 4 points à l'horizontale, 4 en profondeur et 3 coordonnées par points
donc au final pour simplifier il s'agit de 4 courbes de 4 points

opengl se débrouille tout seul pour créer un b-patch = surface paramétrique ou surface de bézier enfin je suis pas pro là dedans donc je pense que tu peux déjà mieux comprendre avec ça ;-)

[Instant]

salut !

jte connseillerais d'aller sur le site de mon prof d'opengl.

http://www.limsi.fr/Individu/jacquemi/

----> tu vas dans "Cours-stages" puis "Cours" puis "Licence / Master1 d'informatique" et enfin dans le tableau tu vas au numéro 8, sur les surfaces, t'as même le corrigé et si tu cliques sur "surfaces" t'as tout le cours.