Compte tenu d'une surface normale, trouver rotation 3D avion

Question

J'ai un plan 3D décrit par 2 vecteurs:

P: un point qui se trouve sur le plan
N: la surface normale pour le plan

Et j'ai un très grand polygone carré plat, que je veux rendre pour représenter ce plan. Je peux facilement traduire le polygone au point donné, mais ensuite j'ai besoin de trouver la rotation correcte à appliquer pour que la surface normale soit réellement la surface normale.

I a essayé un procédé mentionné ailleurs où était:

1) Prendre tout aucun vecteur parallèle (V) à la normale (N), et prendre le produit croisé (W1)
2) Prendre le produit vectoriel de (W1) et (N) présent (W2) et qui est un vecteur (V «) qui se trouve sur le plan

I puis générer une matrice de rotation par rapport à (V ») est couché sur la Plan, de sorte que mon polygone soit aligné avec (V '). cela a fonctionné, mais il est clair que cette méthode ne fonctionne pas correctement dans son ensemble. Le polygone n'est pas parfaitement perpendiculaire à la surface normale.

Des idées sur la façon de générer la rotation appropriée?

Answer 1

Certaines choses utiles sur les rotations:

• Les trois vecteurs orthonormés disposés en rangées définissent une transformation en une nouvelle base (une rotation dans cette base).
• La transposition de toute rotation est son inverse.
• Ainsi, trois vecteurs orthonormés disposés en colonnes définissent une rotation d'une certaine base dans votre cadre de référence "monde".

Ainsi, le problème est de trouver un ensemble de trois vecteurs orthonormés et les organiser comme

| x1 x2 x3 0 | 
| y1 y2 y3 0 | 
| z1 z2 z3 0 | 
| 0 0 0 1 | 

c'est exactement ce que la méthode décrite essaie de faire, si cela ne fonctionne pas, alors il est un problème avec votre implémentation.

Nous pouvons évidemment utiliser votre normal comme (x1, y1, z1), mais le problème est que le système a une infinité de solutions pour les deux vecteurs restants (bien que connaître l'un d'eux vous donne l'autre, comme produit croisé) . Le code suivant devrait donner un vecteur stable perpendiculaire à (x1, y1, z1):

float normal[3] = { ... }; 

int imin = 0; 
for(int i=0; i<3; ++i) 
    if(std::abs(normal[i]) < std::abs(normal[imin])) 
     imin = i; 

float v2[3] = {0,0,0}; 
float dt = normal[imin]; 

v2[imin] = 1; 
for(int i=0;i<3;i++) 
    v2[i] -= dt*normal[i]; 

Il utilise essentiellement Gram-Schmidt orthogonalisation avec la dimension qui est déjà le plus orthogonal au vecteur normal.v3 peut alors être obtenu en prenant le produit croisé normal et v2.

Vous devrez peut-être prendre soin de configurer la rotation, il s'agit de l'origine, donc vous devez appliquer la translation après la rotation et c'est pour les vecteurs colonnes plutôt que pour les vecteurs lignes. Si vous utilisez OpenGL, assurez-vous qu'OpenGL accepte les tableaux dans l'ordre des colonnes (plutôt que dans l'ordre majeur de la rangée C), donc vous devrez peut-être transposer. Je crains de ne pas avoir testé ce qui précède, je l'ai simplement récupéré à partir d'un code que j'ai écrit il y a un certain temps et je l'ai adapté à votre problème! J'espère n'avoir oublié aucun détail.

Edit: J'ai oublié quelque chose :)

La matrice ci-dessus suppose votre normale au polygone est le long de l'axe x, et je soupçonne de Furtif il ne sera pas, tout ce que vous devez faire est Mettez le vecteur "normal" dans la colonne correcte de la matrice de rotation, et v2/v3 dans les deux autres colonnes. Donc, si la normale à votre polygone est le long de l'axe z, alors la normale va dans la troisième colonne et v2/v3 vont dans les deux premières colonnes. Nous sommes désolés si cela peut causer de la confusion.

Answer 2

Je ne sais pas quelle méthode que vous utilisez pour rendre, mais empruntant OpenSceneGraph's matrix:

void Matrix_implementation::makeLookAt(const Vec3d& eye,const Vec3d& center,const Vec3d& up) 
{ 
    Vec3d f(center-eye); 
    f.normalize(); 
    Vec3d s(f^up); 
    s.normalize(); 
    Vec3d u(s^f); 
    u.normalize(); 

    set(
     s[0],  u[0],  -f[0],  0.0, 
     s[1],  u[1],  -f[1],  0.0, 
     s[2],  u[2],  -f[2],  0.0, 
     0.0,  0.0,  0.0,  1.0); 

    preMultTranslate(-eye); 
} 

inline void Matrixd::preMultTranslate(const Vec3d& v) 
{ 
    for (unsigned i = 0; i < 3; ++i) 
    { 
     double tmp = v[i]; 
     if (tmp == 0) 
      continue; 
     _mat[3][0] += tmp*_mat[i][0]; 
     _mat[3][1] += tmp*_mat[i][1]; 
     _mat[3][2] += tmp*_mat[i][2]; 
     _mat[3][3] += tmp*_mat[i][3]; 
    } 
} 

Espérons que cela vous donnera une idée pour votre mise en œuvre. Je ne suis pas très bon avec les quaternions qui pourraient avoir une solution plus simple, mais cette méthode fonctionne bien pour moi.