计算两个向量夹角范围在0到360

double getAngle(double* vec1, double* vec2)

#include "header.h"

const double PI = 3.14159265358979;

class PSVector2D
{
public:
    double x;
    double y;

    PSVector2D(double _x, double _y)
    {
        x = _x;
        y = _y;
    }
};

template <typename DataType>
double getDegAngle2d(const DataType data1, const DataType data2);
double getAngle(double* vec1, double* vec2);

template <typename DataType>
double getDegAngle2d(const DataType data1, const DataType data2)
{
    double vec1[] = { data1.x,data1.y };
    double vec2[] = { data2.x,data2.y };
    return getAngle(vec1, vec2);
}

double getAngle(double* vec1, double* vec2)
{
    // 3,4 quadrant of the coordinate(-PI,0) -> (PI,2PI)
    auto TransformCoordinate = [](const double& angle)
    {
        double transfAngle = angle;
        if (transfAngle != 0.0 &&
            transfAngle < DBL_EPSILON &&
            transfAngle > -atan2(0, -1))
        {
            transfAngle += 2 * PI;
        }
        return transfAngle;
    };

    const double angleStart = atan2(vec1[1], vec1[0]);
    const double angleEnd = atan2(vec2[1], vec2[0]);
    double theta = TransformCoordinate(angleEnd) - TransformCoordinate(angleStart);

    if (theta < DBL_EPSILON)
    {
        theta += 2 * PI;
    }

    //std::cout << vec1[0] << "," << vec1[1] << " " << TransformCoordinate(angleStart) * 180 / PI
    //    << " -> " << vec2[0] << "," << vec2[1] << " " << TransformCoordinate(angleEnd) * 180 / PI
    //    << " : " << theta * 180 / PI << endl;

    return theta;
}

void TestCase()
{
    double vec[][2] = {
    0,0,            // 0        0
    0.8660254,0.5,  // 1/6     30
    1,1,            // 1/4     45
    0.5,0.8660254,  // 1/3     60
    0,1,            // 1/2     90
    -0.5,0.8660254, // 2/3    120
    -1,1,           // 3/4    145
    -0.8660254,0.5, // 2/3    150
    -1,0,           // 1      180
    -0.8660254,-0.5,// -5/6   210
    -1,-1,          // -3/4   225
    -0.5,-0.8660254,// -2/3   240
    0,-1,           // -1/2   270
    0.5,-0.8660254, // -1/3   300
    1,-1,           // -1/4   315
    0.8660254,-0.5  // -1/6   330
    };

    double angle = 0.1;
#if 1
    int size = sizeof(vec) / sizeof(double) / 2;
    for (int i = 0;i < size;++i)
    {
        for (int j = i + 1;j < size;++j)
        {
            double angle = getAngle(vec[i], vec[j]) * 180 / PI;
            double reverseAngle = getAngle(vec[j], vec[i]) * 180 / PI;
            double sumAngle = angle + reverseAngle;
            if (sumAngle - 360.0 < DBL_EPSILON)
            {
                cout << "OK" << endl;
            }
            else
            {
                cout << "NG" << endl;
                printf("\t %.10f %.10f\n", angle, reverseAngle);
            }
        }
    }

    cout << "*****************************************************************" << endl;

    for (int i = size - 1;i >= 0;--i)
    {
        for (int j = i - 1;j >= 0;--j)
        {
            double angle = getAngle(vec[i], vec[j]) * 180 / PI;
            double reverseAngle = getAngle(vec[j], vec[i]) * 180 / PI;
            double sumAngle = angle + reverseAngle;
            if (sumAngle - 360.0 < DBL_EPSILON)
            {
                cout << "OK" << endl;
            }
            else
            {
                cout << "NG" << endl;
                printf("\t %.10f %.10f\n", angle, reverseAngle);
            }
        }
    }
#endif
}

int main()
{
    double angle = 0.1;

    TestCase();

    PSVector2D vec1PS(1.0, 1.0);
    PSVector2D vec2PS(-1.0, -1.0);

    angle = getDegAngle2d(vec1PS, vec2PS);
    angle = getDegAngle2d(vec2PS, vec1PS);
    return 0;
}