Tesseler un carreau de bézier

Salut !

Je cherche une méthode pour tesseler "intélligemment" un carreau de bézier... et je n'ai rien trouvé sur le net avec mes premières recherches :cry:

En fait, je dispose d'un ensemble de carreaux, que j'affichais pour l'instant grâce aux évaluateurs OpenGL .... mais j'utilisais la même précision pour tous les carreaux (15x15). C'est un peu dommage, sachant que certains sont limite des surfaces planes....

Donc, ma question : ;)
Est-ce que vous voyez un moyen de déterminer la précision nécessaire du maillage pour que la tesselation soit appropriée ? (ni trop peu, ni trop ....)

Merci pour toutes vos idées (j'ai peut être une idée à base d'angles entre les tangentes, mais ça reste encore un peu vague dans ma tête :) )


bigquick

A part faire une tessellation "maison" je vois pas, il n'y a rien de tout prêt à ma connaissance

une question par rapport à cela, lorsque tu as 2 carreaux avec un niveau de tessellation différente tu fais comment ?

si tu pouvais nous expliquer ton but final nous pourrions éventuellement t'orienter vers des solutions alternatives

Salut!

Citation:

---

une question par rapport à cela, lorsque tu as 2 carreaux avec un niveau de tessellation différente tu fais comment ?

---

:oops: euh j'avais pas trop pensé aux carreaux qui se suivent et qui ne sont pas subdivisés de la même façon....


Sinon pour résumer, je souhaite charger et afficher une route (que l'on me fournit sous la forme d'un ensemble de carreaux de bézier). Tout ça se passe bien, mais j'ai remarqué que les performances n'étaient pas "top" puisque je subdivise de la même manière les portions de route droites et les portions courbes.
(par exemple sur la capture d'écran http://i2.photobucket.com/albums/y31...ick/bezier.jpg, il faut bien entendu plus de subdivision que pour un morceau de route tout plat).

Je cherche donc une méthode pour déterminer la précision qu'ils faut passer à l'évaluateur OpenGL en fonction de la courbure du patch .... et si possible en tenant compte des patchs environnant (afind 'éviter d'avoir des trous dans la route quand on passe d'un patch à l'autre ;) )


ps: j'ai trouvé ce post sur FlipCode: http://www.flipcode.com/cgi-bin/fcms...read_show=5281 mais je n'arrive pas à faire fonctionner la solution (la méthode proposée prend en parametre P0, P1, P2 et je ne vois pas à quoi cela correspond vraiment)

... et quelques articles sur Gamasutra, mais qui portent sur la subdivision en général (et ça m'embete de transformer tous mes patchs en une grande surface à subdiviser, puisque là je bénéficie du culling du moteur qui n'affiche que les patchs visibles).


enfin donc, au final tu penses qu'il faut laisser tomber les évaluateurs OpenGL, et s'orienter vers une tesselation "maison" de chaque patch ?

petite info en plus:
normalement, les morceaux de route que l'on me passe sont censés se suivre sans cassure.... donc à priori, si ma fonction pour trouver la subdivision est correcte, il ne devrait pas y avoir de trous entre 2 patchs consécutifs (il devrait subdiviser

Capture d'écran d'une route vue du dessus (on voit plusieurs patchs consécutifs subdivisés différemment avec une fonction de test pas très performante) :
http://i2.photobucket.com/albums/y31...k/jointure.jpg


Petite illustration cadeau :) (vous pouvez apprecier au passage mes qualités de dessinateur :lol: )
http://i2.photobucket.com/albums/y31.../jointure2.gif

Il y a des formules pour déterminer la courbure maximale d'une surface, avec des calculs sur sa dérivée seconde. En fonction de ça tu peux en déduire un niveau de tesselation approprié je pense. Bref cherche de ce côté là.

Par contre ça n'a rien à voir avec OpenGL, si tu n'y vois pas d'inconvénient je déplace la conversation dans le forum Algorithmes.

Merci!

Je vais aller voir de ce coté là (mais j'avoue que je ne m'y connais pas trop en maths du coté des surfaces) ...

et sinon aucune objection pour changer de forum ;)

Oui je pense que la meilleure solution est de faire toi même un module de tessellation maison qui serait capable entre autre de trianguler une surface paramétrique (un patch) avec un indice de subdivion différent pour chaque côté

quand à l'article sur FlipCode, à propos de P0, P1 et P2, je pense qu'il s'agit des points de la courbe, une courbe de bézier étant toujours composée d'un point de départ (P0), d'un point d'arrivée (P2) et de N points de controle (ici un seul : P1)

je te conseille vivement de bien de renseigner, te former, concernant les surfaces de bézier et/ou les bsplines pour avancer en toute connaissance de cause

bon courage

Citation:

---

quand à l'article sur FlipCode, à propos de P0, P1 et P2, je pense qu'il s'agit des points de la courbe, une courbe de bézier étant toujours composée d'un point de départ (P0), d'un point d'arrivée (P2) et de N points de controle (ici un seul : P1)

---

ah ok .... ca me paraissait bizarre, puisque pour moi une surface de bézier était définie par M courbes, comportant chacune au moins 4 points (pour définir une coube de bézier il faut pas 2 tangentes ?)

Enfin du coup j'ai fini par me faire une méthode à moi pour calculer la "courbure" du carreau:

Code:

---

1 2 3 4 5

- pour chaque courbe - calculer le vecteur A qui lie ses deux points extremes - pour chaque couple de points successifs (P0P1, P1P2, P2P3, ...) calculer le vecteur B qui les lie - calculer l'angle entre les vecteurs A et B

---

et donc la somme de tous les angles calculés donne une approximation de la courbure (un carreau plan et rectiligne aura une somme valant 0). Après il suffit juste de déterminer la précision de al tesselation en fonction de la courbure obtenue...

C'est p'tet pas top, mais ça marche à peu près ;)
En fait ca me permet surtout de garder l'évaluation du carreau par OpenGL (2 appels suffisent pour qu'il evalue et dessine le carreau)

----

Citation:

---

Oui je pense que la meilleure solution est de faire toi même un module de tessellation maison qui serait capable entre autre de trianguler une surface paramétrique (un patch) avec un indice de subdivion différent pour chaque côté

---

En fait, ce n'est pas vraiment la triangluation qui me posait problème, mais comment obtenir les indices du subdivision. Mais avec ta remarque, je me suis dit: quitte à triangluer à la main (au lieu de laisse OpenGL s'en charger), autant optimiser au passage, c'est à dire avoir non pas un indice de subdivision par coté, mais un ensemble de triangles qui ne forment pas forcément une grille regluière.

Merci pour ton aide du coup, pis je vous tiendrai au courant si j'obtiens un module génial-qui-fait-tout, ça pourrait servir ;)

Pour le calcul de la courbure, il me semble que c'est l'intégrale (double puisque c'est une surface) de la norme de la dérivée seconde. C'est en tout cas ce que j'avais utilisé dans un travail sur les B-Splines.

La dérivée n'est pas difficile à obtenir avec les Béziers, et l'intégrale se règle très bien avec MonteCarlo étant donné que tu n'as pas besoin d'une grosse précision.

Ouah ! Bah je vais regarder tout ça ... le nom "l'intégrale double de la norme de la dérivée seconde" fait un peu peur, mais tu as l'air de dire que c'est largement faisable ;)

Ca sera pas pour tout de suite, parceque j'ai une soutenance demain (la dernière!!! après c'est finiiiiiiiiiiiiiiiiii :lol: ), mais dès que j'en suis débarassé, je me replonge la dedans, et je vous tiens au courant !

Merci beaucoup Loulou24!