Внутренний угол между двумя линиями

if (result > 180)
{
     result = 360 - result;
}

таким образом, это всегда будет внутренний угол. Просто добавьте его после получения результата.

Если вы хотите между углом в 0 градусов до 360 градусов, то используйте следующий код; его полностью протестировано и функционально:

static inline CGFloat angleBetweenLinesInRadians(CGPoint line1Start, CGPoint line1End, CGPoint line2Start, CGPoint line2End) {
double angle1 = atan2(line1Start.y-line1End.y, line1Start.x-line1End.x);
double angle2 = atan2(line2Start.y-line2End.y, line2Start.x-line2End.x);
double result = (angle2-angle1) * 180 / 3.14;
if (result<0) {
    result+=360;
}
return result;

}

Примечание: вращение будет по часовой стрелке;

внутренний угол между 2 векторами ( v1, v2) = arc cos(внутренний продукт (v1,v2) / (модуль(v1) * модуль (v2)) ).

где внутренний продукт (v1,v2) = xv1*xv2 + yv1*yv2

модуль (v) = sqrt(pow(xv,2) + pow(yv,2))

Итак, ответ на ваш вопрос реализован на следующем примере:

#define PI   3.14159258

int main()
{
    double x1,y1,x2,y2,y3;
    double m1, m2;
    double mod1, mod2, innerp, angle;

    cout << "x1 :";
    cin >> x1;
    cout << "y1 :";
    cin >> y1;
    cout << "x2 :";
    cin >> x2;
    cout << "y2 :";
    cin >> y2;
    cout << "y3 :";
    cin >> y3;

    m1 = atan((y2-y1)/(x2-x1)) * 180 / PI;
    m2 = atan((y3-y1)/(x2-x1)) * 180 / PI;

    mod1   = sqrt(pow(y2-y1,2)+pow(x2-x1,2));
    mod2   = sqrt(pow(y3-y1,2)+pow(x2-x1,2));
    innerp = (x2-x1)*(x2-x1) + (y2-y1)*(y3-y1);
    angle  = acos(innerp / (mod1 * mod2)) * 180 / PI;

    cout << "m1 : " << m1 << endl;
    cout << "m2 : " << m2 << endl;
    cout << "angle : " << angle << endl;
}

весь смысл намного проще, чем приведенные ответы:

когда вы используете atan (наклон), вы теряете (буквально) один бит информации, то есть есть ровно два угла (тета) и (тета+ПИ) в диапазоне (0..2 * PI), которые дают одинаковое значение для функции tan ().

просто используйте atan2 (deltax, deltay), и вы получите правильный угол. Например,

atan2(1,1) == PI/4
atan2(-1,-1) == 5*PI/4

затем вычесть, принять абсолютное значение, и если больше, чем PI вычесть из 2*PI.

Если вы используете значение abolute, вы всегда получите острый угол. Это тангенс тета = значение abs m1-m2 over (1 +m1 * m2). Если вы берете арктангенс ваш ответ будет в радианах или градусах, однако Калькулятор находится. Извините, это не язык программирования, я учитель математики, а не программист...

получение внешнего угла против внутреннего угла определяется полностью порядком ваших вычитаний (подумайте об этом). Вам нужно вычесть меньший тета из большего, чтобы надежно всегда получать внутренний угол. Вы также, вероятно, хотите использовать из-за типа данных, которые вы ожидаете.

надеюсь, я правильно понял ваш вопрос, как желающий острый угол, а не тупой угол пересечения двух линий. Я прав?

острые и тупые углы пересечения дополняют друг друга на 180 градусов. т. е.

 acute + obtuse = PI.

http://www.mathworks.com/access/helpdesk/help/techdoc/ref/atan.html показывает, что atan асимптотичен при +/- pi/2.

таким образом, максимальная разница между двумя результатами atan-это pi или 180 град, используете ли вы +/- обозначение или положительный 0 to pi обозначение градиента.

рассмотрим следующий псевдокод:

acuteAngle(m1, m2){
  a = atan(m1) - atan(m2);

  // if obtuse get the complementary acute angle:
  if (a>PI/2) 
    a = PI - a;
  return a;
} 

функции acuteAngle иллюстрирует то, что вам нужно сделать, математически.

однако его нельзя использовать для значений углов в окрестности PI / 2, потому что двоичные сравнения углов с результатами в этой окрестности сомнительны, является ли тупой или острый угол представленный.

поэтому мы должны сравнить координаты точек двух линий. Узнаем, образовалась ли 3-я строка из [(x2,y2)(x3,y3)] короче, равно или длиннее гипотетической гипотенузы.

в силу теоремы Пифагора, Гипотенуза образуется, если угол равен точно PI / 2 или 90o. Назовем его гипотетическую гипотенузную линию L3Hypo.

геометрической визуализацией в вашем уме,

• если 3-й линия длиннее L3Hypo, угол тупой.
• если короче, угол острый.
• в противном случае, идеальный 90.

таким образом,

L1.lengthSquared = sq(x2-x1) + sq(y2-y1)
L2.lengthSquared = sq(x3-x1) + sq(y3-y1)
L3Hypo.lengthSquared = L1.lengthSquared + L2.lengthSquared
L3.lengthSquared = sq(x3-x2) + sq(y3-y2)

поэтому следующий псевдо-код,

struct Point{
  double x, y;
}

// no need to struct, for clarity only
struct Line{
  double lengthSquared;
}

#define sq(n) (n*n)
int isObtuse(Point P1, P2, P3){
  Line L1, L2, L3, L3Hypo;

  L1.lengthSquared = sq(P2.x-P1.x) + sq(P2.y-P1.y);
  L2.lengthSquared = sq(P3.x-P1.x) + sq(P3.y-P1.y);
  L3Hypo.lengthSquared = L1.lengthSquared + L2.lengthSquared;
  L3.lengthSquared = sq(P3.x-P2.x) + sq(P3.y-P2.y);

  if (L3>L3Hypo) return 1; //obtuse
  else if (L3<L3Hypo) return -1; //acute
  else return 0;
}

предполагая, что у вас уже есть функция getGradient (точка P, Q):

double m1m2 = getGradient(P1,P2);
double m1m3 = getGradient(P1,P3);
double a = Abs(atan(m1m2) - atan(m1m3));
if (isObtuse(P1, P2, P3)>0)
  a = PI - a;

возможно, я совершил некоторые опечатки в псевдо-коде (надеюсь, нет), но я продемонстрировал суть концепции. Если так, кто-то может быть так добр, чтобы удалить опечатки.

дальше Однако, поразмыслив над этим, я обнаружил, что борьба за точность вращается на самом слабом звене из-за директивы

#define PI 3.14159blah..blah..blah.

Итак, мы могли бы также сэкономить все проблемы и просто сделать это:

double m1m2 = getGradient(P1,P2);
double m1m3 = getGradient(P1,P3);
double a = Abs(atan(m1m2) - atan(m1m3));
double b = PI - a;
return min(a, b);//the smaller of the two is the acute