You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
344 lines
12 KiB
C++
344 lines
12 KiB
C++
#include "Geometry.h"
|
|
|
|
|
|
/**
|
|
* This function returns the cosine of a given angle in degrees using the
|
|
* built-in cosine function that works with angles in radians.
|
|
*
|
|
* @param x an angle in degrees
|
|
* @return the cosine of the given angle
|
|
*/
|
|
float Cos(float x) {
|
|
return ( cos(x * M_PI / 180));
|
|
}
|
|
|
|
/**
|
|
* This function returns the sine of a given angle in degrees using the
|
|
* built-in sine function that works with angles in radians.
|
|
*
|
|
* @param x an angle in degrees
|
|
* @return the sine of the given angle
|
|
*/
|
|
float Sin(float x) {
|
|
return ( sin(x * M_PI / 180));
|
|
}
|
|
|
|
/**
|
|
* This function returns the principal value of the arc tangent of y/x in
|
|
* degrees using the signs of both arguments to determine the quadrant of the
|
|
* return value. For this the built-in 'atan2' function is used which returns
|
|
* this value in radians.
|
|
*
|
|
* @param x a float value
|
|
* @param y a float value
|
|
* @return the arc tangent of y/x in degrees taking the signs of x and y into
|
|
* account
|
|
*/
|
|
float ATan2(float x, float y) {
|
|
if (fabs(x) < EPSILON && fabs(y) < EPSILON)
|
|
return ( 0.0);
|
|
|
|
return ( atan2(x, y) * 180 / M_PI );
|
|
}
|
|
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
/******************* CLASS VECTOR ***********************************/
|
|
/************************************************************************/
|
|
|
|
/*! Constructor for the Vector class. Arguments x and y
|
|
denote the x- and y-coordinates of the new position.
|
|
\param x the x-coordinate of the new position
|
|
\param y the y-coordinate of the new position
|
|
\return the Vector corresponding to the given arguments */
|
|
Vector::Vector(float vx, float vy) : x(vx), y(vy) {}
|
|
|
|
/*! Overloaded version of unary minus operator for Vectors. It returns the
|
|
negative Vector, i.e. both the x- and y-coordinates are multiplied by
|
|
-1. The current Vector itself is left unchanged.
|
|
\return a negated version of the current Vector */
|
|
Vector Vector::operator-() const{
|
|
return ( Vector(-x, -y));
|
|
}
|
|
|
|
/*! Overloaded version of the binary plus operator for adding a given float
|
|
value to a Vector. The float value is added to both the x- and
|
|
y-coordinates of the current Vector. The current Vector itself is
|
|
left unchanged.
|
|
\param d a float value which has to be added to both the x- and
|
|
y-coordinates of the current Vector
|
|
\return the result of adding the given float value to the current
|
|
Vector */
|
|
Vector Vector::operator+(const float &d) const{
|
|
return ( Vector(x + d, y + d));
|
|
}
|
|
|
|
/*! Overloaded version of the binary plus operator for Vectors. It returns
|
|
the sum of the current Vector and the given Vector by adding their
|
|
x- and y-coordinates. The Vectors themselves are left unchanged.
|
|
\param p a Vector
|
|
\return the sum of the current Vector and the given Vector */
|
|
Vector Vector::operator+(const Vector &p) const{
|
|
return ( Vector(x + p.x, y + p.y));
|
|
}
|
|
|
|
/*! Overloaded version of the binary minus operator for subtracting a
|
|
given float value from a Vector. The float value is
|
|
subtracted from both the x- and y-coordinates of the current
|
|
Vector. The current Vector itself is left unchanged.
|
|
\param d a float value which has to be subtracted from both the x- and
|
|
y-coordinates of the current Vector
|
|
\return the result of subtracting the given float value from the current
|
|
Vector */
|
|
Vector Vector::operator-(const float &d) const{
|
|
return ( Vector(x - d, y - d));
|
|
}
|
|
|
|
/*! Overloaded version of the binary minus operator for
|
|
Vectors. It returns the difference between the current
|
|
Vector and the given Vector by subtracting their x- and
|
|
y-coordinates. The Vectors themselves are left unchanged.
|
|
|
|
\param p a Vector
|
|
\return the difference between the current Vector and the given
|
|
Vector */
|
|
Vector Vector::operator-(const Vector &p) const {
|
|
return ( Vector(x - p.x, y - p.y));
|
|
}
|
|
|
|
/*! Overloaded version of the multiplication operator for multiplying a
|
|
Vector by a given float value. Both the x- and y-coordinates of the
|
|
current Vector are multiplied by this value. The current Vector
|
|
itself is left unchanged.
|
|
\param d the multiplication factor
|
|
\return the result of multiplying the current Vector by the given
|
|
float value */
|
|
Vector Vector::operator*(const float &d) const{
|
|
return ( Vector(x * d, y * d));
|
|
}
|
|
|
|
/*! Overloaded version of the multiplication operator for
|
|
Vectors. It returns the product of the current Vector
|
|
and the given Vector by multiplying their x- and
|
|
y-coordinates. The Vectors themselves are left unchanged.
|
|
|
|
\param p a Vector
|
|
\return the product of the current Vector and the given Vector */
|
|
Vector Vector::operator*(const Vector &p) const{
|
|
return ( Vector(x * p.x, y * p.y));
|
|
}
|
|
|
|
/*! Overloaded version of the division operator for dividing a
|
|
Vector by a given float value. Both the x- and y-coordinates
|
|
of the current Vector are divided by this value. The current
|
|
Vector itself is left unchanged.
|
|
|
|
\param d the division factor
|
|
\return the result of dividing the current Vector by the given float
|
|
value */
|
|
Vector Vector::operator/(const float &d) const{
|
|
return ( Vector(x / d, y / d));
|
|
}
|
|
|
|
/*! Overloaded version of the division operator for Vectors. It
|
|
returns the quotient of the current Vector and the given
|
|
Vector by dividing their x- and y-coordinates. The
|
|
Vectors themselves are left unchanged.
|
|
|
|
\param p a Vector
|
|
\return the quotient of the current Vector and the given one */
|
|
Vector Vector::operator/(const Vector &p) const{
|
|
return ( Vector(x / p.x, y / p.y));
|
|
}
|
|
|
|
/*! Overloaded version of the assignment operator for assigning a given float
|
|
value to both the x- and y-coordinates of the current Vector. This
|
|
changes the current Vector itself.
|
|
\param d a float value which has to be assigned to both the x- and
|
|
y-coordinates of the current Vector */
|
|
void Vector::operator=(const float &d) {
|
|
x = d;
|
|
y = d;
|
|
}
|
|
|
|
/*! Overloaded version of the sum-assignment operator for Vectors. It
|
|
returns the sum of the current Vector and the given Vector by
|
|
adding their x- and y-coordinates. This changes the current Vector
|
|
itself.
|
|
\param p a Vector which has to be added to the current Vector */
|
|
void Vector::operator+=(const Vector &p) {
|
|
x += p.x;
|
|
y += p.y;
|
|
}
|
|
|
|
/*! Overloaded version of the sum-assignment operator for adding a given float
|
|
value to a Vector. The float value is added to both the x- and
|
|
y-coordinates of the current Vector. This changes the current
|
|
Vector itself.
|
|
\param d a float value which has to be added to both the x- and
|
|
y-coordinates of the current Vector */
|
|
void Vector::operator+=(const float &d) {
|
|
x += d;
|
|
y += d;
|
|
}
|
|
|
|
/*! Overloaded version of the difference-assignment operator for
|
|
Vectors. It returns the difference between the current
|
|
Vector and the given Vector by subtracting their x- and
|
|
y-coordinates. This changes the current Vector itself.
|
|
|
|
\param p a Vector which has to be subtracted from the current
|
|
Vector */
|
|
void Vector::operator-=(const Vector &p) {
|
|
x -= p.x;
|
|
y -= p.y;
|
|
}
|
|
|
|
/*! Overloaded version of the difference-assignment operator for
|
|
subtracting a given float value from a Vector. The float
|
|
value is subtracted from both the x- and y-coordinates of the
|
|
current Vector. This changes the current Vector itself.
|
|
|
|
\param d a float value which has to be subtracted from both the x- and
|
|
y-coordinates of the current Vector */
|
|
void Vector::operator-=(const float &d) {
|
|
x -= d;
|
|
y -= d;
|
|
}
|
|
|
|
/*! Overloaded version of the multiplication-assignment operator for
|
|
Vectors. It returns the product of the current Vector
|
|
and the given Vector by multiplying their x- and
|
|
y-coordinates. This changes the current Vector itself.
|
|
|
|
\param p a Vector by which the current Vector has to be
|
|
multiplied */
|
|
void Vector::operator*=(const Vector &p) {
|
|
x *= p.x;
|
|
y *= p.y;
|
|
}
|
|
|
|
/*! Overloaded version of the multiplication-assignment operator for
|
|
multiplying a Vector by a given float value. Both the x- and
|
|
y-coordinates of the current Vector are multiplied by this
|
|
value. This changes the current Vector itself.
|
|
|
|
\param d a float value by which both the x- and y-coordinates of the
|
|
current Vector have to be multiplied */
|
|
void Vector::operator*=(const float &d) {
|
|
x *= d;
|
|
y *= d;
|
|
}
|
|
|
|
/*! Overloaded version of the division-assignment operator for
|
|
Vectors. It returns the quotient of the current Vector
|
|
and the given Vector by dividing their x- and
|
|
y-coordinates. This changes the current Vector itself.
|
|
|
|
\param p a Vector by which the current Vector is divided */
|
|
void Vector::operator/=(const Vector &p) {
|
|
x /= p.x;
|
|
y /= p.y;
|
|
}
|
|
|
|
/*! Overloaded version of the division-assignment operator for
|
|
dividing a Vector by a given float value. Both the x- and
|
|
y-coordinates of the current Vector are divided by this
|
|
value. This changes the current Vector itself.
|
|
|
|
\param d a float value by which both the x- and y-coordinates of the
|
|
current Vector have to be divided */
|
|
void Vector::operator/=(const float &d) {
|
|
x /= d;
|
|
y /= d;
|
|
}
|
|
|
|
/*! Overloaded version of the inequality operator for Vectors. It
|
|
determines whether the current Vector is unequal to the given
|
|
Vector by comparing their x- and y-coordinates.
|
|
|
|
\param p a Vector
|
|
\return true when either the x- or y-coordinates of the given Vector
|
|
and the current Vector are different; false otherwise */
|
|
bool Vector::operator!=(const Vector &p) {
|
|
return ( (x != p.x) || (y != p.y));
|
|
}
|
|
|
|
/*! Overloaded version of the inequality operator for comparing a
|
|
Vector to a float value. It determines whether either the x-
|
|
or y-coordinate of the current Vector is unequal to the given
|
|
float value.
|
|
|
|
\param d a float value with which both the x- and y-coordinates of the
|
|
current Vector have to be compared.
|
|
\return true when either the x- or y-coordinate of the current Vector
|
|
is unequal to the given float value; false otherwise */
|
|
bool Vector::operator!=(const float &d) {
|
|
return ( (x != d) || (y != d));
|
|
}
|
|
|
|
/*! Overloaded version of the equality operator for Vectors. It
|
|
determines whether the current Vector is equal to the given
|
|
Vector by comparing their x- and y-coordinates.
|
|
|
|
\param p a Vector
|
|
\return true when both the x- and y-coordinates of the given
|
|
Vector and the current Vector are equal; false
|
|
otherwise */
|
|
bool Vector::operator==(const Vector &p) {
|
|
return ( (x == p.x) && (y == p.y));
|
|
}
|
|
|
|
/*! Overloaded version of the equality operator for comparing a
|
|
Vector to a float value. It determines whether both the x-
|
|
and y-coordinates of the current Vector are equal to the
|
|
given float value.
|
|
|
|
\param d a float value with which both the x- and y-coordinates of the
|
|
current Vector have to be compared.
|
|
\return true when both the x- and y-coordinates of the current Vector
|
|
are equal to the given float value; false otherwise */
|
|
bool Vector::operator==(const float &d) {
|
|
return ( (x == d) && (y == d));
|
|
}
|
|
|
|
|
|
/*! This method determines the distance between the current
|
|
Vector and a given Vector. This is equal to the
|
|
magnitude (length) of the vector connecting the two positions
|
|
which is the difference vector between them.
|
|
|
|
\param p a Vecposition
|
|
\return the distance between the current Vector and the given
|
|
Vector */
|
|
float Vector::getDistanceTo(const Vector p) {
|
|
return ( (*this -p).length());
|
|
}
|
|
|
|
|
|
/*! This method determines the magnitude (length) of the vector
|
|
corresponding with the current Vector using the formula of
|
|
Pythagoras.
|
|
|
|
\return the length of the vector corresponding with the current
|
|
Vector */
|
|
float Vector::length() const {
|
|
return ( sqrt(x * x + y * y));
|
|
}
|
|
|
|
float Vector::crossProduct(const Vector p) {
|
|
return this->x*p.y - this->y*p.x;
|
|
}
|
|
|
|
|
|
/**
|
|
* This methods returns the inner product of this vector with another
|
|
*
|
|
* @param other the other vector
|
|
* @return inner product
|
|
*/
|
|
float Vector::innerProduct(const Vector& other) const {
|
|
return x * other.x + y * other.y;
|
|
} |