Bon marché mode de calcul de bézier cubique longueur

Plus simple algorithme: aplatir la courbe et le décompte de la distance euclidienne. Aussi longtemps que vous le souhaitez une évaluation approximative de la longueur d'arc, cette solution est rapide et bon marché. Compte tenu de votre courbe de coordonnées de LUT—vous parlez de la vitesse, donc je suis en supposant que vous utilisez ceux-ci, et ne sont pas toujours recalculer les coordonnées—c'est une simple boucle for avec un pointage. Dans le code générique, avec une dist fonction qui calcule la distance euclidienne entre deux points:

var arclength = 0,
    last=LUT.length-1,
    i;
for (i=0; i<last; i++) {
  arclength += dist(LUT[i], LUT[i+1]);
}

Fait. arclength est maintenant le approximative de la longueur de l'arc basé sur le nombre maximum de segments vous pouvez la forme de la courbe en fonction de votre LUT. Besoin de choses plus vite avec un plus grand potentiel d'erreur? Contrôle le segment comte.

var arclength = 0,
    segCount = ...,
    last=LUT.length-2,
    step = last/segCount,
    s, i;
for (s=0; s<=segCount; s++) {
  i = (s*step/last)|0;
  arclength += dist(LUT[i], LUT[i+1]);
}

C'est à peu près le plus simple possible algorithme qui génère toujours des valeurs qui viennent même proche de la véritable longueur de l'arc. Pour quelque chose de mieux, vous allez avoir à utiliser plus cher des techniques numériques (comme l'Legendre-Gauss quadrature technique).

Si vous souhaitez savoir pourquoi, frapper jusqu'à la longueur d'un arc de section de "couche d'Apprêt sur les Courbes de Bézier".

public float FastArcLength()
{
float arcLength = 0.0f;
ArcLengthUtil(cp0.position, cp1.position, cp2.position, cp3.position, 5, ref arcLength);
return arcLength;
}
private void ArcLengthUtil(Vector3 A, Vector3 B, Vector3 C, Vector3 D, uint subdiv, ref float L)
{
if (subdiv > 0)
{
Vector3 a = A + (B - A) * 0.5f;
Vector3 b = B + (C - B) * 0.5f;
Vector3 c = C + (D - C) * 0.5f;
Vector3 d = a + (b - a) * 0.5f;
Vector3 e = b + (c - b) * 0.5f;
Vector3 f = d + (e - d) * 0.5f;
//left branch
ArcLengthUtil(A, a, d, f, subdiv - 1, ref L);
//right branch
ArcLengthUtil(f, e, c, D, subdiv - 1, ref L);
}
else
{
float controlNetLength = (B-A).magnitude + (C - B).magnitude + (D - C).magnitude;
float chordLength = (D - A).magnitude;
L += (chordLength + controlNetLength) / 2.0f;
}
}

d'abord vous devez d'abord Comprendre l'algorithme de l'utilisation de courbes de Bézier,
Quand j'étais à coder un programme en c# Qui était plein de matériel graphique, j'ai utilisé de béziers et beaucoup de temps, j'ai dû trouver un point cordinate de bézier , qui semble imposisble dans le premier regard. donc, la chose que j'ai à faire était d'écrire de bézier Cubique fonction dans mon costume de la classe math qui était en mon projet. je vais donc partager le code avec vous en premier.

    //--------------- My Costum Power Method ------------------\\
public static float FloatPowerX(float number, int power)
{
float temp = number;
for (int i = 0; i < power - 1; i++)
{
temp *= number;
}
return temp;
}
//--------------- Bezier Drawer Code Bellow ------------------\\
public static void CubicBezierDrawer(Graphics graphics, Pen pen, float[] startPointPixel, float[] firstControlPointPixel
, float[] secondControlPointPixel, float[] endPointPixel)
{
float[] px = new float[1111], py = new float[1111];
float[] x = new float[4] { startPointPixel[0], firstControlPointPixel[0], secondControlPointPixel[0], endPointPixel[0] };
float[] y = new float[4] { startPointPixel[1], firstControlPointPixel[1], secondControlPointPixel[1], endPointPixel[1] };
int i = 0;
for (float t = 0; t <= 1F; t += 0.001F)
{
px[i] = FloatPowerX((1F - t), 3) * x[0] + 3 * t * FloatPowerX((1F - t), 2) * x[1] + 3 * FloatPowerX(t, 2) * (1F - t) * x[2] + FloatPowerX(t, 3) * x[3];
py[i] = FloatPowerX((1F - t), 3) * y[0] + 3 * t * FloatPowerX((1F - t), 2) * y[1] + 3 * FloatPowerX(t, 2) * (1F - t) * y[2] + FloatPowerX(t, 3) * y[3];
graphics.DrawLine(pen, px[i - 1], py[i - 1], px[i], py[i]);
i++;
}
}

comme vous le voyez ci-dessus, c'est la façon dont une courbe de bézier de la Fonction de travail et en tirer les mêmes courbes de Bézier comme Microsoft Bézier est la Fonction( je l'ai tester). vous pouvez la rendre encore plus précise par l'incrémentation de la taille de la matrice et de la grandeur du compteur ou de dessiner elipse au lieu de la ligne& ... . Tous d'entre eux dépendent de vous avez besoin et le niveau de précision dont vous avez besoin et ... .

De retour pour but principal ,la Question est de savoir comment calc de la longueur???

bien La réponse est que nous Avons des tonnes de point et chacun d'eux a un x coorinat et la coordonnée y de la qui se souviennent de nous une forme de triangle & surtout Un RightTriabgle Forme. donc, si nous avons point p1 & p2 , nous pouvons calculer la distance d'eux comme un RightTriangle Accord. comme nous le rappelez-vous de nos cours de maths à l'école, dans le Triangle ABC de type RightTriangle, corde de Longueur est -> Sqrt(Angle FrontCostalLenght ^ 2 + Angle de SideCostalLeghth ^ 2);

et il y a cette relation entre tous les points que nous calc la longueur entre le point courant et le dernier point avant le point courant(exmp p[i - 1] & p[i]) et de stocker la somme de toutes dans une variable. permet de montrer dans le code soufflet

//--------------- My Costum Power Method ------------------\\
public static float FloatPower2(float number)
{
return number * number;
}
//--------------- My Bezier Lenght Calculator Method ------------------\\
public static float CubicBezierLenghtCalculator(float[] startPointPixel
, float[] firstControlPointPixel, float[] secondControlPointPixel, float[] endPointPixel)
{
float[] tmp = new float[2];
float lenght = 0;
float[] px = new float[1111], py = new float[1111];
float[] x = new float[4] { startPointPixel[0], firstControlPointPixel[0]
, secondControlPointPixel[0], endPointPixel[0] };
float[] y = new float[4] { startPointPixel[1], firstControlPointPixel[1]
, secondControlPointPixel[1], endPointPixel[1] };
int i = 0;
for (float t = 0; t <= 1.0; t += 0.001F)
{
px[i] = FloatPowerX((1.0F - t), 3) * x[0] + 3 * t * FloatPowerX((1.0F - t), 2) * x[1] + 3F * FloatPowerX(t, 2) * (1.0F - t) * x[2] + FloatPowerX(t, 3) * x[3];
py[i] = FloatPowerX((1.0F - t), 3) * y[0] + 3 * t * FloatPowerX((1.0F - t), 2) * y[1] + 3F * FloatPowerX(t, 2) * (1.0F - t) * y[2] + FloatPowerX(t, 3) * y[3];
if (i > 0)
{
tmp[0] = Math.Abs(px[i - 1] - px[i]);//calculating costal lenght
tmp[1] = Math.Abs(py[i - 1] - py[i]);//calculating costal lenght
lenght += (float)Math.Sqrt(FloatPower2(tmp[0]) + FloatPower2(tmp[1]));//calculating the lenght of current RightTriangle Chord  & add it each time to variable
}
i++;
}
return lenght;
}

si vous souhaitez accélérer le calcul de la juste besoin de réduire px & py tableau de longueur et loob comte.

Nous aussi peut réduire la mémoire nécessaire par la réduction de px et py à la matrice de longueur de 1 ou de faire une simple variable de type double, mais parce que de mise en situation dans les Parages qui Augmentent Notre Big O, je ne l'ai pas fait.

Espère que cela vous a aidé beaucoup. si vous avez une autre question, il suffit de demander.
Avec mes Meilleures salutations, Heydar - République Islamique d'Iran.