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_):valX(x_),valY(y_),valZ(z_)
{}
 
Vector3():valX(0),valY(0),valZ(0)
{}
 
Vector3(const Vector3& v_):valX(v_.x()),valY(v_.y()),valZ(v_.z())
{}
 
bool isDegenerate() const
{
    return (valX==0 && valY==0 && valZ==0);
}
 
bool isNV() const
{
    double sq(valX*valX+valY*valY+valZ*valZ);
    double err(1.0-sq);
    return (err>-.03 && err<.03);
}
 
 
void xyz(double& x_,double& y_,double& z_) const
{
    x_=valX;
    y_=valY;
    z_=valZ;
}
void reset()
{
    valX=0;
    valY=0;
    valZ=0;
}
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;
 
 
double length() const;
 
double operator*(const Vector3& other) const;
 
 
 
 
Vector3 operator*(double val) const;
 
Vector3 operator/(double val) const;
 
Vector3& operator=(const Vector3& other)
{
    valX=other.valX;
    valY=other.valY;
    valZ=other.valZ;
    return *this;
}
 
void addOwnCoords(double& x,double& y,double& z) const
{
    x+=valX;
    y+=valY;
    z+=valZ;
}
 
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);
// Free function
inline Vector3 normalize(const Vector3& other)
{
    double len(other.length());
    if(len>0)
    {
        return Vector3(other.x()/len,other.y()/len,other.z()/len);
    }
    else
    {
#ifdef DEVMODE
        std::cerr<<"\n\n** warning: normalize(const Vector3& other), Null length vector! Will segfault now"<<std::endl;
        std::cerr<<"other.x()="<<other.x()<<std::endl;
        std::cerr<<"other.y()="<<other.y()<<std::endl;
        std::cerr<<"other.z()="<<other.z()<<std::endl;
        if(other.x()==0.0) std::cerr<<"other.x()==0.0"<<std::endl;
        if(other.y()==0.0) std::cerr<<"other.y()==0.0"<<std::endl;
        if(other.z()==0.0) std::cerr<<"other.z()==0.0"<<std::endl;
        // Deliberate segfault (to get a quick backtrace)
        int* i(NULL);
        ++*i;
#endif
        return Vector3(0,0,0);
    }
}
 
 
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)