DGL • Thema anzeigen - Matheproblem: Punkte um Normale drehen

Matheproblem: Punkte um Normale drehen

Moderator: DGL-Team

Seite 1 von 1

[ 5 Beiträge ]

Vorheriges Thema | Nächstes Thema

Autor

Nachricht

Noop

Betreff des Beitrags: Matheproblem: Punkte um Normale drehen

Verfasst: Do Mär 23, 2006 19:25

DGL Member

Registriert: Mi Mär 22, 2006 20:16
Beiträge: 22
Wohnort: Wuppertal

Wie kann ich im 3D-Raum Punkte drehen und zwar um ein Normalvektor?

Wenn ich sage Turn(..., [0,1,0]) drehen sich die Punkte um die Y-Ache, sage ich Turn(..., [1,0,0]) dreht sich das ganze um die X-Achse, natürlich sollte auch Turn(..., [0.707 {=1/Sqrt/(2)}, 0.707, 0]) gehen.

Ich habe folgende Formel zusammengebaut

Code:

function _Turn(p, n: TPoint3DF; d: float): TPoint3DF;
begin
  result.x := Cos(d)*p.x*n.z - Sin(d)*p.y*n.z
            + Cos(d)*p.x*n.y - Sin(d)*p.z*n.y;
  result.y := Cos(d)*p.y*n.z + Sin(d)*p.x*n.z
            + Cos(d)*p.y*n.x - Sin(d)*p.z*n.x;
  result.z := Cos(d)*p.z*n.y + Sin(d)*p.x*n.y
            + Cos(d)*p.z*n.x + Sin(d)*p.y*n.x;
end;
 

Aber die funktioniert eher schlecht als recht.

Es muss doch möglich sein, ohne weitere Vektoren/Matrizien ein Punkt 2D-Mäßig zu drehen nur das halt eine Normale angegeben wird statt direkt X,Y oder Z.

Wie denn?[/pascal]

Nach oben

Betreff des Beitrags:

Verfasst: Do Mär 23, 2006 22:12

DGL Member

Registriert: Sa Jan 22, 2005 21:10
Beiträge: 225

Hab mir deinen Code jetzt nicht genauer angeguckt, aber mit Quaternionen kann man um beliebige Achsen drehen. Googel einfach mal danach, da gibts unmengen von Informationen zu.

_________________
[18:30] tomok: so wie ich das sehe : alles. was nich was anderes ist als nen Essay ist nen Essay

hi, i'm a signature viruz, plz set me as your signature and help me spread

Nach oben

Noop

Betreff des Beitrags:

Verfasst: Do Mär 23, 2006 23:30

DGL Member

Registriert: Mi Mär 22, 2006 20:16
Beiträge: 22
Wohnort: Wuppertal

Quaternionen benutzen, nur um einen 3D-Vektor (x,y,z) Flächenmäßig zu drehen, wobei der Normalvektor angibt, wo oben ist?

Hab mir das vor einiger Zeit schon mal angeguckt, aber nicht so wirkich verstanden.

Mir wär es lieber, wenn ich eine kompakte Formel hätte, anstatt jetzt großartig was aufzuziehen.
Wenn nicht anders gehen sollte, Ok ...

Eine verständliche Einführung in die Welt der Quaternionen wäre auch nicht schlecht

Nach oben

Lyr

Betreff des Beitrags:

Verfasst: Fr Mär 24, 2006 00:03

DGL Member

Registriert: So Sep 26, 2004 05:57
Beiträge: 190
Wohnort: Linz

Wenn dir ein bisschen C nichts ausmacht, dann käme der MESA-Code für glRotatef in Frage. Obwohl dieser eine Matrix berechnet, lässt er sich auch leicht auf nur einen Punkt umwandeln.

Code:

/**********************************************************************/
/** \name Matrix generation */
/*@{*/
 
/**
 * Generate a 4x4 transformation matrix from glRotate parameters, and
 * post-multiply the input matrix by it.
 *
 * \author
 * This function was contributed by Erich Boleyn (erich@uruk.org).
 * Optimizations contributed by Rudolf Opalla (rudi@khm.de).
 */
void
_math_matrix_rotate( GLmatrix *mat,
             GLfloat angle, GLfloat x, GLfloat y, GLfloat z )
{
   GLfloat xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c, s, c;
   GLfloat m[16];
   GLboolean optimized;
 
   s = (GLfloat) sin( angle * DEG2RAD );
   c = (GLfloat) cos( angle * DEG2RAD );
 
   MEMCPY(m, Identity, sizeof(GLfloat)*16);
   optimized = GL_FALSE;
 
#define M(row,col)  m[col*4+row]
 
   if (x == 0.0F) {
      if (y == 0.0F) {
         if (z != 0.0F) {
            optimized = GL_TRUE;
            /* rotate only around z-axis */
            M(0,0) = c;
            M(1,1) = c;
            if (z < 0.0F) {
               M(0,1) = s;
               M(1,0) = -s;
            }
            else {
               M(0,1) = -s;
               M(1,0) = s;
            }
         }
      }
      else if (z == 0.0F) {
         optimized = GL_TRUE;
         /* rotate only around y-axis */
         M(0,0) = c;
         M(2,2) = c;
         if (y < 0.0F) {
            M(0,2) = -s;
            M(2,0) = s;
         }
         else {
            M(0,2) = s;
            M(2,0) = -s;
         }
      }
   }
   else if (y == 0.0F) {
      if (z == 0.0F) {
         optimized = GL_TRUE;
         /* rotate only around x-axis */
         M(1,1) = c;
         M(2,2) = c;
         if (x < 0.0F) {
            M(1,2) = s;
            M(2,1) = -s;
         }
         else {
            M(1,2) = -s;
            M(2,1) = s;
         }
      }
   }
 
   if (!optimized) {
      const GLfloat mag = SQRTF(x * x + y * y + z * z);
 
      if (mag <= 1.0e-4) {
         /* no rotation, leave mat as-is */
         return;
      }
 
      x /= mag;
      y /= mag;
      z /= mag;
 
 
      /*
       *     Arbitrary axis rotation matrix.
       *
       *  This is composed of 5 matrices, Rz, Ry, T, Ry', Rz', multiplied
       *  like so:  Rz * Ry * T * Ry' * Rz'.  T is the final rotation
       *  (which is about the X-axis), and the two composite transforms
       *  Ry' * Rz' and Rz * Ry are (respectively) the rotations necessary
       *  from the arbitrary axis to the X-axis then back.  They are
       *  all elementary rotations.
       *
       *  Rz' is a rotation about the Z-axis, to bring the axis vector
       *  into the x-z plane.  Then Ry' is applied, rotating about the
       *  Y-axis to bring the axis vector parallel with the X-axis.  The
       *  rotation about the X-axis is then performed.  Ry and Rz are
       *  simply the respective inverse transforms to bring the arbitrary
       *  axis back to it's original orientation.  The first transforms
       *  Rz' and Ry' are considered inverses, since the data from the
       *  arbitrary axis gives you info on how to get to it, not how
       *  to get away from it, and an inverse must be applied.
       *
       *  The basic calculation used is to recognize that the arbitrary
       *  axis vector (x, y, z), since it is of unit length, actually
       *  represents the sines and cosines of the angles to rotate the
       *  X-axis to the same orientation, with theta being the angle about
       *  Z and phi the angle about Y (in the order described above)
       *  as follows:
       *
       *  cos ( theta ) = x / sqrt ( 1 - z^2 )
       *  sin ( theta ) = y / sqrt ( 1 - z^2 )
       *
       *  cos ( phi ) = sqrt ( 1 - z^2 )
       *  sin ( phi ) = z
       *
       *  Note that cos ( phi ) can further be inserted to the above
       *  formulas:
       *
       *  cos ( theta ) = x / cos ( phi )
       *  sin ( theta ) = y / sin ( phi )
       *
       *  ...etc.  Because of those relations and the standard trigonometric
       *  relations, it is pssible to reduce the transforms down to what
       *  is used below.  It may be that any primary axis chosen will give the
       *  same results (modulo a sign convention) using thie method.
       *
       *  Particularly nice is to notice that all divisions that might
       *  have caused trouble when parallel to certain planes or
       *  axis go away with care paid to reducing the expressions.
       *  After checking, it does perform correctly under all cases, since
       *  in all the cases of division where the denominator would have
       *  been zero, the numerator would have been zero as well, giving
       *  the expected result.
       */
 
      xx = x * x;
      yy = y * y;
      zz = z * z;
      xy = x * y;
      yz = y * z;
      zx = z * x;
      xs = x * s;
      ys = y * s;
      zs = z * s;
      one_c = 1.0F - c;
 
      /* We already hold the identity-matrix so we can skip some statements */
      M(0,0) = (one_c * xx) + c;
      M(0,1) = (one_c * xy) - zs;
      M(0,2) = (one_c * zx) + ys;
/*    M(0,3) = 0.0F; */
 
      M(1,0) = (one_c * xy) + zs;
      M(1,1) = (one_c * yy) + c;
      M(1,2) = (one_c * yz) - xs;
/*    M(1,3) = 0.0F; */
 
      M(2,0) = (one_c * zx) - ys;
      M(2,1) = (one_c * yz) + xs;
      M(2,2) = (one_c * zz) + c;
/*    M(2,3) = 0.0F; */
 
/*
      M(3,0) = 0.0F;
      M(3,1) = 0.0F;
      M(3,2) = 0.0F;
      M(3,3) = 1.0F;
*/
   }
#undef M
 
   matrix_multf( mat, m, MAT_FLAG_ROTATION );
}

Nach oben

Noop

Betreff des Beitrags:

Verfasst: Fr Mär 24, 2006 01:17

DGL Member

Registriert: Mi Mär 22, 2006 20:16
Beiträge: 22
Wohnort: Wuppertal

Danke, das war, was ich gesucht habe!
Eine Funktion, wo ich nur Punkt und eine Normale brauche.

Für denen, denen es interessiert, hier der von mir in Delphi übersetzte Code:

Code:

type
  float = double;
  TPoint3DF = record x,y,z: float; end;
  TMatrix4x4 = record
    _11,_12,_13,_14: float;
    _21,_22,_23,_24: float;
    _31,_32,_33,_34: float;
    _41,_42,_43,_44: float;
  end;
 

Code:

function _RotN(n: TPoint3DF; d: float): TMatrix4x4;
var
  xx, yy, zz, xy, yz, zx, xs, ys, zs, one_c, s, c, mag: float;
  optimized: boolean;
  m: TMatrix4x4;
begin
(*
 * Generate a 4x4 transformation matrix from glRotate parameters, and
 * post-multiply the input matrix by it.
 *
 * \author
 * This function was contributed by Erich Boleyn (erich@uruk.org).
 * Optimizations contributed by Rudolf Opalla (rudi@khm.de).
 *
 * Translated into Delphi by Stefan (slude007 [at] web [d0t] de)
*)
  s := Sin(d);
  c := Cos(d);
  optimized := False;
  m._11 := 1.0; m._12 := 0.0; m._13 := 0.0; m._14 := 0.0;
  m._21 := 0.0; m._22 := 1.0; m._23 := 0.0; m._24 := 0.0;
  m._31 := 0.0; m._32 := 0.0; m._33 := 1.0; m._34 := 0.0;
  m._41 := 0.0; m._42 := 0.0; m._43 := 0.0; m._44 := 1.0;
  if n.x = 0 then
  begin
    if n.y = 0 then
    begin
      if n.z <> 0 then
      begin
        //Rotate only around Z axis
        optimized := True;
        m._11 := c;
        m._22 := c;
        if n.z < 0 then
        begin
          m._12 := s;
          m._21 := -s;
        end else
        begin
          m._12 := -s;
          m._21 := s;
        end;
      end
    end else
    if n.z = 0 then
    begin
      //Rotate only around Y axis
      optimized := True;
      m._11 := c;
      m._33 := c;
      if n.y < 0 then
      begin
        m._13 := -s;
        m._31 := s;
      end else
      begin
        m._13 := s;
        m._31 := -s;
      end;
    end;
  end else
  if n.y = 0 then
  begin
    if n.z = 0 then
    begin
      //Rotate only around X axis
      optimized := True;
      m._22 := c;
      m._33 := c;
      if (n.x < 0) then
      begin
        m._23 := s;
        m._32 := -s;
      end else
      begin
        m._23 := -s;
        m._32 := s;
      end;
    end;
  end;
  if not optimized then
  begin
    mag := Sqrt(n.x*n.x + n.y*n.y + n.z*n.z);
    if mag <= 0.0001 then exit;
    n.x := n.x / mag;
    n.y := n.y / mag;
    n.z := n.z / mag;
(*
       *     Arbitrary axis rotation matrix.
       *
       *  This is composed of 5 matrices, Rz, Ry, T, Ry', Rz', multiplied
       *  like so:  Rz * Ry * T * Ry' * Rz'.  T is the final rotation
       *  (which is about the X-axis), and the two composite transforms
       *  Ry' * Rz' and Rz * Ry are (respectively) the rotations necessary
       *  from the arbitrary axis to the X-axis then back.  They are
       *  all elementary rotations.
       *
       *  Rz' is a rotation about the Z-axis, to bring the axis vector
       *  into the x-z plane.  Then Ry' is applied, rotating about the
       *  Y-axis to bring the axis vector parallel with the X-axis.  The
       *  rotation about the X-axis is then performed.  Ry and Rz are
       *  simply the respective inverse transforms to bring the arbitrary
       *  axis back to it's original orientation.  The first transforms
       *  Rz' and Ry' are considered inverses, since the data from the
       *  arbitrary axis gives you info on how to get to it, not how
       *  to get away from it, and an inverse must be applied.
       *
       *  The basic calculation used is to recognize that the arbitrary
       *  axis vector (x, y, z), since it is of unit length, actually
       *  represents the sines and cosines of the angles to rotate the
       *  X-axis to the same orientation, with theta being the angle about
       *  Z and phi the angle about Y (in the order described above)
       *  as follows:
       *
       *  cos ( theta ) = x / sqrt ( 1 - z^2 )
       *  sin ( theta ) = y / sqrt ( 1 - z^2 )
       *
       *  cos ( phi ) = sqrt ( 1 - z^2 )
       *  sin ( phi ) = z
       *
       *  Note that cos ( phi ) can further be inserted to the above
       *  formulas:
       *
       *  cos ( theta ) = x / cos ( phi )
       *  sin ( theta ) = y / sin ( phi )
       *
       *  ...etc.  Because of those relations and the standard trigonometric
       *  relations, it is pssible to reduce the transforms down to what
       *  is used below.  It may be that any primary axis chosen will give the
       *  same results (modulo a sign convention) using thie method.
       *
       *  Particularly nice is to notice that all divisions that might
       *  have caused trouble when parallel to certain planes or
       *  axis go away with care paid to reducing the expressions.
       *  After checking, it does perform correctly under all cases, since
       *  in all the cases of division where the denominator would have
       *  been zero, the numerator would have been zero as well, giving
       *  the expected result.
*)
    xx := n.x * n.x;
    yy := n.y * n.y;
    zz := n.z * n.z;
    xy := n.x * n.y;
    yz := n.y * n.z;
    zx := n.z * n.x;
    xs := n.x * s;
    ys := n.y * s;
    zs := n.z * s;
    one_c := 1.0 - c;
    m._11 := (one_c * xx) + c;
    m._12 := (one_c * xy) - zs;
    m._13 := (one_c * zx) + ys;
 
    m._21 := (one_c * xy) + zs;
    m._22 := (one_c * yy) + c;
    m._23 := (one_c * yz) - xs;
 
    m._31 := (one_c * zx) - ys;
    m._32 := (one_c * yz) + xs;
    m._33 := (one_c * zz) + c;
  end;
  Result := m;
end;
 

Nach oben

Seite 1 von 1

[ 5 Beiträge ]

Foren-Übersicht » Programmierung » Allgemein

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 11 Gäste

Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.