How to detect if object is moving in clockwise- or counterclockwise direction?

Question

I've read this one, but I need more info: rotating an object from sourceAngle to destAngle, both 0-359, clockwise or counter clockwise?

I have a ball. The user is able to drag the ball in any direction clockwise/anticlockwise around a circle. I need to know whether or not the ball was dragged clockwise or anticlockwise.

I'd like to get both vector/non-vector methods.

Answer 1

Keep track of the position of the ball on the previous frame. Then let's say we have:

A                 
|\                // A = Rotation Center
| \               // B = Previous Frame Position
|  C              // C = Current Frame Position
B

You need to check using the 2D analog of a cross product whether C lies to the left or to the right of the AB line segment. If it's to the right, then it's rotating clockwise. If it's to the left, then it's rotating counter-clockwise.

You can use this method to check:

bool isLeft(Vector2 a, Vector2 b, Vector2 c)
{
     return ((b.x - a.x)*(c.y - a.y) - (b.y - a.y)*(c.x - a.x)) > 0;
}

Answer 2

Given the points Source, Destination and Centre, where a move has happened from Source to Destination first compute the vectors:

CentreSource = Source - Centre
CentreDestination = Destination - Centre

Compute the dot product of the tværvector of CentreSource and CentreDestination:

RorL = CentreSourceX * CentreDestinationY - CentreSourceY * CentreDestinationX

Now RorL should be positive if the point is moving counterclockwise around the centre, negative in case of clockwise, and 0 if the move was either 0 or 180 degrees.

You can further check if the move was above or below 90 degrees by computing the dot product of CentreSource and CentreDestination:

AorB = CentreSourceX * CentreSourceY + CentreDestinationX * CentreDestinationY

If AorB is positive then the move was below 90 degrees, if it is negative the move was above 90 degrees, and if it is 0 then the move was either exactly 90 degrees or it either started or ended in the point Centre.

Answer 3

How I would achieve this is to have a stack of 3 positions and use these to determine rotation of the object.

example:

double[] position = new double[2];

double[][] positions = new double[3][2];
void bool clockwise () {
     for (int i = 0; i < 2; i++) {
          positions[i + 1][0] = positions[i][0];
          positions[i + 1][1] = positions[i][1];
     }
     positions[0][0] = position[0];
     positions[0][1] = position[1];
     double[] averageOfEnds = new double[]{ (positions[0][0] + position[2][0]) / 2, (positions[0][1] + position[2][1]) / 2 };
     if (positions[2][0] < averageOfEnds[0] || positions[2][1] > averageOfEnds[1]) {
          return true;
     }
     return false;
}

this assumes you axes are like

+
|
|
|
- ------ +

Answer 4

Starting with the representation:

[x2, y2]' = R(th) * [x1 y1]';
R(th) = [cos(th) -sin(th)
         sin(th)  cos(th)]

Which is basically a rotation operation on a vector. x2 and y2 are the rotated position of x1 and y1. The idea is to get cos(th) and sin(th) in terms of x1,x2,y1 and y2 variables. In order not to fall in to wrong quadrant, atan2 is used with the values of sin(th) and cos(th) which boils down to:

  x1 = cos(th1); y1 = sin(th1);
  x2 = cos(th2); y2 = sin(th2);
  
  diff = atan2((x1*y2 - x2*y1), (y1*y2 + x1*x2)); # atan2(Yterm,Xterm) (Matlab notation 

Derivation:

Answer 5

The easiest solution would be to keep a reference to the object's previous and current or previous, current and extrapolated next positions and do a simple compare.