ci-dessus maxVelocity change de direction en diagonale, contournement

Question

La faille ici dans la classe VelocityTracker d'Android que si votre vitesse dans la direction X dépasse la vitesse maxVelocity, elle est égale à maxVelocity et la même chose pour le Y. Mais, cela signifie que si nous allons à un angle de 20 ° et à une vitesse de 200, et notre maxVelocity est de 20. Notre vitesse est modifiée pour être de 20 * sqrt (2) à un angle de 45 °. La bonne réponse consiste à mettre à l'échelle le mXVelocity et le mYVeloicity par le rapport de la vitesse réelle et de la maxVelocity.

Ma question est de savoir si je dois recourir à deux racines carrées pour corriger cette erreur?

La vitesse est la direction et la vitesse d'un objet. Changer la direction en raison de la vitesse maximale a été atteint doit être considéré comme un défaut. Cela entraîne également une lacune en ce sens qu'une vitesse diagonale est plus rapide que la vitesse orthogonale.

Le bit problématique d'un code semblable à:

mXVelocity = accumX < 0.0f ? Math.max(accumX, -maxVelocity) : Math.min(accumX, maxVelocity); 
mYVelocity = accumY < 0.0f ? Math.max(accumY, -maxVelocity) : Math.min(accumY, maxVelocity); 

Pour contourner ce que j'utilise:

tracker.computeCurrentVelocity(units); //maxVelocity 
double velocityX = tracker.getXVelocity(); 
double velocityY = tracker.getYVelocity(); 
double actualVelocitySq = velocityX * velocityX + velocityY * velocityY; 
double maxVelocitySq = maxVelocity * maxVelocity; 
if (actualVelocitySq > maxVelocitySq) { 
    //double excessFactor = Math.sqrt(maxVelocitySq)/Math.sqrt(actualVelocitySq); 
    double excessFactor = Math.sqrt(maxVelocitySq/actualVelocitySq); //leewz's optimization 
    velocityX *= excessFactor; 
    velocityY *= excessFactor; 
} 

Est-il possible de ne pas éviter la double racine carrée? Ou une autre chose qui résout autrement ce bug visqueux?

---

Update:

La réponse semble être échelle deux composants selon l'une composante qui dépasse la vitesse maximale par le plus. Ce n'est pas strictement l'échelle en fonction de la vitesse réelle, mais il résout la majeure partie du problème avec des mathématiques faciles.

double scale; 
double vectorX = Math.abs(velocityX); 
double vectorY = Math.abs(velocityY); 
if (vectorX > maxVelocity) { 
    scale = maxVelocity/vectorX; 
    if (vectorY > maxVelocity) { 
     scale = Math.min(scale, maxVelocity/vectorY); 
    } 
    velocityX *= scale; 
    velocityY *= scale; 
} else { 
    if (vectorY > maxVelocity) { 
     scale = maxVelocity/vectorY; 
     velocityX *= scale; 
     velocityY *= scale; 
    } 
} 

Answer 1

Vous pouvez couper Math.sqrt(maxVelocitySq), parce que vous savez maxVelocitySq = maxVelocity * maxVelocity. Même sans cela, vous pouvez utiliser un seul sqrt() en faisant la première division:

double excessFactor = Math.sqrt(maxVelocitySq/actualVelocitySq); 

Mathématiquement, je crois prennent une racine carrée est nécessaire, mais comment vous prenez la racine carrée est toujours ouverte pour vous. En particulier, Fast Inverse Square Root fonctionne pour votre utilisation. Voici le code utilisant fisr().

if (actualVelocitySq > maxVelocitySq) { 
    double excessFactor = fisr(actualVelocitySq/maxVelocitySq); 
    velocityX *= excessFactor; 
    velocityY *= excessFactor; 
} 

Here's a Java implementation of FISR.

caveat: FISR a été conçu pour une ancienne génération de processeurs Intel qui étaient lents à opérations en virgule flottante (division en particulier, que le code ci-dessus utilise encore), pas une machine virtuelle JIT'd (comme Java) fonctionnant sur ARM (une architecture commune pour Android). N'oubliez pas de profiler votre code pour voir si le coût de la racine carrée est suffisamment important pour optimiser, puis de mesurer si le FISR donne une amélioration valable.

Answer 2

L'astuce consiste à ne pas mettre à l'échelle en fonction de l'amplitude du vecteur réel mais plutôt de la composante qui a le plus dépassé le besoin. Puis mettre à l'échelle x et y par cela. Il ne nécessite aucune mathématique plus difficile que la division. Et ne fubar l'angle du vecteur du tout. Tandis que le résultat de la maxVelocity pourrait, d'un certain angle, dépasser la vitesse réelle d'un facteur de sqrt (2). Il se conforme mieux à la documentation de ce que fait MaxVelocity.

maxVelocity float: Vitesse maximale pouvant être calculée par cette méthode . Cette valeur doit être déclarée dans la même unité que le paramètre . Cette valeur doit être positive.

double scale; 
double vectorX = Math.abs(velocityX); 
double vectorY = Math.abs(velocityY); 
if (vectorX > maxVelocity) { 
    scale = maxVelocity/vectorX; 
    if (vectorY > maxVelocity) { 
     scale = Math.min(scale, maxVelocity/vectorY); 
    } 
    velocityX *= scale; 
    velocityY *= scale; 
} else { 
    if (vectorY > maxVelocity) { 
     scale = maxVelocity/vectorY; 
     velocityX *= scale; 
     velocityY *= scale; 
    } 
}