Pfeil eines Vektors in die richtige Richtung drehen, aber wie?

T0bi

wie gesagt das bekomm ich erst im naechstem semester:

aber etwas hab ich es glaube verstanden. ich muss 2mal das skalarprodukt errechnen

einmal um den zylinder um die zAchse zu drehen

y
^
|   /<--- Vektor a
|  /
| /\
|/a \<---------Windkel für glRotatef( a, 0.0f, 0.0f, 1.0f )
+--------->x

und einmal um den zylinder um die yAchse zu drehen

x
^
|   /<--- Vektor a
|  /
| /\
|/b \<---------Windkel für glRotatef( b, 0.0f, 1.0f, 0.0f )
+--------->z

dabei ist beim winkel a, ist der eine vektor der den ich zeichnen lasse und der andere ist die xAchse( mit ( 1 / 0 / 0 ) ), oder?

und beim winkel b, ist der eine vektor der den ich zeichnen lasse und der andere ist die zAchse( mit ( 0 / 0 / 1 ) ), oder?

hab ich das jetzt einiger maßen richtig erkannt?

this-*gt*that

T0bi schrieb:

aber etwas hab ich es glaube verstanden. ich muss 2mal das skalarprodukt errechnen

einmal um den zylinder um die zAchse zu drehen
und einmal um den zylinder um die yAchse zu drehen

Ja

T0bi schrieb:

dabei ist beim winkel a, ist der eine vektor der den ich zeichnen lasse und der andere ist die xAchse( mit ( 1 / 0 / 0 ) ), oder?

Ich habe v und die y-Achse genommen. Du kannst aber auch die x-Achse nehmen.

und beim winkel b, ist der eine vektor der den ich zeichnen lasse und der andere ist die zAchse( mit ( 0 / 0 / 1 ) ), oder?

Für den 2. Winkel habe ich (wie man im Code sieht) die x-Achse genommen. Allerdings kann man es auch mit der z-Achse machen.

Wichtig ist halt einfach nur, dass du die 2 Winkel zur Orientierung errechnest. Das hier sollte eigentlich letzte Unklarheiten beseitigen: http://de.wikipedia.org/wiki/Kugelkoordinaten

T0bi

okay danke erste mal, ich werds mal alles probieren und wenns net gehts frag ich noch mal

Gruß Tobi.

T0bi

// ***** draw peak *****
    // ***** vector *****
    vec[ 0 ] = xPos2 - xPos1; // x
    vec[ 1 ] = yPos2 - yPos1; // y
    vec[ 2 ] = zPos2 - zPos1; // z

    // ***** xAxis *****
    vX[ 0 ] = 1.0f; // x
    vX[ 1 ] = 0.0f; // y
    vX[ 2 ] = 0.0f; // z

    // ***** zAxis *****
    vZ[ 0 ] = 0.0f; // x
    vZ[ 1 ] = 0.0f; // y
    vZ[ 2 ] = 1.0f; // z

    fa = (float)( ( ( vec[ 0 ] * vX[ 0 ] ) + ( vec[ 1 ] * vX[ 1 ] ) + ( vec[ 2 ] * vX[ 2 ] ) ) );

    fa /= ( sqrt( ( vec[ 0 ] * vec[ 0 ] ) + ( vec[ 1 ] * vec[ 1 ] ) + ( vec[ 2 ] * vec[ 2 ] ) ) *
            sqrt( ( vX[ 0 ] * vX[ 0 ] ) + ( vX[ 1 ] * vX[ 1 ] ) + ( vX[ 2 ] * vX[ 2 ] ) ) );

    fa = acos( fa );
    fa = ( fa * 180 ) / PI;

    fb = (float)( ( ( vec[ 0 ] * vZ[ 0 ] ) + ( vec[ 1 ] * vZ[ 1 ] ) + ( vec[ 2 ] * vZ[ 2 ] ) ) );

    fb /= ( sqrt( ( vec[ 0 ] * vec[ 0 ] ) + ( vec[ 1 ] * vec[ 1 ] ) + ( vec[ 2 ] * vec[ 2 ] ) ) *
            sqrt( ( vZ[ 0 ] * vZ[ 0 ] ) + ( vZ[ 1 ] * vZ[ 1 ] ) + ( vZ[ 2 ] * vZ[ 2 ] ) ) );

    fb = acos( fb );
    fb = ( fb * 180 ) / PI;

    glPushMatrix( );

        glRotatef( fb, 0.0f, 0.0f, 1.0f ); // rotate z
        glRotatef( fa, 0.0f, 1.0f, 0.0f ); // rotate y
        glTranslatef( -xPos2, -yPos2, zPos2 );
        gluCylinder( obj, ( froom * 0.04f ), 0, ( froom / 5 ), 30, 30 );
    glPopMatrix( );

sooo? aber irgendwie ist die spitze jetzt immer wo anderes.

T0bi

hallo?

this-*gt*that

Hi

Wenn du es verstehen möchtest, führt kein Weg an einem Matrizen/Vektor-Tutorial vorbei.
Was nutzt dir fertiger Code, wenn du es danach immer noch nicht kapiert hast.
http://cybersound.cy.funpic.de/tutorial-gfx-game/3d-mathematik.php
Hier, das is recht gut geschrieben
rya.

T0bi

hm.. aber ich wollte doch nur wissen ob meine formel da richtig ist. ich habe mir noch mal zum verglich um einige Fälle durch zu spielen einekleine Konsolenanwendung gebastelt, mit der ich die Drehwinkel um beide Achsen ermitteln wollte.
Hier das Miniprog:

#include <iostream>
#include <math.h>
    using namespace std;

#define PI 3.1415926535897932384626433832795
typedef struct DOT {

    float x;
    float y;
    float z;

} Skalar;

int main( int argc, char* argv[] ) {

    // ***** Rotation angels *****
    float fAngelOne = 0.0f;
    float fAngelTwo = 0.0f;

    // ***** Vectors *****

    Skalar sVector, sX, sZ;
    // ***** MyVector *****
    sVector.x = 1.0f;
    sVector.y = 0.0f;
    sVector.z = 0.0f;

    // ***** yAxis *****
    sX.x = 1.0f;
    sX.y = 0.0f;
    sX.z = 0.0f;

    // ***** xAxis *****
    sZ.x = 0.0f;
    sZ.y = 0.0f;
    sZ.z = 1.0f;

    // ***** Calculation *****

    // ***** for z rotation *****
    fAngelOne = ( ( sVector.x * sX.x ) + ( sVector.y * sX.y ) + ( sVector.z * sX.z ) ) /
                ( ( sqrt( ( ( sVector.x * sVector.x ) + ( sVector.y * sVector.y ) + ( sVector.z * sVector.z ) ) ) *
                  ( sqrt( ( ( sX.x * sX.x ) + ( sX.y * sX.y ) + ( sX.z * sX.z ) ) ) ) ) );

    fAngelOne = acos( fAngelOne );
    fAngelOne = ( fAngelOne * 180.0f ) / PI;

    // ***** for y rotation *****
    fAngelTwo = ( ( sVector.x * sZ.x ) + ( sVector.y * sZ.y ) + ( sVector.z * sZ.z ) ) /
                ( ( sqrt( ( ( sVector.x * sVector.x ) + ( sVector.y * sVector.y ) + ( sVector.z * sVector.z ) ) ) *
                  ( sqrt( ( ( sZ.x * sZ.x ) + ( sZ.y * sZ.y ) + ( sZ.z * sZ.z ) ) ) ) ) );

    fAngelTwo = acos( fAngelTwo );
    fAngelTwo = ( fAngelTwo * 180.0f ) / PI;

    cout << "\n 1. Angel :  " << fAngelOne << "   ( rotation angel for yAxis! )" << endl;
    cout << "\n 2. Angel :  " << fAngelTwo << "   ( rotation angel for zAxis! )" << endl;
    getchar( );
    return 0;
}

Diese Formel klappt eigentlich ganz gut solange x = Null ist, ist x aber != 0 dann wird die Pfeilspitze wieder krum. Beispiel
1/1/0
für zRotation wird der Winkel 90° und für die yRotation 45°. Das kann aber nicht stimmen. eigentlich müsste doch alles genau anders rum sein. wieso ist das aber nicht so?

Oder muss ich noch den Vektor normalisieren?

Gruß Tobi.

T0bi

so gehts! wer einwende hat soll hier schrein...

const double PI = 3.141592;
    GLUquadricObj *obj;
    typedef struct DOT {

        float x;
        float y;
        float z;

    } Skalar;

    Skalar sVector, sX, sZ;

    // ***** length of vector *****
    float fLength = 0.0f;

    // ***** Rotation angels *****
    float fAngelOne = 0.0f;
    float fAngelTwo = 0.0f;

    obj = gluNewQuadric( );
    gluQuadricNormals( obj, GL_SMOOTH );
    glLineWidth( 2.0f );

    glBegin( GL_LINES );

        // ***** start from O *****
        glVertex3f( -xPos1, -yPos1, zPos1 );

        // ***** to x/y/z *****
        glVertex3f( -xPos2, -yPos2, zPos2 );
    glEnd( );

    // ***** draw peak *****
    // ***** MyVector *****
    sVector.x = xPos2 - xPos1;
    sVector.y = yPos2 - yPos1;
    sVector.z = zPos2 - zPos1;

    // ***** xAxis *****
    if( yPos2 <= 0.0f ) {

        sX.x = -1.0f;
    }
    else {

        sX.x =  1.0f;
    }
    sX.y =  0.0f;
    sX.z =  0.0f;

    // ***** zAxis *****
    sZ.x = 0.0f;
    sZ.y = 0.0f;
    sZ.z = 1.0f;

    // ***** Calculation *****

    // ***** normal. vector *****
    fLength = sqrt( ( sVector.x * sVector.x ) + ( sVector.z * sVector.z ) + ( sVector.z * sVector.z ) );

    if( fLength != 0.0f ) {

        sVector.x /= fLength;
        sVector.y /= fLength;
        sVector.z /= fLength;
    }
    // ***** for z rotation *****
    fAngelOne = ( ( sVector.x * sX.x ) + ( sVector.y * sX.y ) + ( sVector.z * sX.z ) ) /
                ( ( sqrt( ( ( sVector.x * sVector.x ) + ( sVector.y * sVector.y ) + ( sVector.z * sVector.z ) ) ) *
                  ( sqrt( ( ( sX.x * sX.x ) + ( sX.y * sX.y ) + ( sX.z * sX.z ) ) ) ) ) );

    fAngelOne = acos( fAngelOne );
    fAngelOne = ( fAngelOne * 180.0f ) / PI;

    // ***** for y rotation *****
    fAngelTwo = ( ( sVector.x * sZ.x ) + ( sVector.y * sZ.y ) + ( sVector.z * sZ.z ) ) /
                ( ( sqrt( ( ( sVector.x * sVector.x ) + ( sVector.y * sVector.y ) + ( sVector.z * sVector.z ) ) ) *
                  ( sqrt( ( ( sZ.x * sZ.x ) + ( sZ.y * sZ.y ) + ( sZ.z * sZ.z ) ) ) ) ) );

    fAngelTwo = acos( fAngelTwo );
    fAngelTwo = ( fAngelTwo * 180.0f ) / PI;

    if( yPos2 > 0.0f ) {

        fAngelTwo *= -1;
    }

    glPushMatrix( );
        // ***** draw peak *****
        glTranslatef( -xPos2, -yPos2, zPos2 );
        glRotatef( fAngelOne, 0.0f, 0.0f, 1.0f ); // rotate z
        glRotatef( fAngelTwo, 0.0f, 1.0f, 0.0f ); // rotate y

        gluCylinder( obj, ( froom * 0.03f ), 0, ( froom / 10 ), 30, 30 );
    glPopMatrix( );

dnake euch erst mal alle für eure hilfe und für die guzten tutorials.

Gruß Tobi.

xindon

Einwand!

dt. Winkel = en. angle
dt. Engel = en. angel

T0bi

xD sorry, wrerds mir merken.