Animación En una ruta con rotación automática basada en la ruta en android

Question

He intentado animar una imagen de una mosca que se mueve en una ruta como la siguiente imagen (que he agregado para tener una idea clara) en versión de Android 2.2

Bueno, esto se puede hacer de una manera muy sencilla en el iPhone, ya que tienen una propiedad forsetting esta rotación automático después de la ruta se dibuja usando

animation.rotationMode = kCAAnimationRotateAuto; 

que creo que sería girar el objeto basado en el camino`

soy capaz de animar ma volar a través de este camino usando la biblioteca nineoldandroid utilizando los métodos

path.moveTo(float x, float y); 
path.lineTo(float x, float y); 
path.curveTo(float c0X, float c0Y, float c1X, float c1Y, float x, float y); 

Tal que las curvas se trazan a través curva Bzier cúbico.

Ahora lo que he estado intentando es implementar algo que permita que mi mosca gire a lo largo del camino y simplemente no puedo alcanzar a ninguna parte.

¡Por favor, ayúdenme con algunas ideas! :(:(

Answer 1

Usted tiene que descargar la demo y de la librería de nineoldandroids y these 4 java files si quieres usar mi solución

Eso era fácil, lo modificó el evaluador en el demo de nineoldandroids.

Es demasiado para publicar aquí:

sólo para obtener la idea:

extiendo la PathPoint con el ángulo de campo. A continuación, escriba todos los puntos calculados en una pila (un simple float [] [])

Después del primer cálculo, el ángulo puede calcularse mediante el atan y los 2 últimos puntos de la pila.

Si no desea utilizar una pila, puede modificar el parámetro timeparam y esperar a que se dibuje el siguiente punto y calcular el ángulo de estos.

Simplemente piense en: ¿La primera vez que mira hacia dónde camina y luego camina o simplemente camina y luego elige el ángulo del destino? No es necesario ya que tenemos densidades de visualización tan altas y calculamos el ángulo para cada píxel.

Aquí está la PathEvaluator

public class PathEvaluatorAngle implements TypeEvaluator<PathPointAngle> { 

private static final int POINT_COUNT = 5000; 
private float[][] stack = new float[POINT_COUNT][2]; 
private int stackC = 0; 

@Override 
public PathPointAngle evaluate(float t, PathPointAngle startValue, PathPointAngle endValue) { 
    float x, y; 
    if (endValue.mOperation == PathPointAngle.CURVE) { 
     float oneMinusT = 1 - t; 
     x = oneMinusT * oneMinusT * oneMinusT * startValue.mX + 
       3 * oneMinusT * oneMinusT * t * endValue.mControl0X + 
       3 * oneMinusT * t * t * endValue.mControl1X + 
       t * t * t * endValue.mX; 
     y = oneMinusT * oneMinusT * oneMinusT * startValue.mY + 
       3 * oneMinusT * oneMinusT * t * endValue.mControl0Y + 
       3 * oneMinusT * t * t * endValue.mControl1Y + 
       t * t * t * endValue.mY; 
    } else if (endValue.mOperation == PathPointAngle.LINE) { 
     x = startValue.mX + t * (endValue.mX - startValue.mX); 
     y = startValue.mY + t * (endValue.mY - startValue.mY); 
    } else { 
     x = endValue.mX; 
     y = endValue.mY; 
    } 

    stack[stackC][0] = x; 
    stack[stackC][1] = y; 

    double angle; 

    if (stackC == 0){ 
     angle = 0; 
    } else if (stackC >= POINT_COUNT){ 
     throw new IllegalStateException("set the stack POINT_COUNT higher!"); 
    } else { 
     angle = Math.atan(
       (stack[stackC][1] - stack[stackC-1][1])/
       (stack[stackC][0] - stack[stackC-1][0])  
       ) * 180d/Math.PI; 
    } 
    stackC++; 
    return PathPointAngle.moveTo(x, y, angle); 
} 

}

Answer 2

Por favor, compruebe el siguiente link.Hope que le ayudará.

https://github.com/JakeWharton/NineOldAndroids