Clamp angle to arbitrary range

Question

I need a function to clamp an angle (in degrees) into an arbitrary range [min,max]. Here are some examples:

The colored areas represent the valid angle range.

In image #1, ang should be clamped to max (-90)
In image #2, ang should be clamped to min (135)
In image #3, ang should be clamped to min (135)

This is what I have so far:

static float clamp_angle(float ang,float min,float max)
{
    ang = normalize_angle(ang); // normalize_angle transforms angle into [-180,180) range
    min = normalize_angle(min);
    max = normalize_angle(max);
    if(angle_in_range(ang,min,max) == false)
    {
        if(abs(get_angle_difference(ang,min)) < abs(get_angle_difference(ang,max))
            ang = min; // Clamp to min if we're closer to min than max
        else
            ang = max;
    }
    return ang;
}

What I'm missing is the function angle_in_range (true if the angle is within the range, otherwise false).
What would be the simplest way of determining whether the angle is within the range or not?

This sounds similar to http://stackoverflow.com/questions/13652518/efficiently-find-points-inside-a-circle-sector ? At least the math requirements. — Zze, Feb 15 '17 at 10:36

Serikov · Accepted Answer · 2017-02-15T11:56:26.303

You can normalize angles in such a way that ang become 0 and min and max is mapped to [-180; 180). Then you can check if angle is in provided range like this:

float clamp_angle(const float ang, const float min, const float max)
{
    float n_min = normalize180(min-ang);
    float n_max = normalize180(max-ang);

    if (n_min <= 0 && n_max >= 0)
    {
        return ang;
    }
    if (abs(n_min) < abs(n_max))
        return min;
    return max;
}

Live On Coliru

Dmitry Lachinov · Answer 2 · 2017-02-15T11:43:52.310

Assume you use clockwise order. The distance between min and max in cw order is dist(min, max) = (max - min)mod N Assume point inside region. Then dist(min,A) + dist(A,max) = dist(min,max). Now you can measure distance between point A, min and max : dist(min, A)= (A - min)modN dist(A, max)=(max-A)modN. If A outside region, then sum of the distances should be N+dist(min, max), if inside it should be equal dist(min,max)

In your case N = 360, all values lies in [0,360)

Edit: In most languages behavior of (-x)modX is undefined, so you should manually convert -x to positive number e.g. (-x + X)modX where x lies in [0,X)

score 0 · Answer 3 · answered Jan 15 '19 at 01:49

If you want to clamp the angle so that it stays within the range but it wraps around when it reaches max or min (instead of clipping to the limits) then you could use this fairly simple function I worte using python:

def clamp_to_range(value, min, max):
     return (value % (max - min)) + min

It behaves like this:

>>> for i in range(0, 30): print("|{:<30}|{:<30}|".format(" "*(clamp_to_range(i, 4, 15)) + "♥", " "*i + "♥"))
...
|    ♥                         |♥                             |
|     ♥                        | ♥                            |
|      ♥                       |  ♥                           |
|       ♥                      |   ♥                          |
|        ♥                     |    ♥                         |
|         ♥                    |     ♥                        |
|          ♥                   |      ♥                       |
|           ♥                  |       ♥                      |
|            ♥                 |        ♥                     |
|             ♥                |         ♥                    |
|              ♥               |          ♥                   |
|    ♥                         |           ♥                  |
|     ♥                        |            ♥                 |
|      ♥                       |             ♥                |
|       ♥                      |              ♥               |
|        ♥                     |               ♥              |
|         ♥                    |                ♥             |
|          ♥                   |                 ♥            |
|           ♥                  |                  ♥           |
|            ♥                 |                   ♥          |
|             ♥                |                    ♥         |
|              ♥               |                     ♥        |
|    ♥                         |                      ♥       |
|     ♥                        |                       ♥      |
|      ♥                       |                        ♥     |
|       ♥                      |                         ♥    |
|        ♥                     |                          ♥   |
|         ♥                    |                           ♥  |
|          ♥                   |                            ♥ |
|           ♥                  |                             ♥|

as I mentioned, it wraps around. If you instead want to clip the value to the specified limits, you can use this function:

def clip_to_range(value, min_, max_):  # underscores added to avoid name collisions
     return min(max_, max(value, min_))

In this case this will happen:

>>> for i in range(0, 30): print("|{:<30}|{:<30}|".format(" "*clip_to_range(i, 4, 15) + "♥", " "*i + "♥"))
...
|    ♥                         |♥                             |
|    ♥                         | ♥                            |
|    ♥                         |  ♥                           |
|    ♥                         |   ♥                          |
|    ♥                         |    ♥                         |
|     ♥                        |     ♥                        |
|      ♥                       |      ♥                       |
|       ♥                      |       ♥                      |
|        ♥                     |        ♥                     |
|         ♥                    |         ♥                    |
|          ♥                   |          ♥                   |
|           ♥                  |           ♥                  |
|            ♥                 |            ♥                 |
|             ♥                |             ♥                |
|              ♥               |              ♥               |
|               ♥              |               ♥              |
|               ♥              |                ♥             |
|               ♥              |                 ♥            |
|               ♥              |                  ♥           |
|               ♥              |                   ♥          |
|               ♥              |                    ♥         |
|               ♥              |                     ♥        |
|               ♥              |                      ♥       |
|               ♥              |                       ♥      |
|               ♥              |                        ♥     |
|               ♥              |                         ♥    |
|               ♥              |                          ♥   |
|               ♥              |                           ♥  |
|               ♥              |                            ♥ |
|               ♥              |                             ♥|

A C analog to the clamp_to_range function would look like this:

#include <math.h>

float clampInRange(float value, float min, float max)
{
    return fmod(value, max - min) + min;
}

shouldn't you subtract the "min" from value before the modulo operation? That is return (value - min_val) % (max_val - min_val)) + min_val. On another note: you SHOULD NOT use min or max as variable names, because min and max are built-in python functions — Robyc, Jul 07 '21 at 15:50

Clamp angle to arbitrary range

3 Answers3