Discussion :

[Avalion]

Bonjour à tous et à toutes.

Bloquant sur une question mathématique, je viens à vous après quelques semaines d'arrachage de cheveux sur ce problème concernant les courbes de Bézier.

Rappelons donc que les courbes de Bezier sont données par cette équation :
C(t) = P0 * (1 - t)^3 + P1 * t * (1 - t)^2 + P2 * t^2 * (1 - t) + P3 * t^3
avec P0 le point de départ, P1 la tangente à C en P0, P2 la tengante en P3 et P3 le point d'arrivée et t appartenant à [0,1]

Le problème est le suivant.

Connaissant t, j'aimerais trouver t + dt tel que la longueur de l'arc entre t et t + dt soit égal à un pas p.

Niveau code, voici une classe contenant une courbe de bézier, contenant une fonction d'approximation de sa longueur, ainsi que GetNextPosition calculant la position a t + dt cependant, elle ne fonctionne évidemment pas comme je le désire (vitesse non constante).
(calculLength est lancée au début, avant tout appel de GetNextPosition)

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
 
public class Bezier {
    public Vector3 p1;
    public Vector3 p2;
    public Vector3 p3;
    public Vector3 p4;
 
    private float length;
 
    private void calculLength() {
        length = 0;
        Vector3 start = p0;
        Vector3 end;
        for (int i = 0; i < 1000; i++) {
            float t = i / 1000
            end = p0 * Mathf.Pow((1 - t), 3) + 3 * p1 * t * (1 - t) * (1 - t) + 3 * p2 * t * t * (1 - t) + p3 * Mathf.Pow(t, 3);
            length += Vector3.Distance(start, end);
            start = end;
        }
    }
 
    public Vector3 GetNextPosition(float _progress, float _step) {
        Vector3 start = p0;
        Vector3 end;
 
        float t = _progress + _step/length;
 
        return p0 * Mathf.Pow((1 - t), 3) + 3 * p1 * t * (1 - t) * (1 - t) + 3 * p2 * t * t * (1 - t) + p3 * Mathf.Pow(t, 3);
    }
}

J'ai donc également une autre classe qui permet d'afficher un élément le long de cette courbe grâce à la fonction getNextPosition (_progress est mis à jour dans cette classe pour le moment)

Un ami m'a conseillé de passer par les intégrales curvilignes mais ne connaissant pas trop le domaine, arriver a l'appliquer à mon cas n'est pas une mince affaire, même après les nombreuses recherches à ce sujet.

Merci d'avance a tous les matheux.

[dancingmad]

Bonjour,

On peut en effet utiliser les intégrales curvilignes. à l'instant t, la vitesse du point de la courbe est C'(t), et donc la norme de cette vitesse vaut ||C'(t)||. Ainsi, la distance parcourue sur une période dt est :

Code :

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

intégrale de t à t+dt de ||C'(u)||.du

Pour régler ton problème, il faut donc résoudre l'équation:

Code :

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

intégrale de t à t+dt de ||C'(u)||.du = p

C'est une équation assez compliquée, mais qui doit être faisable (j'avoue ne pas avoir essayé de la résoudre). Si tu a des problèmes pour la résoudre, n'hésite pas

[theMonz31]

salut

tu peux aussi prendre l'option par dichotomie...

Tu essayes une valeur pour dt et si tu es "très" proche de p, c bon, sinon,
suivant que tu es au dessus ou au dessous, tu augmentes ou diminues dt...

En quelques "itérations", tu devrais trouver ton dt facilement.

[LinuxUser]

J'ai implémenter quand j'étais à la Fac les courbes et surfaces de Bézier ainsi que les NURBS.
Y a un super livre qui pourrait t'aider, t'y trouveras notamment les algorithmes de Casteljau et Cox-DeBoor.
http://books.google.fr/books/about/T...kC&redir_esc=y