Finden einer Quaternion, die die Rotation von einem Vektor zu einem anderen darstellt

Ich habe zwei Vektoren u und v. Gibt es eine Möglichkeit, ein Quaternion zu finden, das die Rotation von u nach v darstellt?

Quaternion q;
vector a = crossproduct(v1, v2);
q.xyz = a;
q.w = sqrt((v1.Length ^ 2) * (v2.Length ^ 2)) + dotproduct(v1, v2);

Vergessen Sie nicht, q zu normalisieren.

Richard hat Recht damit, dass es keine eindeutige Rotation gibt, aber das Obige sollte den "kürzesten Bogen" ergeben, was wahrscheinlich das ist, was Sie brauchen.

Half-Way-Vektorlösung

Ich kam auf die Lösung, die Imbrondir meiner Meinung nach zu präsentieren versuchte (wenn auch mit einem kleinen Fehler, weshalb Sinisterchipmunk wahrscheinlich Probleme hatte, sie zu überprüfen).

Vorausgesetzt, wir können ein Quaternion konstruieren, das eine Drehung um eine Achse wie folgt darstellt:

q.w == cos(angle / 2)
q.x == sin(angle / 2) * axis.x
q.y == sin(angle / 2) * axis.y
q.z == sin(angle / 2) * axis.z

Und dass das Punkt- und Kreuzprodukt zweier normalisierter Vektoren sind:

dot     == cos(theta)
cross.x == sin(theta) * perpendicular.x
cross.y == sin(theta) * perpendicular.y
cross.z == sin(theta) * perpendicular.z

Da eine Drehung von u nach v durch Drehen um Theta (den Winkel zwischen den Vektoren) um den senkrechten Vektor erreicht werden kann, sieht es so aus, als könnten wir aus den Ergebnissen der Punkt- und Kreuzprodukte direkt eine Quaternion konstruieren, die eine solche Drehung darstellt ;; So wie es aussieht, ist Theta = Winkel / 2 , was bedeutet, dass dies zu der doppelten gewünschten Drehung führen würde.

Eine Lösung besteht darin, einen Vektor auf halbem Weg zwischen u und v zu berechnen und das Punkt- und Kreuzprodukt von u und dem halben Vektor zu verwenden, um eine Quaternion zu konstruieren, die eine Drehung um den doppelten Winkel zwischen u und dem halben Vektor darstellt. das bringt uns den ganzen Weg nach v !

Es gibt einen Sonderfall, in dem u == -v und ein eindeutiger Halbwertsvektor nicht mehr berechnet werden können. Dies wird angesichts der unendlich vielen "kürzesten Bogen" -Drehungen erwartet, die uns von u nach v führen können , und wir müssen uns einfach um 180 Grad um jeden Vektor drehen, der orthogonal zu u (oder v ) ist, als unsere Sonderfalllösung. Dies geschieht, indem das normalisierte Kreuzprodukt von u mit einem anderen Vektor genommen wird, der nicht parallel zu u ist .

Es folgt ein Pseudocode (in der Realität müsste der Sonderfall natürlich Gleitkomma-Ungenauigkeiten berücksichtigen - wahrscheinlich durch Überprüfen der Punktprodukte anhand eines bestimmten Schwellenwerts anstelle eines absoluten Werts).

Beachten Sie auch, dass es keinen Sonderfall gibt, wenn u == v (die Identitätsquaternion wird erstellt - überprüfen Sie und überzeugen Sie sich selbst).

// N.B. the arguments are _not_ axis and angle, but rather the
// raw scalar-vector components.
Quaternion(float w, Vector3 xyz);

Quaternion get_rotation_between(Vector3 u, Vector3 v)
{
  // It is important that the inputs are of equal length when
  // calculating the half-way vector.
  u = normalized(u);
  v = normalized(v);

  // Unfortunately, we have to check for when u == -v, as u + v
  // in this case will be (0, 0, 0), which cannot be normalized.
  if (u == -v)
  {
    // 180 degree rotation around any orthogonal vector
    return Quaternion(0, normalized(orthogonal(u)));
  }

  Vector3 half = normalized(u + v);
  return Quaternion(dot(u, half), cross(u, half));
}

Die orthogonalFunktion gibt jeden Vektor zurück, der orthogonal zum angegebenen Vektor ist. Diese Implementierung verwendet das Kreuzprodukt mit dem orthogonalsten Basisvektor.

Vector3 orthogonal(Vector3 v)
{
    float x = abs(v.x);
    float y = abs(v.y);
    float z = abs(v.z);

    Vector3 other = x < y ? (x < z ? X_AXIS : Z_AXIS) : (y < z ? Y_AXIS : Z_AXIS);
    return cross(v, other);
}

Quaternion-Lösung auf halbem Weg

Dies ist tatsächlich die Lösung, die in der akzeptierten Antwort dargestellt ist, und sie scheint geringfügig schneller zu sein als die Vektorlösung auf halbem Weg (~ 20% schneller durch meine Messungen, obwohl ich nicht mein Wort dafür nehme). Ich füge es hier hinzu, falls andere wie ich an einer Erklärung interessiert sind.

Anstatt ein Quaternion mit einem Halbwertsvektor zu berechnen, können Sie im Wesentlichen das Quaternion berechnen, das zu der doppelten erforderlichen Rotation führt (wie in der anderen Lösung beschrieben), und das Quaternion auf halbem Weg zwischen diesem und null Grad ermitteln.

Wie ich zuvor erklärt habe, lautet die Quaternion für die doppelte erforderliche Rotation:

q.w   == dot(u, v)
q.xyz == cross(u, v)

Und die Quaternion für die Nullrotation lautet:

q.w   == 1
q.xyz == (0, 0, 0)

Die Berechnung der Quaternion auf halbem Weg ist einfach eine Frage der Summierung der Quaternionen und der Normalisierung des Ergebnisses, genau wie bei Vektoren. Wie auch bei Vektoren müssen die Quaternionen jedoch dieselbe Größe haben, da sonst das Ergebnis in Richtung der Quaternion mit der größeren Größe verschoben wird.

Ein Quaternion, das aus dem Punkt- und Kreuzprodukt zweier Vektoren aufgebaut ist, hat die gleiche Größe wie diese Produkte : length(u) * length(v). Anstatt alle vier Komponenten durch diesen Faktor zu teilen, können wir stattdessen die Identitätsquaternion vergrößern. Und wenn Sie sich gefragt haben, warum die akzeptierte Antwort die Sache scheinbar kompliziert macht sqrt(length(u) ^ 2 * length(v) ^ 2), liegt dies daran, dass die quadratische Länge eines Vektors schneller zu berechnen ist als die Länge, sodass wir eine sqrtBerechnung speichern können . Das Ergebnis ist:

q.w   = dot(u, v) + sqrt(length_2(u) * length_2(v))
q.xyz = cross(u, v)

Und dann normalisieren Sie das Ergebnis. Pseudocode folgt:

Quaternion get_rotation_between(Vector3 u, Vector3 v)
{
  float k_cos_theta = dot(u, v);
  float k = sqrt(length_2(u) * length_2(v));

  if (k_cos_theta / k == -1)
  {
    // 180 degree rotation around any orthogonal vector
    return Quaternion(0, normalized(orthogonal(u)));
  }

  return normalized(Quaternion(k_cos_theta + k, cross(u, v)));
}

Das angegebene Problem ist nicht genau definiert: Es gibt keine eindeutige Drehung für ein bestimmtes Vektorpaar. Betrachten Sie zum Beispiel den Fall, in dem u = <1, 0, 0> und v = <0, 1, 0> . Eine Umdrehung von u nach v wäre eine pi / 2- Umdrehung um die z-Achse. Eine andere Drehung von u nach v wäre eine pi- Drehung um den Vektor <1, 1, 0> .

Warum nicht den Vektor mit reinen Quaternionen darstellen? Es ist besser, wenn Sie sie vielleicht zuerst normalisieren.
q ₁ = (0 u _x u _y u _z ) '
q ₂ = (0 v _x v _y v _z )'
q ₁ q _rot = q ₂
Vormultiplizieren mit q ₁ ^-1
q _rot = q ₁ ^-1 q ₂
wobei q ₁ ^-1 = q ₁ ^konj / q _Norm
Dies kann als "linke Teilung" angesehen werden. Die rechte Teilung, die Sie nicht wollen, ist:
q _{rot, rechts} = q ₂ ^-1 q ₁

Ich bin nicht sehr gut in Quaternion. Ich hatte jedoch stundenlang Probleme damit und konnte die Polaris878-Lösung nicht zum Laufen bringen. Ich habe versucht, v1 und v2 vornormalisieren. Normalisierung q. Normalisierung von q.xyz. Trotzdem verstehe ich es nicht. Das Ergebnis hat mir immer noch nicht das richtige Ergebnis gebracht.

Am Ende fand ich jedoch eine Lösung, die es tat. Wenn es jemand anderem hilft, ist hier mein Arbeitscode (Python):

def diffVectors(v1, v2):
    """ Get rotation Quaternion between 2 vectors """
    v1.normalize(), v2.normalize()
    v = v1+v2
    v.normalize()
    angle = v.dot(v2)
    axis = v.cross(v2)
    return Quaternion( angle, *axis )

Ein Sonderfall muss gemacht werden, wenn v1 und v2 wie v1 == v2 oder v1 == -v2 (mit einer gewissen Toleranz) parallel sind, wobei ich glaube, dass die Lösungen Quaternion (1, 0,0,0) sein sollten (keine Rotation) oder Quaternion (0, * v1) (180-Grad-Drehung)

Einige der Antworten scheinen die Möglichkeit nicht in Betracht zu ziehen, dass das Kreuzprodukt 0 sein könnte. Unter dem Snippet wird die Winkelachsendarstellung verwendet:

//v1, v2 are assumed to be normalized
Vector3 axis = v1.cross(v2);
if (axis == Vector3::Zero())
    axis = up();
else
    axis = axis.normalized();

return toQuaternion(axis, ang);

Das toQuaternionkann wie folgt implementiert werden:

static Quaternion toQuaternion(const Vector3& axis, float angle)
{
    auto s = std::sin(angle / 2);
    auto u = axis.normalized();
    return Quaternion(std::cos(angle / 2), u.x() * s, u.y() * s, u.z() * s);
}

Wenn Sie die Eigenbibliothek verwenden, können Sie auch einfach Folgendes tun:

Quaternion::FromTwoVectors(from, to)

Aus Sicht des Algorithmus sieht die schnellste Lösung im Pseudocode aus

 Quaternion shortest_arc(const vector3& v1, const vector3& v2 ) 
 {
     // input vectors NOT unit
     Quaternion q( cross(v1, v2), dot(v1, v2) );
     // reducing to half angle
     q.w += q.magnitude(); // 4 multiplication instead of 6 and more numerical stable

     // handling close to 180 degree case
     //... code skipped 

        return q.normalized(); // normalize if you need UNIT quaternion
 }

Stellen Sie sicher, dass Sie Einheitenquaternionen benötigen (normalerweise ist dies für die Interpolation erforderlich).

HINWEIS: Nicht-Einheiten-Quaternionen können bei einigen Vorgängen schneller als Einheiten verwendet werden.