Introduction

Given three points A, B, and C, the usual question is: what is the angle at point B made by the segments BA and BC? This comes up in game development, robotics, GIS, and any code that needs to reason about direction changes. The reliable solution is to convert the points into vectors and compute the angle from those vectors.

Build the Two Vectors

The angle is always measured at the middle point, so if the problem says "angle between three points" and means A-B-C, point B is the vertex. That means you should build two vectors starting at B:

• 'BA = A - B'
• 'BC = C - B'

In coordinates, if A = (ax, ay), B = (bx, by), and C = (cx, cy), then:

• 'BA = (ax - bx, ay - by)'
• 'BC = (cx - bx, cy - by)'

Once you have those vectors, the original geometry problem becomes a standard vector problem. This is better than using slopes because slopes break on vertical lines and behave badly near them.

Use the Dot Product for the Unsigned Angle

The standard formula is:

• 'dot(u, v) = ux * vx + uy * vy'
• '|u| = sqrt(ux * ux + uy * uy)'
• 'theta = acos(dot(u, v) / (|u| * |v|))'

That gives the smaller angle between the two vectors, in the range from 0 to pi radians. In degrees, convert with math.degrees.

Here is a complete Python example:

1import math
2
3
4def angle_between_points(a, b, c):
5    bax = a[0] - b[0]
6    bay = a[1] - b[1]
7    bcx = c[0] - b[0]
8    bcy = c[1] - b[1]
9
10    mag_ba = math.hypot(bax, bay)
11    mag_bc = math.hypot(bcx, bcy)
12    if mag_ba == 0 or mag_bc == 0:
13        raise ValueError("Angle is undefined when two points are identical")
14
15    dot = bax * bcx + bay * bcy
16    cos_theta = dot / (mag_ba * mag_bc)
17
18    # Clamp to protect against floating-point roundoff.
19    cos_theta = max(-1.0, min(1.0, cos_theta))
20
21    radians = math.acos(cos_theta)
22    degrees = math.degrees(radians)
23    return radians, degrees
24
25
26points = ((1, 2), (0, 0), (3, 1))
27radians, degrees = angle_between_points(*points)
28print(f"angle = {radians:.6f} rad")
29print(f"angle = {degrees:.2f} deg")

This version is practical because it handles the common failure case where one of the vectors has zero length and it clamps the cosine value before calling acos.

When You Need Direction, Use atan2

The dot-product formula gives only the unsigned angle. Sometimes that is not enough. For example, if you want to know whether a turn from BA to BC is clockwise or counterclockwise, you need a signed angle.

In two dimensions, combine the dot product with the scalar cross product:

• 'cross(u, v) = ux * vy - uy * vx'
• 'signed_angle = atan2(cross(u, v), dot(u, v))'

That returns an angle in the range from -pi to pi. Positive and negative values indicate orientation.

1import math
2
3
4def signed_angle_between_points(a, b, c):
5    bax = a[0] - b[0]
6    bay = a[1] - b[1]
7    bcx = c[0] - b[0]
8    bcy = c[1] - b[1]
9
10    dot = bax * bcx + bay * bcy
11    cross = bax * bcy - bay * bcx
12    return math.degrees(math.atan2(cross, dot))
13
14
15print(signed_angle_between_points((1, 0), (0, 0), (0, 1)))
16print(signed_angle_between_points((0, 1), (0, 0), (1, 0)))

This is often the better choice for path planning, steering, and polygon algorithms because it preserves turning direction.

Choosing the Right Representation

A few practical choices matter in production code.

First, decide whether your application wants radians or degrees. Most math libraries use radians, but user interfaces and debugging output are usually easier to read in degrees.

Second, decide whether you want the smaller angle only or the full signed turn. For collision handling or simple geometry checks, the smaller angle is usually enough. For navigation and rotation logic, the signed angle is often more useful.

Third, be explicit about the vertex. A large share of bugs in these calculations come from using the wrong point as the center of the angle. If the angle is at B, both vectors must start at B.

Common Pitfalls

A common mistake is using slopes instead of vectors. That creates division-by-zero cases for vertical lines and loses sign information.

Another frequent bug is forgetting that the angle is at the middle point. If you accidentally compute AB and AC, you are measuring the angle at A, not at B.

Floating-point rounding also matters. The expression passed to acos should be in the interval [-1, 1], but tiny precision errors can produce 1.0000000002 or -1.0000000001. Clamp the value before calling acos.

Finally, identical points make the angle undefined because one vector has length zero. Handle that case explicitly instead of letting the code fail later with a confusing error.

Summary

• The angle for A-B-C is the angle at point B
• Build vectors BA and BC before doing any math
• Use the dot product and acos for the smaller unsigned angle
• Use atan2(cross, dot) when direction matters
• Clamp the cosine input to avoid floating-point errors
• Reject zero-length vectors when two points are the same