Is a point between two angles from another point? - math

Question

I am trying to determine if a point is between two angles coming from an original point (in order to determine whether or not to draw it with OpenGL, although that is irrelevant). What is the easiest way of doing this?

Answer 1

If absolute value of angles CAB + BAD = 45, then point is inside. If CAB + BAD > 45, then point is outside.

Answer 2

The 2-dimensional cross-product of 2 vectors u = (ux, uy), v = (vx, vy), is
u x v = ux * vy - uy * vx = |u| * |v| * sin(phi)
where phi is the angle between u to v (measured from u to v). The cross-product is positive if the angle is between 0 and 180 degrees.
Therefore
(B - A) x (D - A) > 0
if B lies in the half plane "left of" the vector from A to D, and thus
(B - A) x (D - A) > 0 and (B - A) x (C - A) < 0
exactly if B lies in the sector. If you want also to catch the case that B lies on the boundary of the sector, use >= resp. <=.
(Note: This works as long as the angle of the sector at A is less than 180 degrees, and can probably generalized for greater angles. Since your angle is 45 degrees, these formulas can be used.)

Answer 3

If you have point coordinates and no angles then use polar coordinates to convert [X,Y] -> [R,Theta] (Radius and Angle) relative to center (A in your figure) and then compare angles (thetas).
This code converts Point to PolarPoint relative to center point:
/// <summary>
/// Converts Point to polar coordinate point
/// </summary>
public static PolarPoint PointToPolarPoint(Point center, Point point)
{
double dist = Distance(center, point);
double theta = Math.Atan2(point.Y - center.Y, point.X - center.X);
if (theta < 0) // provide 0 - 2Pi "experience"
theta = 2 * Math.PI + theta;
return new PolarPoint(dist, theta);
}
/// <summary>
/// Calculates distance between two points
/// </summary>
public static int Distance(Point p1, Point p2)
{
return (int) Math.Sqrt
(
Math.Pow(p1.X - p2.X, 2) +
Math.Pow(p1.Y - p2.Y, 2)
);
}
The Polar Point Class in C# (That includes conversion back to Point):
/* NFX by ITAdapter
* Originated: 2006.01
* Revision: NFX 0.2 2009.02.10
*/
using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;
namespace NFX.Geometry
{
/// <summary>
/// Represents a point with polar coordinates
/// </summary>
public struct PolarPoint
{
#region .ctor
/// <summary>
/// Initializes polar coordinates
/// </summary>
public PolarPoint(double r, double theta)
{
m_R = r;
m_Theta = 0;
Theta = theta;
}
/// <summary>
/// Initializes polar coordinates from 2-d cartesian coordinates
/// </summary>
public PolarPoint(Point center, Point point)
{
this = CartesianUtils.PointToPolarPoint(center, point);
}
#endregion
#region Private Fields
private double m_R;
private double m_Theta;
#endregion
#region Properties
/// <summary>
/// R coordinate component which is coordinate distance from point of coordinates origin
/// </summary>
public double R
{
get { return m_R; }
set { m_R = value; }
}
/// <summary>
/// Angular azimuth coordinate component. An angle must be between 0 and 2Pi.
/// Note: Due to screen Y coordinate going from top to bottom (in usual orientation)
/// Theta angle may be reversed, that is - be positive in the lower half coordinate plane.
/// Please refer to:
/// http://en.wikipedia.org/wiki/Polar_coordinates
/// </summary>
public double Theta
{
get { return m_Theta; }
set
{
if ((value < 0) || (value > Math.PI * 2))
throw new NFXException("Invalid polar coordinates angle");
m_Theta = value;
}
}
/// <summary>
/// Returns polar coordinate converted to 2-d cartesian coordinates.
/// Coordinates are relative to 0,0 of the angle base vertex
/// </summary>
public Point Point
{
get
{
int x = (int)(m_R * Math.Cos(m_Theta));
int y = (int)(m_R * Math.Sin(m_Theta));
return new Point(x, y);
}
}
#endregion
#region Operators
public static bool operator ==(PolarPoint left, PolarPoint right)
{
return (left.m_R == right.m_R) && (left.m_Theta == right.m_Theta);
}
public static bool operator !=(PolarPoint left, PolarPoint right)
{
return (left.m_R != right.m_R) || (left.m_Theta != right.m_Theta);
}
#endregion
#region Object overrides
public override bool Equals(object obj)
{
if (obj is PolarPoint)
return this==((PolarPoint)obj);
else
return false;
}
public override int GetHashCode()
{
return m_R.GetHashCode() + m_Theta.GetHashCode();
}
public override string ToString()
{
return string.Format("Distance: {0}; Angle: {1} rad.", m_R, m_Theta);
}
#endregion
}
}

Answer 4

I eventually got it down to this function (where cameraYR is the angle that the point A is rotated at, cameraX is A.x, cameraY is A.y, x is B.x and y is B.y):
float cameraAngle = PI + cameraYR;
float angle = PI / 2 + atan2f(cameraY - y, cameraX - x);
float anglediff = fmodf(angle - cameraAngle + PI, PI * 2) - PI;
return (anglediff <= visibleAngle && anglediff >= -visibleAngle) || (anglediff <= -PI * 2 + visibleAngle && angleDiff >= -PI * 2 - visibleAngle);

Answer 5

I just answered a similar question. Find if an angle is between 2 angles (which also solves your problem). Check below
Is angle in between two angles
Hope it helps