Rotation circulaire autour d'un axe arbitraire

Je suis de programmation de Starcraft 2 cartes personnalisées et quelques proglems avec les mathématiques en 3D. Actuellement, je suis en train de créer et tourner un point autour d'un axe arbitraire, donnée par x,y et z (xyz vecteur est normalisée).

J'ai essayé autour d'un lot, et de lire beaucoup de choses sur internet, mais je ne peux pas comment il fonctionne correctement. Mon script actuel (vous avez probablement ne savez pas la langue, mais c'est rien de spécial) est le résultat de tout casser pendant des heures (ne fonctionne pas correctement):

    point CP;
fixed AXY;
point D;
point DnoZ;
point DXY_Z;
fixed AZ;
fixed LXY;
missile[Missile].Angle = (missile[Missile].Angle + missile[Missile].Acceleration) % 360.0;
missile[Missile].Acceleration += missile[Missile].AirResistance;
if (missile[Missile].Parent > -1) {
    D = missile[missile[Missile].Parent].Direction;
    DnoZ = Point(PointGetX(D),0.0);
    DXY_Z = Normalize(Point(SquareRoot(PointDot(DnoZ,DnoZ)),PointGetHeight(D)));
    AZ = MaxF(ACos(PointGetX(DXY_Z)),ASin(PointGetY(DXY_Z)))+missile[Missile].Angle;
    DnoZ = Normalize(DnoZ);
    AXY = MaxF(ACos(PointGetX(DnoZ)),ASin(PointGetY(DnoZ)));
    CP = Point(Cos(AXY+90),Sin(AXY+90));
    LXY = SquareRoot(PointDot(CP,CP));
    if (LXY > 0) {
        CP = PointMult(CP,Cos(AZ)/LXY);
        PointSetHeight(CP,Sin(AZ));
    } else {
        CP = Point3(0.0,0.0,1.0);
    }
} else {
    CP = Point(Cos(missile[Missile].Angle),Sin(missile[Missile].Angle));
}
missile[Missile].Direction = Normalize(CP);
missile[Missile].Position = PointAdd(missile[Missile].Position,PointMult(missile[Missile].Direction,missile[Missile].Distance));

J'ai juste ne peux pas obtenir mon esprit autour des mathématiques. Si vous pouvez l'expliquer en termes simples ce serait la meilleure solution, un code ciselée serait bien aussi (mais pas tout à fait comme utile, parce que j'ai l'intention de faire plus de 3D dans le futur).

OriginalL'auteur Alexander | 2011-07-17

22

http://en.wikipedia.org/wiki/Rotation_matrix. Regardez dans la section Matrice de Rotation de l'axe et l'angle. Pour votre commodité, voici la matrice dont vous avez besoin. C'est un peu poilu. theta est l'angle, et ux, uy et uz sont x, y et z les composantes de la normalisé vecteur de l'axe

Si vous ne comprenez pas les matrices et les vecteurs, les post de retour et je vais vous aider.

J'ai trouvé que la matrice de trop, mon problème est que je ne comprends pas comment l'utiliser. Ce que je ne comprends pas est comment faire pour créer le point que je veux faire tourner. Merci pour votre aide.
Après réflexion beaucoup plus à ce sujet, la rotation n'est pas le problème, je pense que je comprends la rotation. Ce que je viens ne peut pas faire est de trouver un vecteur perpendiculaire à mon axe, au moins aucun qui tourne avec l'axe (l'axe des changements tous les 0.0625 secondes et je veux une rotation autour d'elle avec une distance constante).
Il fonctionne maintenant, j'utilise un vecteur que j'ai à calculer sur chaque rotation etc. Serait mieux si il y avait un moyen de la calculer en cas de besoin.
Je me rends compte il peut y avoir de nombreuses raisons pour lesquelles vous êtes à l'aide d'un vecteur, mais la matrice que j'ai posté a toutes les informations nécessaires pour accomplir la rotation. Avez-vous les coordonnées du point que vous êtes en rotation? Avez-vous de l'axe (x, y, z) de la forme? Avez-vous des thêta et peut calculer sin(theta) et cos(theta)? Si oui, cette formule devrait être suffisant pour obtenir ce que vous voulez.
Non, je n'ai pas les coordonnées. Je voulais être calculé et mis en rotation par l'angle. Et je n'ai aucune idée de comment faire pour calculer un point qui est toujours dans la même direction à partir de mon axe (si je passe mon axe et d'affichage le point, il devrait ressembler il est connecté).

OriginalL'auteur Gravity
11

Une méthode utile pour faire des rotations est de le faire avec les quaternions. Dans la pratique, j'ai trouvé plus facile à utiliser et ont l'avantage supplémentaire d'éviter Gimbal lock.

Ici est une belle promenade à travers qui explique comment et pourquoi ils sont utilisés pour la rotation autour d'un axe arbitraire (c'est la réponse à l'utilisateur en question). C'est un peu plus haut niveau et serait bon pour quelqu'un qui est nouveau à l'idée, donc je vous recommande de commencer.

Mise à jour pour éviter lien à la corrosion

Le texte à partir du site lié:

Comme vous l'avez sans doute déjà conclu, la rotation autour de l'axe
qui passe par l'origine et un point de (a,b,c) sur la sphère unité dans
trois dimensions est une transformation linéaire, et peut donc être
représenté par la multiplication de matrices. Nous allons donner un très habile
méthode pour la détermination de cette matrice, mais d'apprécier la compacité
de la formule, il sera sage de commencer par quelques remarques.

Rotations en trois dimensions sont plutôt linéaires spéciales
transformations, pas moins, car ils conservent les longueurs de
vecteurs et aussi (lorsque les deux vecteurs sont en rotation) les angles entre les
vecteurs. De telles transformations sont appelées "orthogonale", et ils sont
représentés par des matrices orthogonales:
```
M M' = I
```
où nous sommes idéalement désigner la transposition par '. En d'autres mots, le
la transposition d'une matrice orthogonale est son inverse.

D'examiner les données qui sont nécessaires pour définir la transformation.
Vous avez déjà donné la notation de l'axe de rotation, ai + bj + ck,
idéalement supposé être un vecteur unitaire. La seule autre donnée est la
angle de rotation, ce qui manque de plus le caractère naturel je vais
désigne par r (pour la rotation?) et qui nous supposerons être donnée en
radians.

Maintenant les rotations sont en fait un peu particulière, même parmi orthogonale
transformations, et en fait ils sont aussi appelés spécial orthogonal
transformations (ou matrices) en raison de leur propriété de
"l'orientation de la préserver". Les comparer avec les reflets, qui sont
également de la longueur et de l'angle de la préservation, et vous verrez que les géométrique
caractéristique de la préservation de l'orientation (ou "gaucher" si vous
préférez) a une valeur numérique de contrepartie dans le déterminant de la matrice.
Une rotation de la matrice de déterminant 1, tandis qu'un reflet de la matrice a
déterminant -1. Il s'avère que le produit (ou composition), de deux
des rotations est de nouveau une rotation, qui est d'accord avec le fait que l'
déterminant d'un produit est le produit des déterminants (ou 1 dans
le cas d'une rotation).

Maintenant, nous pouvons décrire une approche étape par étape que l'on pourrait suivre pour
construire le désiré de la matrice (avant nous de raccourci, l'ensemble du processus et
saut à la Réponse!). Considérons d'abord une étape dans laquelle nous tourner le
vecteur unitaire:
```
u = ai + bj + ck
```
de sorte qu'il coïncide avec celui de la "norme" vecteurs unitaires, peut-être
k (les impacts de l'axe z). Maintenant, nous savons comment le faire pivoter autour de l'axe z;
c'est une question de faire l'habitude 2x2 transformation de x,y
coordonnées seul:
```
       cos(r) sin(r)   0
M  =  -sin(r) cos(r)   0
         0      0      1
```
Enfin, il nous faut "annuler" que la rotation initiale qui a eu u de k,
ce qui est facile, car à l'inverse de cette transformation est (nous
en rappel, représentée par la matrice de transposition. En d'autres termes, si
la matrice R représente une rotation de la prise de u de k, alors R' a k de u,
et nous pouvons écrire la composition de transformations comme ceci:
```
R' M R
```
C'est facile à vérifier que ce produit de matrices, lorsqu'il est multiplié
fois u, donne u une fois de plus:
```
R' M R u = R' M k = R' k = u
```
Donc c'est en effet une rotation autour de l'axe défini par u.

Un des avantages de cette expression est qu'il sépare la
la dépendance de M sur l'angle r de la dépendance de Q et Q' sur le
"l'axe" vecteur u. Toutefois, si nous devons effectuer les calculs dans
le détail, on aura évidemment beaucoup de multiplication de matrice à faire.

Donc, pour le raccourci. Il s'avère que lorsque toute la poussière qui retombe la
la multiplication parmi les rotations est isomorphe à la multiplication de l'unité
les quaternions. Les Quaternions, dans le cas où vous ne les avez pas vus avant, sont un
type de quatre dimensions de la généralisation des nombres complexes. Ils ont été
"inventé" par William Hamilton en 1843:

[Sir William Rowan Hamilton]
http://www-gap.dcs.st-and.ac.uk/~history/Mathematicians/Hamilton.html

et aujourd'hui les graphiques 3D, les programmeurs se sont considérablement sa dette.

Chaque unité de quaternions q = q0 + q1*i + q2*j + q3*k définit ensuite une matrice de rotation:
```
     (q0² + q1² - q2² - q3²)      2(q1q2 - q0q3)          2(q1q3 + q0q2)

Q  =      2(q2q1 + q0q3)     (q0² - q1² + q2² - q3²)      2(q2q3 - q0q1)

          2(q3q1 - q0q2)          2(q3q2 + q0q1)     (q0² - q1² - q2² + q3²)
```
Pour vérifier que Q est une matrice orthogonale, c'est à dire. que Q Q' = I, signifie, dans la
l'essentiel, que les lignes de Q forment une base orthogonale. Donc, pour
exemple, la première ligne doit avoir une longueur de 1:
```
(q0² + q1² - q2² - q3²)² + 4(q1q2 - q0q3)² + 4(q1q3 + q0q2)²

  = (q0² + q1² - q2² - q3²)² + 4(q1q2)² + 4(q0q3)² + 4(q1q3)² + 4(q0q2)²

  = (q0² + q1² + q2² + q3²)²

  =  1
```
et les deux premières lignes ont point produit zéro:
```
  [ (q0² + q1² - q2² - q3²), 2(q1q2 - q0q3), 2(q1q3 + q0q2) ]

   * [ 2(q2q1 + q0q3), (q0² - q1² + q2² - q3²), 2(q2q3 - q0q1) ]

 = 2(q0² + q1² - q2² - q3²)(q2q1 + q0q3)

   + 2(q1q2 - q0q3)(q0² - q1² + q2² - q3²)

   + 4(q1q3 + q0q2)(q2q3 - q0q1)

 = 4(q0²q1q2 + q1²q0q3 - q2²q0q3 - q3²q2q1)

   + 4(q3²q1q2 - q1²q0q3 + q2²q0q3 - q0²q2q1)

 =  0
```
Il peut également être démontré que, en général,det(Q) = 1, et donc que Q est
vraiment une rotation.

Mais autour de ce que l'axe Q est la rotation? Et par quel angle? Eh bien,
compte tenu de l'angle de r et le vecteur unitaire:
```
u = ai + bj + ck
```
comme avant, le quaternion correspondant est:
```
q = cos(r/2) + sin(r/2) * u

  = cos(r/2) + sin(r/2) ai + sin(r/2) bj + sin(r/2) ck
```
Donc avec:
```
q0 = cos(r/2), q1 = sin(r/2) a, q2 = sin(r/2) b, q3 = sin(r/2) c,
```
nous sommes en mesure d'obtenir la propriété désirée que la multiplication par Q "fixe" u:
```
Q u = u
```
Plutôt que de souffler à travers la longue-haleine de l'algèbre, nous allons faire un exemple simple.

Laisser u = 0i + 0.6j + 0.8k être notre vecteur unitaire et r = pi être notre angle de rotation.

Puis le quaternion est:
```
q = cos(pi/2) + sin(pi/2) * u

  = 0 + 0i + 0.6j + 0.8k
```
et la matrice de rotation:
```
        -1     0     0

Q =      0  -0.28  0.96

         0   0.96  0.28
```
Dans ce cas concret, il est facile de vérifier que Q, Q' = I et det(Q) = 1.

Aussi, nous calculons que:
```
Q u = [ 0, -0.28*0.6 + 0.96*0.8, 0.96*0.6 + 0.28*0.8 ]'

    = [ 0, 0.6, 0.8 ]'

    =  u
```
ie. le vecteur unitaire u définit l'axe de rotation, car il est "fixé" par Q.

Enfin, nous illustrons le fait que l'angle de rotation est pi (ou 180
degrés) en tenant compte de la Q actes sur le vecteur unitaire dans la direction
de l'axe x positif, qui est perpendiculaire à u:
```
i + 0j + 0k,  or as a vector, [ 1, 0, 0 ]'
```
Puis Q [ 1, 0, 0 ]' = [-1, 0, 0 ]' qui est la rotation de [ 1, 0, 0
]' par le biais d'angle pi sur u.

Comme référence pour cette représentation de rotations par les quaternions et
certaines autres méthodes de représentation (et ce qu'ils sont bons
de), voir les détails ici:

[Représentant des rotations 3D]
http://gandalf-library.sourceforge.net/tutorial/report/node125.html

RÉSUMÉ

Angle donné r en radians et vecteur unitaire u = ai + bj + ck ou [a,b,c]', définir:
```
q0 = cos(r/2),  q1 = sin(r/2) a,  q2 = sin(r/2) b,  q3 = sin(r/2) c
```
et de construire à partir de ces valeurs de la matrice de rotation:
```
     (q0² + q1² - q2² - q3²)      2(q1q2 - q0q3)          2(q1q3 + q0q2)

Q  =      2(q2q1 + q0q3)     (q0² - q1² + q2² - q3²)      2(q2q3 - q0q1)

          2(q3q1 - q0q2)          2(q3q2 + q0q1)     (q0² - q1² - q2² + q3²)
```
La Multiplication par Q puis les effets de la rotation désirée, et en particulier:
```
Q u = u
```
OriginalL'auteur user1205577
5

Pour effectuer une rotation 3D, vous avez simplement besoin de compenser le point de rotation de l'origine et de façon séquentielle tourner autour de chaque axe, le stockage des résultats entre chaque axe de rotation pour une utilisation avec la prochaine rotation de l'opération. L'algorithme ressemble comme suit:

Décalage du point à l'origine.
```
Point of Rotation = (X1, Y1, Z1)
Point Location    = (X1+A, Y1+B, Z1+C)

(Point Location - Point of Rotation) = (A, B, C).
```
Effectuer une rotation autour de l'Axe Z.
```
    A' = A*cos ZAngle - B*sin ZAngle
    B' = A*sin ZAngle + B*cos ZAngle
    C' = C.
```
Prochain, effectuer une rotation autour de l'Axe Y.
```
    C'' = C'*cos YAngle - A'*sin YAngle
    A'' = C'*sin YAngle + A'*cos YAngle
    B'' = B'   
```
Maintenant effectuer la dernière rotation, sur l'Axe des X.
```
    B''' = B''*cos XAngle - C''*sin XAngle
    C''' = B''*sin XAngle + C''*cos XAngle
    A''' = A''
```
Enfin, ajouter ces valeurs vers le point d'origine de la rotation.
```
Rotated Point = (X1+A''', Y1+B''', Z1+C''');
```
J'ai trouvé ce lien pour être très utile. Il définit la façon dont les rotations sur les axes X, Y et Z axes.

Mathématiquement, vous pouvez définir l'ensemble des opérations comme:

OriginalL'auteur Mapsy
2

Voici ce que vous pouvez utiliser pour tourner autour d'un axe quelconque, que ce soit x,y ou z. Rx, Ry et Rz désigner une rotation autour de l'as x,y,z respectivement.

Cette image est à partir de ici, droit? Vous devriez probablement citer que.

OriginalL'auteur Aakash Anuj
0

Pour des rotations autour d'un axe arbitraire en trois dimensions avec des matrices, j'ai une page ici. Liés l'explication et de la dérivation de la matrice (ici) comprend les éléments suivants rotation/translation de la matrice. C'est la matrice qui donne le résultat de la rotation du point (x,y,z) sur la droite passant par (a,b,c) avec le vecteur de direction ⟨u,v,w⟩ par l'angle thêta.

Le résultat est de ce point dans trois dimensions:

La page contient un lien vers un téléchargement du code source. Si vous voulez interactive à faire des rotations, vous pouvez le faire à ce site. Essayez l'exemple de la rotation lien pour avoir une idée de ce qui se passe.

OriginalL'auteur Glenn
0

Une très belle façon à ce programme, surtout si vous êtes en mesure de fonctionner avec des matrices (comme dans Matlab) est le Rodrigues Formule De Rotation.

La formule crée une matrice de rotation autour d'un axe défini par le vecteur unitaire par un angle à l'aide d'une très simple équation:

Où est la matrice identité et est une matrice donnée par les composantes du vecteur unitaire :

Noter qu'il est très important que le vecteur est un vecteur unitaire, c'est à dire la norme de doit être de 1.

Vous pouvez vérifier pour le euclidienne de l'axe, la formule est exacte que ceux trouvés sur Wikipédia et publié ici par Aakash Anuj.

Je n'utilise cette formule pour les rotations depuis que j'ai découvert il. Espérons que cela aide à personne.

OriginalL'auteur Daniel Pereira

-2

Python de mise en œuvre, a travaillé pour moi.

cos180=-1
sin180=0

rotmatrix=np.zeros((3,3))
rotmatrix[0][0]=cos180 + rotaxis[0]**2 * (1-cos180)
rotmatrix[0][1]=rotaxis[0]*rotaxis[1] * (1-cos180) - rotaxis[2] * sin180
rotmatrix[0][2]=rotaxis[0]*rotaxis[2] * (1-cos180) + rotaxis[1] * sin180

rotmatrix[1][0]=rotaxis[1]*rotaxis[0] * (1-cos180) + rotaxis[2] * sin180
rotmatrix[1][1]=cos180 + rotaxis[1]**2 * (1-cos180)
rotmatrix[1][2]=rotaxis[1]*rotaxis[2] * (1-cos180) - rotaxis[0] * sin180

rotmatrix[2][0]=rotaxis[2]*rotaxis[0] * (1-cos180) - rotaxis[1] * sin180
rotmatrix[2][1]=rotaxis[2]*rotaxis[1] * (1-cos180) + rotaxis[0] * sin180
rotmatrix[2][2]=cos180 + rotaxis[2] ** 2 * (1-cos180)

OriginalL'auteur Alejandro Varela

Vous devez vous connecter pour publier un commentaire.

RÉSUMÉ