Günstige Möglichkeit der Berechnung von kubischen Bézier-Länge

Einfachste Algorithmus: glätten Sie die Kurve und Aufzeichnung der euklidischen Distanz. So lange, wie Sie wollen, eine Ungefähre Bogenlänge, diese Lösung ist schnell und Billig. Angesichts Ihrer Kurve zu koordinieren LUT—Sie reden über Geschwindigkeit, so dass ich annehme, dass Sie diese verwenden, und nicht ständig neu berechnen, die Koordinaten—es ist eine einfache for-Schleife mit einer Bilanz. In generischem code, mit dist Funktion berechnet die euklidische Distanz zwischen zwei Punkten:

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

Getan. arclength jetzt ist die Ungefähre Bogenlänge auf der Basis der maximalen Anzahl der Segmente, die Sie bilden können, in der Kurve, basierend auf Ihrer LUT. Müssen die Dinge schneller und mit einem größeren möglichen Fehler? Steuern des Segments zählen.

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]);
}

Dies ist so ziemlich die einfachste mögliche Algorithmus, der noch Werte generiert, die auch nur annähernd den wahren Bogenlänge. Um alles besser, du gehst zu haben, um die Verwendung teurer numerische Ansätze (wie die Legendre-Gauss-Quadratur-Technik).

Wenn du wissen willst, warum, schlug die Bogenlänge Abschnitt von "A Primer on Bézier-Kurven".

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;
    }
}

erste von zunächst sollten Sie Verstehen den Algorithmus in Bézier,
Wenn ich die Codierung ein Programm von c#, Das war voll von Grafik-material, das ich verwendet, beziers und die viele Zeit, die ich hatte, um einen Punkt zu finden cordinate in Bézier , whic es scheinen imposisble in den ersten Blick. also das, was ich Tue, zu schreiben, das Kubische Bézier-Funktion in mein Kostüm math-Klasse, die war in meinem Projekt. so möchte ich den code mit Euch.

    //--------------- 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++;
        }
    }

wie Sie oben sehen, ist dies der Weg einer bezier-Funktion arbeiten und Sie ziehen die gleiche Bezier wie Microsoft Bézier-Funktion tun( ich habe es testen). Sie können machen es noch genauer durch die Inkrementierung der array-Größe und-Zähler der Größe oder zeichnen elipse statt line& ... . Alle von Ihnen abhängen, die Sie brauchen und das Niveau der Genauigkeit, die Sie brauchen, und ... .

Rückkehr zum Hauptziel ,die Frage ist, wie calc die Länge???

nun, Die Antwort ist wir Haben Tonnen von Punkt und jeder von Ihnen hat ein x coorinat-und y-Koordinaten, die denken Sie daran, uns eine Dreieck-Form & vor allem Eine RightTriabgle Form. wenn wir also Punkt p1 & p2 , können wir berechnen, den Abstand von Ihnen als RightTriangle Akkord. wie wir mehr aus unserem Matheunterricht in der Schule, im ABC-Dreieck Typ RightTriangle -, Akkord-Länge ist -> Sqrt(der Winkel ist FrontCostalLenght ^ 2 + Winkel ist SideCostalLeghth ^ 2);

und es ist diese Beziehung zwischen allen Punkten, die wir calc die Länge zwischen aktuellen Punkt und dem letzten Punkt vor dem aktuellen Punkt(exmp p[i - 1] & p[i]) und speichern die Summe von Ihnen allen in einer Variablen. können zeigen, dass es im code Balg

//--------------- 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;
        }

wenn Sie möchten, um eine schnellere Berechnung brauchen nur zu reduzieren, px & py array-Länge und loob zählen.

Wir können auch verringern Speicherbedarf durch die Reduzierung von px und py der array-Länge auf 1 oder einen einfachen double-Variablen, sondern weil der Bedingte situation Passiert, die zu einer Erhöhung Unserer Big O habe ich es nicht getan.

Hoffe es hat dir geholfen, so viel. wenn noch weitere Fragen haben einfach Fragen.
Mit Besten GRÜßEN, Herr - der islamischen Republik Iran.