Vector3.h

// Copyright (C) Geom Software e.U, Bernhard Kornberger, Graz/Austria
//
// This file is part of the WOF software. WOF is commercial software.
// Users holding a license may use this file in accordance with the
// License Agreement.
//
// This software is provided AS IS with NO WARRANTY OF ANY KIND,
// INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE.
//
// Please contact the author if any conditions of this licensing are
// not clear to you.
//
// Author: Bernhard Kornberger, bkorn (at) geom.at
// http://www.geom.at
 
#pragma once
#include <iostream>
#include "wof_api_definitions.h" // for CLASS_DECLSPEC
 
namespace GEOM_WOF {
 
 
class CLASS_DECLSPEC Vector3
{
public:
 
Vector3(const double x_,const double y_,const double z_);
 
Vector3();
 
Vector3(const Vector3& v_);
 
bool isDegenerate() const;
 
void xyz(double& x_,double& y_,double& z_) const
{
    x_=valX;
    y_=valY;
    z_=valZ;
}
 
inline double x() const
{
    return valX;
}
 
 
inline double y() const
{
    return valY;
}
 
 
 
inline double z() const
{
    return valZ;
}
 
void set(const double x_,const double y_,const double z_);
 
void add(const Vector3& other)
{
    valX+=other.valX;
    valY+=other.valY;
    valZ+=other.valZ;
}
void sub(const Vector3& other)
{
    valX-=other.valX;
    valY-=other.valY;
    valZ-=other.valZ;
}
void div(double div)
{
    valX/=div;
    valY/=div;
    valZ/=div;
}
void mul(double mul)
{
    valX*=mul;
    valY*=mul;
    valZ*=mul;
}
 
double sqLength() const;
 
 
 
int getMaxAbsIndex() const;
 
 
double getMaxComponent() const
{
    if(valX>=valY && valX>=valZ) return valX;
    if(valY>=valZ) return valY;
        else return valZ;
}
double getMaxAbsComponent() const;
 
 
double getCartesian(int i) const;
 
bool isNV() const;
 
double length() const;
 
double operator*(const Vector3& other) const;
 
 
Vector3 operator*(double val) const;
 
Vector3 operator/(double val) const;
 
Vector3& operator=(const Vector3& other);
 
Vector3& operator+=(const Vector3& other);
Vector3& operator-=(const Vector3& other);
Vector3& operator/=(double div);
Vector3& operator*=(double mul);
 
 
 
protected:
 
double valX;
double valY;
double valZ;
};
 
 
 
 
// Free functions
inline std::ostream &operator<<(std::ostream &stream, const Vector3& vec)
{
    stream << "Vector3: "<<vec.x()<<", "<<vec.y()<<", "<<vec.z();
    return stream;
}
 
 
inline Vector3 crossProduct(const Vector3& vec0,const Vector3& vec1)
{
 
    double x=vec0.y() * vec1.z() - vec0.z() * vec1.y();
    double y=vec0.z() * vec1.x() - vec0.x() * vec1.z();
    double z=vec0.x() * vec1.y() - vec0.y() * vec1.x();
    return Vector3(x,y,z);
}
 
 
CLASS_DECLSPEC
Vector3 normalize(const Vector3& other);
 
 
inline Vector3 operator-(const Vector3& in)
{
    return Vector3(-in.x(),-in.y(),-in.z());
}
 
 
inline Vector3 operator*(double d,const Vector3& vec)
{
    return Vector3(d*vec.x(),d*vec.y(),d*vec.z());
}
 
 
inline Vector3 operator+(const Vector3& vec0,const Vector3& vec1)
{
    return Vector3(vec0.x()+vec1.x(), vec0.y()+vec1.y() , vec0.z()+vec1.z());
}
 
 
inline Vector3 operator-(const Vector3& vec0,const Vector3& vec1)
{
    return Vector3(vec0.x()-vec1.x(), vec0.y()-vec1.y() , vec0.z()-vec1.z());
}
 
 
} // (namespace)