Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » OpenGL » Winkeldefinition (OpenGL vs trignometrisch)

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
17.07.2009, 16:37 Uhr
Dirk1980



Hallo,

bei den trigonometrischen Funktionen sind die Winkel anders definiert als in OpenGL.

Trigonometrische Funktionen (z.B. cos, sin): 0° auf der x-Achse, Richtung: gegen den Uhrzeigersinn
OpenGL: 0° auf der y-Achse, Richtung: mit dem Uhrzeigersinn

Wie geht ihr damit um?

Schreibt ihr euch jeweils einen Wrapper für die trigonometrischen Funktionen und rechnet dort den Winkel mit (90°-Winkel) von "OpenGL" nach "trigonometrisch" um,
und macht dann in diesem Wrapper gleich noch die Konvertierung degree nach rad?

Oder wie macht ihr es?

Ich komme auf dieses Problem, weil ich eine Funktion für einen Kreisbogen geschrieben habe. Bei der Darstellung ist mir dann aufgefallen, dass OpenGL die Winkel anders definiert hat, als die trigonometrischen Funktionen.

Gruß
Dirk

Dieser Post wurde am 17.07.2009 um 16:38 Uhr von Dirk1980 editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
17.07.2009, 20:13 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


naja ich dreh mir normalerweise immer das koordinatensystem so das es richtig rum ist
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
18.07.2009, 00:01 Uhr
Hans
Library Walker
(Operator)


Hi,

bei meinen ersten Grafikexperimenten auf dem Heimcomputer waren die Grafikfunktionen auch so definiert, wie Du sie für OpenGL beschreibst. Ich hatte dann später Schwierigkeiten, mich an diesen "mathematisch positiven Drehsinn" zu gewöhnen, als ich es zum ersten mal mit den BGI-Funktionen aus Borlands Turbo-Sprachen zu tun bekam.


Zitat von Dirk1980:
Konvertierung degree nach rad?

Dazu brauchst Du doch blos Winkel*pi/180 zu rechnen, das hast Du doch das Bogenmass.


Zitat:
Schreibt ihr euch jeweils einen Wrapper für die trigonometrischen Funktionen und rechnet dort den Winkel mit (90°-Winkel) von "OpenGL" nach "trigonometrisch" um,

Also ob man das schon als "Wrapper" bezeichnen kann lass ich mal dahin gestellt, aber wenn man sich das mal aufmalt, etwa so:

Code:
                                                      
                                                      
                        y^                              
                         |                              
                         |90°                              
                         |                            
                         |                                
                         |                              
                       0°|                              
                     360°|                            
                         |                            
                         |                            
      180°               |      90°                    
     --------------------+-------------------->        
               270°      |                0°  x        
                         |              360°          
                         |                            
                         |180°                        
                         |                            
                         |                            
                         |                            
                     270°|                            
                         |                          
                                                    
Innen: OGL-Winkeldefinition                        
Aussen: mathematische Winkeldefinition            


stellt man fest, das es sich um zwei zusätzliche Drehungen handelt, durch die sich die Winkel unterscheiden.
Die Winkel sind bei OGL erst mal um 180° um die y-Achse, dann um (mathematisch) -90° um die z-Achse gedreht. Für diese Drehungen würde ich mir zwei Funktionen schreiben, die das für mich erledigen; - von "OGL zu trigonometrisch" und von "trigonometrisch zu OGL". Sofern Du dabei nur mit den Winkeln rechnest, müsste das ganze eigentlich sogar rein mit Additionen realisierbar sein, d.h. nicht sehr rechenintensiv.

Hans
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
18.07.2009, 09:11 Uhr
FloSoft
Medialer Over-Flow
(Administrator)



Zitat:

Die Winkel sind bei OGL erst mal um 180° um die y-Achse, dann um (mathematisch) -90° um die z-Achse gedreht.



Oder man dreht einfach "alles" um 180° um die y-Achse und -90° um die z-Achse ;-) so mach ich das immer
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
20.07.2009, 11:11 Uhr
Dirk1980



Hallo,

danke für Eure Antworten.

Mir ist klar, dass wenn man um 180° um die y-Achse dreht und dann anschließend um -90° um die z-Achse, dass dann die OpenGL-Winkel identisch sind zu den trigonometrischen Winkeln.


Code:
/* rotate 180° around y-axis */
glRotatef( 180.0, 0.0, 1.0, 0.0 );

/* rotate -90° around z-axis */
glRotatef( -90.0, 0.0, 0.0, 1.0 );



Bei diesen Drehungen passiert doch aber auch folgendes:
z-Achse zeigt nun nach innen anstatt nach außen
y-Achse zeigt nun nach rechts anstatt nach oben
x-Achse zeigt nun nach oben anstatt rechts

Mir ist jetzt leider folgendes immer noch nicht klar:

1.) Welche Winkeldefinition haltet ihr für die richtige? OpenGL oder trigonometrisch?

2.) Wann führt ihr diese Drehungen durch? Einmal am Anfang direkt nach der Definition des Koordinatensystems oder immer vor dem Aufruf einer trigonometrischen Funktion?


Hier mal ein Beispiel:

Ich habe eine Funktion geschrieben, die den Kreisbogen im Uhrzeigersinn zeichnen soll. Input Parameter sind der Mittelpunkt des Kreises, der Radius, der Start- und der Endwinkel.


Code:
const float DEG2RAD = 3.14159/180;

static void drawCircleArcClockwise(struct TPoint* p_point, float radius, float start_angle, float end_angle)
{
    float degInRad;
    float angle_step = 1.0;
    float angle;

    glBegin(GL_LINE_STRIP);
    {
        angle = start_angle;
        while( angle <= end_angle )
        {
            degInRad = angle*DEG2RAD;
            glVertex2f(cos(degInRad)*radius + p_point->x,sin(degInRad)*radius + p_point->y);

            angle = angle + angle_step;
        }
    }
    glEnd();

    glBegin(GL_LINES);
    {
        degInRad = (angle-angle_step)*DEG2RAD;
        glVertex2f(cos(degInRad)*radius,sin(degInRad)*radius);

        degInRad = end_angle*DEG2RAD;
        glVertex2f(cos(degInRad)*radius,sin(degInRad)*radius);
    }
    glEnd();
}



1.) Mit welcher Winkeldefinition würdet ihr diese Funktion aufrufen? (OpenGL oder trigonometrisch?)
2.) Wo würdet ihr diese Drehungen jetzt durchführen?

Viele Grüße
Dirk

Dieser Post wurde am 20.07.2009 um 11:11 Uhr von Dirk1980 editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
20.07.2009, 14:26 Uhr
TOSHMAX



Hi,
wenn du die 0° oben haben willst und 90° rechts kannst du es z. B. so umstellen:

C++:
glVertex2f(sin(degInRad)*radius + p_point->x,p_point->y - cos(degInRad)*radius);


So kannst du auch noch ein wenig rumspielen, damit das rauskommt was du haben willst.

Gruß
Toshmax
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
20.07.2009, 16:29 Uhr
FloSoft
Medialer Over-Flow
(Administrator)



Zitat:

Bei diesen Drehungen passiert doch aber auch folgendes:
z-Achse zeigt nun nach innen anstatt nach außen
y-Achse zeigt nun nach rechts anstatt nach oben
x-Achse zeigt nun nach oben anstatt rechts


das ist klar, du kannst es auch anders drehen (also erst um z) dann zeigt x und y achse "richtig" und bei z musste halt mit negativen werten arbeiten (macht man doch imho bei direct3d auch das die distanz "in den raum" hinein negativ ist)
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
21.07.2009, 22:38 Uhr
Dirk1980



Hallo FloSoft,

dein beschriebenes Koordinatensystem wäre super. Aber ich verstehe nicht, wie du das hinbekommen willst.

Wenn ich erst um -90° um die z-Achse drehe und dann um 180° um die y-Achse. Da kommt doch genau dasselbe heraus, wie wenn ich erst um 180° um die y-Achse drehe und dann um -90° um die z-Achse.

Ich verstehe sowieso nicht, wie es möglich ist die y-Achse weiterhin nach oben zeigen zu lassen und die 0° auf die x-Achse zu legen.

Wie genau drehst du, damit die y-Achse nach oben zeigt, die x-Achse nach rechts und der Winkel 0° auf der x-Achse liegt und der Winkel 90° auf der y-Achse liegt?

Viele Grüße
Dirk
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
22.07.2009, 08:22 Uhr
FloSoft
Medialer Over-Flow
(Administrator)


ich find das beispiel wo ich da mal hatte leider nicht mehr, aber imho musstest du mehrmals über mehrere achsen drehen (kann man ja direkt angeben) hab aber wie gesagt das was ich mir da damals zusammengefrickelt hab nicht mehr gefunden gerade. wird wohl in irgendeinem backup drin sein
--
class God : public ChuckNorris { };
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ OpenGL ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: