Como obter velocidade uniforme de movimento em uma curva bezier?

Estou tentando mover uma imagem ao longo da curva de Bezier. É assim que eu faço:

- (void)startFly
{    
 [self runAction:[CCSequence actions:
             [CCBezierBy actionWithDuration:timeFlying bezier:[self getPathWithDirection:currentDirection]],
             [CCCallFuncN actionWithTarget:self selector:@selector(endFly)],
             nil]];

}

Meu problema é que a imagem não se move uniformemente. No começo, ele está se movendo lentamente e depois acelera gradualmente e, no final, está se movendo muito rápido. O que devo fazer para me livrar dessa aceleração?

É possível aproximar uma solução para esse problema para a maioria das trajetórias paramétricas. A idéia é a seguinte: se você aplicar zoom suficientemente profundo em uma curva, não poderá distinguir a curva da tangente nesse ponto.

Ao fazer essa suposição, não há necessidade de precompor nada mais do que dois vetores (três para curvas de Bezier cúbicas etc. ).

Portanto, para uma curva , calculamos seu vetor tangente no ponto . A norma desse vetor é e, portanto, a distância percorrida por uma duração pode ser aproximada como . Segue-se que uma distância é percorrida por uma duração .$M(t)$$\frac{dM}{dt}$$t$$\lVert \frac{dM}{dT} \rVert$$\Delta t$$\lVert \frac{dM}{dT} \rVert \Delta t$$L$$L \div \lVert \frac{dM}{dT} \rVert$

Aplicação: curva quadrática de Bezier

Se os pontos de controle da curva de Bezier são , e , a trajetória pode ser expressa como:$A$$B$$C$

$$\begin{align} M(t) &= (1-t)^2A + 2t(1-t)B + t^2C \\ &= t^2(A - 2B + C) + t(-2A + 2B) + A \end{align}$$

Portanto, a derivada é:

$$\frac{dM}{dt} = t(2A - 4B + 2C) + (-2A + 2B)$$

Você só precisa armazenar vetores e algum lugar. Então, para um dado , se você quiser avançar um comprimento , faça:$\vec v_1 = 2A - 4B + 2C$$\vec v_2 = -2A + 2B$$t$$L$

$$t = t + {L \over length(t \cdot \vec v_1 + \vec v_2)}$$

Curvas cúbicas de Bezier

O mesmo raciocínio se aplica a uma curva com quatro pontos de controle , , e :$A$$B$$C$$D$

$$\begin{align} M(t) &= (1-t)^3A + 3t(1-t)^2B + 3t^2(1-t)C + t^3D \\ &= t^3(-A + 3B - 3C + D) + t^2(3A - 6B + 3C) + t(-3A + 3B) + A \end{align}$$

A derivada é:

$$\frac{dM}{dt} = t^2(-3A + 9B - 9C + 3D) + t(6A - 12B + 6C) + (-3A + 3B)$$

Pré-calculamos os três vetores:

$$\begin{align} \vec v_1 &= -3A + 9B - 9C + 3D \\ \vec v_2 &= 6A - 12B + 6C \\ \vec v_3 &= -3A + 3B \end{align}$$

e a fórmula final é:

$$t = t + {L \over length(t^2 \cdot \vec v_1 + t \cdot \vec v_2 + \vec v_3)}$$

Problemas de precisão

Se você estiver executando em uma taxa de quadros razoável, (que deve ser calculado de acordo com a duração do quadro) será suficientemente pequeno para que a aproximação funcione.$L$

No entanto, você pode enfrentar imprecisões em casos extremos. Se for muito grande, você poderá fazer o cálculo por partes, por exemplo, usando 10 partes:$L$

for (int i = 0; i < 10; i++)
    t = t + (L / 10) / length(t * v1 + v2);

Você precisa reparamaterizar a curva. A maneira mais fácil de fazer isso é calcular os comprimentos do arco de vários segmentos da curva e usá-los para descobrir de onde você deve amostrar. Por exemplo, talvez em t = 0,5 (no meio do caminho), você deve passar s = 0,7 para a curva para obter a posição "no meio do caminho". Você precisa armazenar uma lista de comprimentos de arco de vários segmentos de curva para fazer isso.

Provavelmente existem maneiras melhores, mas aqui está um código C # muito simples que escrevi para fazer isso no meu jogo. Deve ser fácil portar para o Objetivo C:

public sealed class CurveMap<TCurve> where TCurve : struct, ICurve
{
    private readonly float[] _arcLengths;
    private readonly float _ratio;
    public float length { get; private set; }
    public TCurve curve { get; private set; }
    public bool isSet { get { return !length.isNaN(); } }
    public int resolution { get { return _arcLengths.Length; } }

    public CurveMap(int resolution)
    {
        _arcLengths = new float[resolution];
        _ratio = 1f / resolution;
        length = float.NaN;
    }

    public void set(TCurve c)
    {
        curve = c;
        Vector2 o = c.sample(0);
        float ox = o.X;
        float oy = o.Y;
        float clen = 0;
        int nSamples = _arcLengths.Length;
        for(int i = 0; i < nSamples; i++)
        {
            float t = (i + 1) * _ratio;
            Vector2 p = c.sample(t);
            float dx = ox - p.X;
            float dy = oy - p.Y;
            clen += (dx * dx + dy * dy).sqrt();
            _arcLengths[i] = clen;
            ox = p.X;
            oy = p.Y;
        }
        length = clen;
    }

    public Vector2 sample(float u)
    {
        if(u <= 0) return curve.sample(0);
        if(u >= 1) return curve.sample(1);

        int index = 0;
        int low = 0;
        int high = resolution - 1;
        float target = u * length;
        float found = float.NaN;

        // Binary search to find largest value <= target
        while(low < high)
        {
            index = (low + high) / 2;
            found = _arcLengths[index];
            if (found < target)
                low = index + 1;
            else
                high = index;
        }

        // If the value we found is greater than the target value, retreat
        if (found > target)
            index--;

        if(index < 0) return curve.sample(0);
        if(index >= resolution - 1) return curve.sample(1);

        // Linear interpolation for index
        float min = _arcLengths[index];
        float max = _arcLengths[index + 1];
        Debug.Assert(min <= target && max >= target);
        float interp = (target - min) / (max - min);
        Debug.Assert(interp >= 0 && interp <= 1);
        return curve.sample((index + interp + 1) * _ratio);
    }
}

Edit: Vale a pena notar que isso não fornecerá o comprimento exato do arco, pois é impossível obter o comprimento do arco de uma curva cúbica. Tudo o que isso faz é estimar o comprimento dos vários segmentos. Dependendo do comprimento da curva, pode ser necessário aumentar a resolução para impedir que ela mude de velocidade quando atingir um novo segmento. Eu costumo usar ~ 100, com o qual nunca tive problemas.

Uma solução muito leve é ​​aproximar a velocidade em vez de aproximar a curva. Na verdade, essa abordagem é independente da função da curva e permite que você use qualquer curva exata em vez de usar derivadas ou aproximações.

Aqui está o código para o C # Unity 3D:

public float speed; // target linear speed

// determine an initial value by checking where speedFactor converges
float speedFactor = speed / 10; 

float targetStepSize = speed / 60f; // divide by fixedUpdate frame rate
float lastStepSize;

void Update ()
{   
    // Take a note of your previous position.
    Vector3 previousPosition = transform.position;

    // Advance on the curve to the next t;
    transform.position = BezierOrOtherCurveFunction(p0, p1, ..., t);

    // Measure your movement length
    lastStepSize = Vector3.Magnitude(transform.position - previousPosition);

    // Accelerate or decelerate according to your latest step size.
    if (lastStepSize < targetStepSize) 
    {
        speedFactor *= 1.1f;
    }
    else
    {
        speedFactor *= 0.9f;
    }

    t += speedFactor * Time.deltaTime;
}

Embora a solução seja independente da função de curva, eu queria anotá-la aqui, pois também estava procurando como obter velocidade constante em uma curva de Bezier e, em seguida, forneço essa solução. Considerando a popularidade da função, isso pode ser útil aqui.

Eu não sei nada sobre cocos2, mas uma curva de bezier é um tipo de equação paramétrica, portanto, você poderá obter seus valores xey em termos de tempo.