# Winkel aus zwei Punkten/Längen (C++/OpenGL)



## Jy-Falc00n (14. November 2009)

*Winkel aus zwei Punkten/Längen (C++/OpenGL)*

Hallo!

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



```
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. November 2009)

*AW: Winkel aus zwei Punkten/Längen (C++/OpenGL)*

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


----------



## Jy-Falc00n (14. November 2009)

*AW: Winkel aus zwei Punkten/Längen (C++/OpenGL)*

Das ist mir schon klar. Ich berechne ja auch aus denn Punkten die Längen.


----------



## avenger (14. November 2009)

*AW: Winkel aus zwei Punkten/Längen (C++/OpenGL)*

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


----------



## rabit (14. November 2009)

*AW: Winkel aus zwei Punkten/Längen (C++/OpenGL)*

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


----------



## Jy-Falc00n (14. November 2009)

*AW: Winkel aus zwei Punkten/Längen (C++/OpenGL)*

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 )  :


```
#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. November 2009)

*AW: Winkel aus zwei Punkten/Längen (C++/OpenGL)*

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


----------

