-//\r
-// vector.cpp: Various structures used for 3 dimensional imaging\r
-//\r
-// by James L. Hammons\r
-// (C) 2006 Underground Software\r
-//\r
-// JLH = James L. Hammons <jlhamm@acm.org>\r
-//\r
-// WHO WHEN WHAT\r
-// --- ---------- ------------------------------------------------------------\r
-// JLH 09/19/2006 Created this file\r
-// JLH 03/22/2011 Moved implementation of constructor from header to here\r
-// JLH 04/02/2011 Fixed divide-by-zero bug in Unit(), added Angle() function\r
-//\r
-\r
-#include "vector.h"\r
-\r
-#include <math.h> // For sqrt()\r
-#include "mathconstants.h"\r
-\r
-\r
-// Vector implementation\r
-\r
-Vector::Vector(double xx/*= 0*/, double yy/*= 0*/, double zz/*= 0*/): x(xx), y(yy), z(zz)\r
-{\r
-}\r
-\r
-Vector Vector::operator=(Vector const v)\r
-{\r
- x = v.x, y = v.y, z = v.z;\r
-\r
- return *this;\r
-}\r
-\r
-Vector Vector::operator+(Vector const v)\r
-{\r
- return Vector(x + v.x, y + v.y, z + v.z);\r
-}\r
-\r
-Vector Vector::operator-(Vector const v)\r
-{\r
- return Vector(x - v.x, y - v.y, z - v.z);\r
-}\r
-\r
-// Unary negation\r
-\r
-Vector Vector::operator-(void)\r
-{\r
- return Vector(-x, -y, -z);\r
-}\r
-\r
-// Vector x constant\r
-\r
-Vector Vector::operator*(double const v)\r
-{\r
- return Vector(x * v, y * v, z * v);\r
-}\r
-\r
-// Vector x constant\r
-\r
-Vector Vector::operator*(float const v)\r
-{\r
- return Vector(x * v, y * v, z * v);\r
-}\r
-\r
-// Vector / constant\r
-\r
-Vector Vector::operator/(double const v)\r
-{\r
- return Vector(x / v, y / v, z / v);\r
-}\r
-\r
-// Vector / constant\r
-\r
-Vector Vector::operator/(float const v)\r
-{\r
- return Vector(x / v, y / v, z / v);\r
-}\r
-\r
-// Vector (cross) product\r
-\r
-Vector Vector::operator*(Vector const v)\r
-{\r
- // a x b = [a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1]\r
- return Vector((y * v.z) - (z * v.y), (z * v.x) - (x * v.z), (x * v.y) - (y * v.x));\r
-}\r
-\r
-// Dot product\r
-\r
-double Vector::Dot(Vector const v)\r
-{\r
- return (x * v.x) + (y * v.y) + (z * v.z);\r
-}\r
-\r
-\r
-// Vector x constant, self assigned\r
-\r
-Vector& Vector::operator*=(double const v)\r
-{\r
- x *= v, y *= v, z *= v;\r
-\r
- return *this;\r
-}\r
-\r
-// Vector / constant, self assigned\r
-\r
-Vector& Vector::operator/=(double const v)\r
-{\r
- x /= v, y /= v, z /= v;\r
-\r
- return *this;\r
-}\r
-\r
-// Vector + vector, self assigned\r
-\r
-Vector& Vector::operator+=(Vector const v)\r
-{\r
- x += v.x, y += v.y, z += v.z;\r
-\r
- return *this;\r
-}\r
-\r
-// Vector + constant, self assigned\r
-\r
-Vector& Vector::operator+=(double const v)\r
-{\r
- x += v, y += v, z += v;\r
-\r
- return *this;\r
-}\r
-\r
-\r
-Vector Vector::Unit(void)\r
-{\r
- double mag = Magnitude();\r
-\r
- // If the magnitude of the vector is zero, then the Unit vector is undefined...\r
- if (mag == 0)\r
- return Vector(0, 0, 0);\r
-\r
- return Vector(x / mag, y / mag, z / mag);\r
-}\r
-\r
-double Vector::Magnitude(void)\r
-{\r
- return sqrt(x * x + y * y + z * z);\r
-}\r
-\r
-double Vector::Angle(void)\r
-{\r
- // acos returns a value between zero and PI, which means we don't know which\r
- // quadrant the angle is in... Though, if the y-coordinate of the vector is\r
- // negative, that means that the angle is in quadrants III - IV.\r
- double rawAngle = acos(Unit().x);\r
- double correctedAngle = (y < 0 ? (2.0 * PI) - rawAngle : rawAngle);\r
-\r
- return correctedAngle;\r
-}\r
-\r
-bool Vector::isZero(double epsilon/*= 1e-6*/)\r
-{\r
- return (fabs(x) < epsilon && fabs(y) < epsilon && fabs(z) < epsilon ? true : false);\r
-}\r
-\r
-\r
-// Class methods\r
-\r
-double Vector::Dot(Vector v1, Vector v2)\r
-{\r
- return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);\r
-}\r
+//
+// vector.cpp: Various structures used for 3 dimensional imaging
+//
+// by James Hammons
+// (C) 2006 Underground Software
+//
+// JLH = James L. Hammons <jlhamm@acm.org>
+//
+// WHO WHEN WHAT
+// --- ---------- ------------------------------------------------------------
+// JLH 09/19/2006 Created this file
+// JLH 03/22/2011 Moved implementation of constructor from header to here
+// JLH 04/02/2011 Fixed divide-by-zero bug in Unit(), added Angle() function
+// JLH 08/04/2013 Added Parameter() function
+//
+
+#include "vector.h"
+
+#include <math.h> // For sqrt()
+#include "mathconstants.h"
+
+// Vector implementation
+
+Vector::Vector(double xx/*= 0*/, double yy/*= 0*/, double zz/*= 0*/): x(xx), y(yy), z(zz)
+{
+}
+
+
+Vector::Vector(Vector tail, Vector head): x(head.x - tail.x), y(head.y - tail.y), z(head.z - tail.z)
+{
+}
+
+
+// Create vector from angle + length (2D; z is set to zero)
+void Vector::SetAngleAndLength(double angle, double length)
+{
+ x = cos(angle) * length;
+ y = sin(angle) * length;
+ z = 0;
+}
+
+
+Vector Vector::operator=(Vector const v)
+{
+ x = v.x, y = v.y, z = v.z;
+
+ return *this;
+}
+
+
+Vector Vector::operator+(Vector const v)
+{
+ return Vector(x + v.x, y + v.y, z + v.z);
+}
+
+
+Vector Vector::operator-(Vector const v)
+{
+ return Vector(x - v.x, y - v.y, z - v.z);
+}
+
+
+// Unary negation
+
+Vector Vector::operator-(void)
+{
+ return Vector(-x, -y, -z);
+}
+
+
+// Vector x constant
+
+Vector Vector::operator*(double const v)
+{
+ return Vector(x * v, y * v, z * v);
+}
+
+
+// Vector x constant
+
+Vector Vector::operator*(float const v)
+{
+ return Vector(x * v, y * v, z * v);
+}
+
+
+// Vector / constant
+
+Vector Vector::operator/(double const v)
+{
+ return Vector(x / v, y / v, z / v);
+}
+
+
+// Vector / constant
+
+Vector Vector::operator/(float const v)
+{
+ return Vector(x / v, y / v, z / v);
+}
+
+
+// Vector (cross) product
+
+Vector Vector::operator*(Vector const v)
+{
+ // a x b = [a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1]
+ return Vector((y * v.z) - (z * v.y), (z * v.x) - (x * v.z), (x * v.y) - (y * v.x));
+}
+
+
+// Dot product
+
+double Vector::Dot(Vector const v)
+{
+ return (x * v.x) + (y * v.y) + (z * v.z);
+}
+
+
+// Vector x constant, self assigned
+
+Vector& Vector::operator*=(double const v)
+{
+ x *= v, y *= v, z *= v;
+
+ return *this;
+}
+
+
+// Vector / constant, self assigned
+
+Vector& Vector::operator/=(double const v)
+{
+ x /= v, y /= v, z /= v;
+
+ return *this;
+}
+
+// Vector + vector, self assigned
+
+Vector& Vector::operator+=(Vector const v)
+{
+ x += v.x, y += v.y, z += v.z;
+
+ return *this;
+}
+
+
+// Vector + constant, self assigned
+
+Vector& Vector::operator+=(double const v)
+{
+ x += v, y += v, z += v;
+
+ return *this;
+}
+
+
+// Vector - vector, self assigned
+
+Vector& Vector::operator-=(Vector const v)
+{
+ x -= v.x, y -= v.y, z -= v.z;
+
+ return *this;
+}
+
+
+// Vector - constant, self assigned
+
+Vector& Vector::operator-=(double const v)
+{
+ x -= v, y -= v, z -= v;
+
+ return *this;
+}
+
+
+// Check for equality
+bool Vector::operator==(Vector const v)
+{
+ return (x == v.x && y == v.y && z == v.z ? true : false);
+}
+
+
+// Check for inequality
+bool Vector::operator!=(Vector const v)
+{
+ return (x != v.x || y != v.y || z != v.z ? true : false);
+}
+
+
+Vector Vector::Unit(void)
+{
+ double mag = Magnitude();
+
+ // If the magnitude of the vector is zero, then the Unit vector is undefined...
+ if (mag == 0)
+ return Vector(0, 0, 0);
+
+ return Vector(x / mag, y / mag, z / mag);
+}
+
+
+double Vector::Magnitude(void)
+{
+ return sqrt(x * x + y * y + z * z);
+}
+
+
+double Vector::Angle(void)
+{
+ // acos returns a value between zero and PI, which means we don't know which
+ // quadrant the angle is in... Though, if the y-coordinate of the vector is
+ // negative, that means that the angle is in quadrants III - IV.
+ double rawAngle = acos(Unit().x);
+ double correctedAngle = (y < 0 ? (2.0 * PI) - rawAngle : rawAngle);
+
+ return correctedAngle;
+}
+
+
+bool Vector::isZero(double epsilon/*= 1e-6*/)
+{
+ return (fabs(x) < epsilon && fabs(y) < epsilon && fabs(z) < epsilon ? true : false);
+}
+
+
+// Class methods
+
+/*static*/ double Vector::Dot(Vector v1, Vector v2)
+{
+ return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z);
+}
+
+
+/*static*/ double Vector::Magnitude(Vector v1, Vector v2)
+{
+ double xx = v1.x - v2.x;
+ double yy = v1.y - v2.y;
+ double zz = v1.z - v2.z;
+ return sqrt((xx * xx) + (yy * yy) + (zz * zz));
+}
+
+
+//
+// Convenience function
+//
+/*static*/ double Vector::Angle(Point p1, Point p2)
+{
+ return Vector(p1, p2).Angle();
+}
+
+
+// Returns the parameter of a point in space to this vector. If the parameter
+// is between 0 and 1, the normal of the vector to the point is on the vector.
+// Note: v1 is the tail, v2 is the head of the line (vector).
+/*static*/ double Vector::Parameter(Vector tail, Vector head, Vector p)
+{
+ // Geometric interpretation:
+ // The parameterized point on the vector lineSegment is where the normal of
+ // the lineSegment to the point intersects lineSegment. If the pp < 0, then
+ // the perpendicular lies beyond the 1st endpoint. If pp > 1, then the
+ // perpendicular lies beyond the 2nd endpoint.
+
+ Vector lineSegment = head - tail;
+ double magnitude = lineSegment.Magnitude();
+ Vector pointSegment = p - tail;
+ double t = lineSegment.Dot(pointSegment) / (magnitude * magnitude);
+ return t;
+}
+
+
+// Return the 2D normal to the linesegment formed by the passed in points.
+// The normal thus calculated should rotate anti-clockwise.
+/*static*/ Vector Vector::Normal(Vector tail, Vector head)
+{
+ Vector v = (head - tail).Unit();
+ return Vector(-v.y, v.x);
+}
+
+
+/*static*/ double Vector::AngleBetween(Vector a, Vector b)
+{
+ // This is done using the following formula:
+ // (a . b) = ||a|| ||b|| cos(theta)
+ // However, have to check for two degenerate cases, where a = cb:
+ // 1, if c > 0, theta = 0; 2, if c < 0, theta = 180°.
+ // Also, the vectors a & b have to be non-zero.
+ // Also, have to check using an epsilon because acos will not return an
+ // exact value if the vectors are orthogonal
+ if (a.isZero() || b.isZero())
+ return 0;
+
+ return acos(a.Dot(b) / (a.Magnitude() * b.Magnitude()));
+}
+
projects / architektonas / blobdiff