X-Git-Url: http://shamusworld.gotdns.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fvector.cpp;h=1f4c29cc5ae5b69eedd639efaa5fa0a6bc56883c;hb=3ef71393f70213eb53db552605ae3c93f1303ee9;hp=fc008f3e542d9b39f214f69ca7229b365ce70728;hpb=6d13a5166688e470590692eb91c3915ab332fe36;p=ttedit diff --git a/src/vector.cpp b/src/vector.cpp index fc008f3..1f4c29c 100755 --- a/src/vector.cpp +++ b/src/vector.cpp @@ -1,141 +1,398 @@ -// -// VECTOR.H - vector class definition -// -// by James L. Hammons -// (C) 2004 Underground Software -// -// JLH = James L. Hammons -// -// Who When What -// --- ---------- ------------------------------------------------------------- -// JLH ??/??/2003 Created original implementation -// JLH 05/14/2004 Separated header from implementation, added operator- -// function -// JLH 05/15/2004 Added operator+ function -// - -#include -#include "vector.h" - -vector::vector(double a1/*= 0.0*/, double b1/*= 0.0*/, double c1/*= 0.0*/, - double a2/*= 0.0*/, double b2/*= 0.0*/, double c2/*= 0.0*/): - x(a1 - a2), y(b1 - b2), z(c1 - c2) -{ -} - -vector::vector(const vector &v1, const vector &v2): - x(v1.x - v2.x), y(v1.y - v2.y), z(v1.z - v2.z) -{ -} - -vector& vector::operator=(const vector &v) -{ - x = v.x, y = v.y, z = v.z; - return *this; -} - -bool vector::operator==(const vector &v) -{ - if ((x == v.x) && (y == v.y) && (z == v.z)) - return true; - - return false; -} - -void vector::unitize(void) -{ - double dist = sqrt(x*x + y*y + z*z); - - if (dist != 0.0) - x /= dist, y /= dist, z /= dist; - - if (x == -0.0) - x = +0.0; - - if (y == -0.0) - y = +0.0; - - if (z == -0.0) - z = +0.0; -} - -vector vector::operator*(const vector &v) // Cross product: "this" x "v" -{ - vector r; - - r.x = (y * v.z) - (v.y * z); - r.y = -((x * v.z) - (v.x * z)); - r.z = (x * v.y) - (v.x * y); - - return r; -} - -vector vector::operator+(const vector &v) -{ - return vector(x + v.x, y + v.y, z + v.z); -} - -vector vector::operator-(const vector &v) -{ - return vector(x, y, z, v.x, v.y, v.z); -} - -double vector::dot(const vector &v1, const vector &v2) -{ - return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; -} - -double vector::dot(const vector &v) -{ - return x * v.x + y * v.y + z * v.z; -} - -double vector::distance(const vector &v) // Pythagoras extended to 3 dimensions -{ - double a = x - v.x, b = y - v.y, c = z - v.z; - - return sqrt(a * a + b * b + c * c); -} - -double vector::length(void) -{ - return sqrt(x * x + y * y + z * z); -} - -void vector::operator*=(const double &d) -{ - x *= d, y *= d, z *= d; -} - -void vector::operator/=(const double &d) -{ - if (d != 0.0) - x /= d, y /= d, z /= d; -} - -void vector::operator+=(const vector &v) -{ - x += v.x, y += v.y, z += v.z; -} - -void vector::operator-=(const vector &v) -{ - x -= v.x, y -= v.y, z -= v.z; -} - -vector vector::operator*(const double &d) // Scale vector by amount -{ - return vector(x * d, y * d, z * d); -} - -void vector::zero(const double epsilon) -{ - if (fabs(x) < epsilon) - x = 0.0; - - if (fabs(y) < epsilon) - y = 0.0; - - if (fabs(z) < epsilon) - z = 0.0; -} +#if 0 + +// +// VECTOR.H - vector class definition +// +// by James L. Hammons +// (C) 2004 Underground Software +// +// JLH = James L. Hammons +// +// Who When What +// --- ---------- ------------------------------------------------------------- +// JLH ??/??/2003 Created original implementation +// JLH 05/14/2004 Separated header from implementation, added operator- +// function +// JLH 05/15/2004 Added operator+ function +// + +#include "vector.h" +#include + +vector::vector(double a1/*= 0.0*/, double b1/*= 0.0*/, double c1/*= 0.0*/, + double a2/*= 0.0*/, double b2/*= 0.0*/, double c2/*= 0.0*/): + x(a1 - a2), y(b1 - b2), z(c1 - c2) +{ +} + +vector::vector(const vector &v1, const vector &v2): + x(v1.x - v2.x), y(v1.y - v2.y), z(v1.z - v2.z) +{ +} + +vector& vector::operator=(const vector &v) +{ + x = v.x, y = v.y, z = v.z; + return *this; +} + +bool vector::operator==(const vector &v) +{ + if ((x == v.x) && (y == v.y) && (z == v.z)) + return true; + + return false; +} + +void vector::unitize(void) +{ + double dist = sqrt(x*x + y*y + z*z); + + if (dist != 0.0) + x /= dist, y /= dist, z /= dist; + + if (x == -0.0) + x = +0.0; + + if (y == -0.0) + y = +0.0; + + if (z == -0.0) + z = +0.0; +} + +vector vector::operator*(const vector &v) // Cross product: "this" x "v" +{ + vector r; + + r.x = (y * v.z) - (v.y * z); + r.y = -((x * v.z) - (v.x * z)); + r.z = (x * v.y) - (v.x * y); + + return r; +} + +vector vector::operator+(const vector &v) +{ + return vector(x + v.x, y + v.y, z + v.z); +} + +vector vector::operator-(const vector &v) +{ + return vector(x, y, z, v.x, v.y, v.z); +} + +double vector::dot(const vector &v1, const vector &v2) +{ + return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z; +} + +double vector::dot(const vector &v) +{ + return x * v.x + y * v.y + z * v.z; +} + +double vector::distance(const vector &v) // Pythagoras extended to 3 dimensions +{ + double a = x - v.x, b = y - v.y, c = z - v.z; + + return sqrt(a * a + b * b + c * c); +} + +double vector::length(void) +{ + return sqrt(x * x + y * y + z * z); +} + +void vector::operator*=(const double &d) +{ + x *= d, y *= d, z *= d; +} + +void vector::operator/=(const double &d) +{ + if (d != 0.0) + x /= d, y /= d, z /= d; +} + +void vector::operator+=(const vector &v) +{ + x += v.x, y += v.y, z += v.z; +} + +void vector::operator-=(const vector &v) +{ + x -= v.x, y -= v.y, z -= v.z; +} + +vector vector::operator*(const double &d) // Scale vector by amount +{ + return vector(x * d, y * d, z * d); +} + +void vector::zero(const double epsilon/*= 1.0e-6*/) +{ + if (fabs(x) < epsilon) + x = 0.0; + + if (fabs(y) < epsilon) + y = 0.0; + + if (fabs(z) < epsilon) + z = 0.0; +} + +#else + +// +// vector.cpp: Various structures used for 3 dimensional imaging +// +// by James Hammons +// (C) 2006 Underground Software +// +// JLH = James L. Hammons +// +// 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 +// + +#include "vector.h" + +#include // For sqrt() +//#include "mathconstants.h" + +#define PI 3.14159265358979323846264338327 +#define RADIANS_TO_DEGREES (180.0 / PI) +#define DEGREES_TO_RADIANS (PI / 180.0) + + +// Vector implementation + +Vector::Vector(double x1/*= 0*/, double y1/*= 0*/, double z1/*= 0*/, + double x2/*= 0*/, double y2/*= 0*/, double z2/*= 0*/): + x(x1 - x2), y(y1 - y2), z(z1 - z2) +{ +} + + +Vector::Vector(Vector head, Vector tail): x(head.x - tail.x), y(head.y - tail.y), z(head.z - tail.z) +{ +} + + +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; +} + + +// +// Angle between these two vectors +// +double Vector::Angle(Vector v) +{ + return Angle() - v.Angle(); +} + + +bool Vector::isZero(double epsilon/*= 1e-6*/) +{ + return (fabs(x) < epsilon && fabs(y) < epsilon && fabs(z) < epsilon ? true : false); +} + + +// Class methods + +double Vector::Dot(Vector v1, Vector v2) +{ + return (v1.x * v2.x) + (v1.y * v2.y) + (v1.z * v2.z); +} + + +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); +} + +#endif