Angle of a line with relative to another line - c++

Question

Although this is an easy question, I might be thinking in a wrong way so could not find the correct way.
Imagine I have a line, say Line 1, starting from m_StartPoint1 and ending at m_EndPoint1. I want to draw another line, say Line 2, starting from m_EndPoint1 and having a constant angle of alpha with Line 1. Basically my goal is to draw an arrow.
I am using the following code to calculate the x,y coordinates of Line 2.
const float ARROW_ANGLE=-PI/8.0;
wxPoint p;
p.x=m_EndPoint.x+ARROW_LENGTH*sin(ARROW_ANGLE);
p.y=m_EndPoint.y+ARROW_LENGTH*cos(ARROW_ANGLE);
m_ArrowHead1=new CLine(m_EndPoint,p,color,PenWidth); //Draws a line from m_EndPoint to p
This calculation works well when the angle of Line 1 is less than 90 (in degrees). However, when the angle of line 1 changes the arrow does not show correctly. Basically the user should be able to draw Line 1 as he/she wants and arrow line should show correctly regardless of the angle of Line 1.
I have expressed line 1 as vector and got its angle through the following code:
class CVector2D
{
wxPoint m_StartPoint, m_EndPoint;
public:
CVector2D():m_StartPoint(),m_EndPoint() {}
CVector2D(wxPoint p1, wxPoint p2):m_StartPoint(p1),m_EndPoint(p2) {}
float GetSlope(void)
{
return float(m_EndPoint.y-m_StartPoint.y)/float(m_EndPoint.x-m_StartPoint.x);
}
float GetSlopeAngleInRadians()
{
/*Will return the angle of the vector in radians
* The angle is the counterclockwise rotation therefore it is negative
*/
float slope=GetSlope();
float InRadians=atan2(float(m_EndPoint.y-m_StartPoint.y),float(m_EndPoint.x-m_StartPoint.x));
if(InRadians<=0) return InRadians;
return -(2*PI-InRadians);
}
};
And then I tried to calculate with the following code:
CVector2D vector(m_StartPoint,m_EndPoint);
float vector_angle=vector.GetSlopeAngleInRadians();
float total_angle=vector_angle+ARROW_ANGLE;
wxPoint p;
p.x=m_EndPoint.x+ARROW_LENGTH*cos(total_angle);
p.y=m_EndPoint.y+ARROW_LENGTH*sin(total_angle);
m_ArrowHead1=new CLine(m_EndPoint,p,color,PenWidth);
However, this code did not work either. Any ideas will be appreciated.

Answer 1

The difficulty here is perhaps more about math than programming. You need however to be careful to handle the singularities.
How do you guard against division by zero at 90 degrees in:
float GetSlope(void)
{
return float(m_EndPoint.y-m_StartPoint.y)/float(m_EndPoint.x-m_StartPoint.x);
}
I recommend dot product based math, see:
How to find out if the angle between two vectors is external or internal?
PS
Why not use double instead of float?

Answer 2

I think, you are overcomplicating slightly. std::atan2 returns an angle within [-PI,PI] range already. All you have to do is to add correctly the delta angle. If I understood your problem correctly, you are looking for something like this (code on ideone.com):
#include <iostream>
#include <cmath>
namespace so
{
struct _point_2d_
{
float x{};
float y{};
};
struct _line_2d_
{
_point_2d_ start{};
_point_2d_ end{};
};
_line_2d_ create_arrow(float _angle_delta, float _length, _line_2d_ const & _base)
{
float angle_arrow_{std::atan2(_base.end.y - _base.start.y, _base.end.x - _base.start.x) + _angle_delta};
_line_2d_ line_arrow_{};
line_arrow_.start.x = _base.end.x;
line_arrow_.start.y = _base.end.y;
line_arrow_.end.x = line_arrow_.start.x + _length * std::cos(angle_arrow_);
line_arrow_.end.y = line_arrow_.start.y + _length * std::sin(angle_arrow_);
return (line_arrow_);
}
}
int main()
{
so::_line_2d_ base_{};
float angle_delta_{0.5236f};
float length_{1.0f};
base_.start.x = 1.0f;
base_.start.y = 1.0f;
base_.end.x = -1.0f;
base_.end.y = 1.0f;
so::_line_2d_ arrow_counter{so::create_arrow(3.1416f - angle_delta_, length_, base_)};
std::cout << "(" << arrow_counter.start.x << ", " << arrow_counter.start.y << ") - (" << arrow_counter.end.x << ", "
<< arrow_counter.end.y << ")" << std::endl;
so::_line_2d_ arrow_clock{so::create_arrow(-3.1416f + angle_delta_, length_, base_)};
std::cout << "(" << arrow_clock.start.x << ", " << arrow_clock.start.y << ") - (" << arrow_clock.end.x << ", "
<< arrow_clock.end.y << ")" << std::endl;
return (0);
}
Program output:
(-1, 1) - (-0.133971, 0.500006)
(-1, 1) - (-0.133972, 1.49999)

Answer 3

first, to draw a line of length ARROW_LENGTH from m_EndPoint to p you should use this (I think there is an error in your formula):
wxPoint p;
p.x=m_EndPoint.x+ARROW_LENGTH*cos(ARROW_ANGLE);
p.y=m_EndPoint.y+ARROW_LENGTH*sin(ARROW_ANGLE);
m_ArrowHead1=new CLine(m_EndPoint,p,color,PenWidth);
Then to draw a line with relative angle add the angle
new_angle = ARROW_ANGLE + ANGLE_BETWEEN_LINES
But:
be careful to take into consideration periodicity of trigonometric functions. If you get a slope as you said:
float GetSlope(void)
{
return float(m_EndPoint.y-m_StartPoint.y)/float(m_EndPoint.x-m_StartPoint.x);
}
remember that this is tan(angle) and tangent function is not an injection so here you have lost information whether your angle is i.e. in first or third quadrant. To use described formula for drawing a line you have to get correct value of angle from this (first or third quarter argument) - you can use
std::atan2()
Compute arc tangent with two parameters. Returns the principal value of
the arc tangent of y/x, expressed in radians. Notice that despite the
sign ambiguity, this function determines with certainty in which
quadrant the angle falls. It takes a fractional argument. To compute the value, the function takes into account the sign of both arguments in order to determine the quadrant.
and then you can use this value to calculate new_angle. So it might looks like this:
float GetSlope(void)
{
return std::atan2(m_EndPoint.y-m_StartPoint.y, m_EndPoint.x-m_StartPoint.x);
}
wxPoint p;
p.x=m_EndPoint.x+ARROW_LENGTH*cos(GetSlope()+ANGLE_BETWEEN_LINES);
p.y=m_EndPoint.y+ARROW_LENGTH*sin(GetSlope()+ANGLE_BETWEEN_LINES);
m_ArrowHead1=new CLine(m_EndPoint,p,color,PenWidth);
now, because of atan2 you don't have to handle PI/2 and 3/2PI case individually.

Answer 4

I have solved the question using the following code:
CVector2D vector(m_StartPoint,m_EndPoint);
float vector_angle=vector.GetSlopeAngleInRadians();
float total_angle=vector_angle+ARROW_ANGLE; //ARROW_ANGLE=-PI/8, so is negative too
wxPoint p;
p.x=m_EndPoint.x-ARROW_LENGTH*cos(total_angle);
p.y=m_EndPoint.y-ARROW_LENGTH*sin(total_angle);
m_ArrowHead1=new CLine(m_EndPoint,p,color,PenWidth);
total_angle=vector_angle-ARROW_ANGLE;
p.x=m_EndPoint.x-ARROW_LENGTH*cos(total_angle);
p.y=m_EndPoint.y-ARROW_LENGTH*sin(total_angle);
m_ArrowHead2=new CLine(m_EndPoint,p,color,PenWidth);
It now draws a perfect arrow regardless of the way I draw it. Thanks all for your ideas.