Minor fixes to polygon adding, added Tau constants to math package.

[ttedit] / src / vector.cpp

#if 0

//
// VECTOR.H - vector class definition
//
// by James L. Hammons
// (C) 2004 Underground Software
//
// JLH = James L. Hammons <jlhamm@acm.org>
//
// 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 <math.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/*= 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 <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
//

#include "vector.h"

#include <math.h>                                                               // For sqrt()
#include "mathconstants.h"


// 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 ? TAU - rawAngle : rawAngle);

        return correctedAngle;
}


//
// Returns the smallest angle between these two vectors
//
double Vector::Angle(Vector v)
{
// seems that something relies on this bad behavior... :-P
#if 0
        // Discard the sign from the subtraction
        double angle = fabs(Angle() - v.Angle());

        // Return the complementary angle if greater than 180⁰
        return (angle <= 180.0 ? angle : 360.0 - angle);
#else
        return Angle() - v.Angle();
#endif
}


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