Winkel aus zwei Punkten/Längen (C++/OpenGL) - Die Hardware-Community für PC-Spieler

Jy-Falc00n · 14.11.2009, 14:21

Hallo!

Zur Zeit versuche ich aus zwei verschiedene Punkten einen Winkel in Grad zu brechnen. Dazu habe ich folgende Formel formuliert :

Code:

b = atan((x1-x2)/(y1-y2))*180/M_PI

Ich bekomme zwar korekte Zahlen zurück, aber diese sind immer falsch. Nun will ich wissen was ICH falsch mache.

Wieder einmal brauche ich das für eine OpenGL Anwendung. Ich habe bereits danach gegooglt, aber außer eine genauso nutzlosen Berechnung mit atan2() nichts brauchbares gefunden.

Grüße

Jy-Falc00n

avenger · 14.11.2009, 15:31

Wie genau meinst du des, aus zwei Punkten einen Winkel zu bestimmen? Normalerweise tritt ein Winkel zwischen zwei Geraden auf

Jy-Falc00n · 14.11.2009, 15:41

Das ist mir schon klar.

Ich berechne ja auch aus denn Punkten die Längen.

avenger · 14.11.2009, 15:42

Kannst vllt. die gesamte Rechnung mal zeigen? Dann kann man sich eher was drunter vorstellen

rabit · 14.11.2009, 15:43

Tangens wiederholt sich doch alle 180 Grad zieh mal von deinem Ergebnis 180°ab.

Jy-Falc00n · 14.11.2009, 17:06

Also Gegeben sind :

X1,Y1 und X2,Y2

Das sind Punkte in einem Koordinaten System. Da ein Punkt alleine nicht reicht, berechne ich folgendermaßen die Ankathete : X1-X2. Genauso mit der Gegenkathete, Y1-Y2. Meines wissen nach muss ich nun Tanges anwenden. Da kein Winkel vorliegt, rechne ich nun (X1-X2) / (Y1-Y2). Denn Quotient jage ich nun durch durch atan(), also umgekertes Tangens. Zumschluss rechne ich das ganze noch in Grad um, * 180 / PI. Jedoch ist das ergebnis immer falsch. Als Test habe ich mal denn Zweiten Punkt im 90° Winkel plaziert, das ergebnis ist jedoch ca. 31°.

Hier ist noch mein Quellcode (recht Chaotisch

) :

Code:

#define _USE_MATH_DEFINES
#include <iostream>
#include <stdlib.h>
#include <GL/glut.h>
#include <math.h>
#include <stdio.h>


using namespace std;
GLdouble ox=0.0,oy=0.0,oz= 0.0;
int CursorX;
int CursorY;
float Xdevi;
float Ydevi;
float ang;
float enmX,enmY;
float a;

float angleofpoint2(float x1,float y1,float x2, float y2)
{
    float b;
    //b = atan2(y2 - y1, x2 - x1) * 180 / M_PI;
    b = atan2(y2 - y1, x2 - x1) * 180 / 3.14159265;
    return b;
}

void WinPosTo3DPos(int x, int y)
{
  GLint viewport[4];
  GLdouble modelview[16],projection[16];
  GLfloat wx=x,wy,wz;
  glGetIntegerv(GL_VIEWPORT,viewport);
  y=viewport[3]-y;
  wy=y;
  glGetDoublev(GL_MODELVIEW_MATRIX,modelview);
  glGetDoublev(GL_PROJECTION_MATRIX,projection);
  glReadPixels(x,y,1,1,GL_DEPTH_COMPONENT,GL_FLOAT,&wz);
  gluUnProject(wx,wy,wz,modelview,projection,viewport,&ox,&oy,&oz);
}

void PosByAngle(float angle,float lenght,float x, float y)

{
    enmX = (sin(angle) * lenght) + enmX;
    enmY = (cos(angle) * lenght) + enmY; 
}


void initRender(int w, int h) 
{

    glEnable(GL_DEPTH_TEST);
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity(); 
    gluPerspective(45.0,                  
                   (double)w / (double)h, 
                   1.0,
                   200.0);
    WinPosTo3DPos(400,300);

}

void Render()
{

    glDepthMask(true);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity(); 

    glColor3f(0.8f,0.8f,0.6f);
    glBegin(GL_TRIANGLE_STRIP);
        glVertex3d(-50.0f,50.0f,-51.0f);
        glVertex3d(-50.0f,-50.0f,-51.0f);
        glVertex3d(50.0f,50.0f,-51.0f);
        glVertex3d(50.0f,-50.0f,-51.0f);
    glEnd();

    glLoadIdentity();
    a = angleofpoint2(enmX, enmY, CursorX , CursorY);
    //ang = sin(
    cout << a<< "  ";

    PosByAngle(a, 0.0f, enmX, enmY);

    glTranslatef(enmX,enmY,-50.0f);
    glColor3f(1.0f,0.0f,0.0f);
    glutSolidSphere(1,8,8);
    
    glLoadIdentity(); 
    
    glDepthMask(false);
    glColor3f(0.0f,1.0f,0.0f);
    

    WinPosTo3DPos(CursorX,CursorY);
    glTranslatef(ox,oy,oz);
    glutSolidSphere(1,16,16);
    glLoadIdentity(); 

    glutSwapBuffers();
}



void MouseMang(int button, int state, int x, int y) // Mouse handle function
{
    WinPosTo3DPos(x,y);
    cout << "Done!";
}

void MouseMang_Move(int x, int y)
{
    CursorX = x;
    CursorY = y;
}
void Game(int vaule)
{
    glutPostRedisplay();
    glutTimerFunc(25, Game,0);
}
int main(int argc, char** argv)
{
    enmX = 2.0f;
    enmY = 0.0f;
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(800, 600);
    glutCreateWindow("OpenGL");
    initRender(800,600);
    glutPassiveMotionFunc(MouseMang_Move);
    glutMouseFunc(MouseMang);
    glutDisplayFunc(Render);
    glutTimerFunc(1000, Game,0);
    glutMainLoop();

    return 0;

}

Jy-Falc00n · 14.11.2009, 21:08

Ich hab denn Fehler Gefunden... Das hätte auch garnicht funktionieren können wenn ich denn Winkel aus Fenster und 3D Koordinaten erechnen will.

Anfänger Fehler halt.

Die Formel war aber richtig.

Grüße

Jy-Falc00n