CVector3d.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// Qt includes
#include <QtCore/QtGlobal>
 
// ACF includes
#include <imath/TVector.h>
#include <i2d/CVector2d.h>
#include <i3d/i3d.h>
 
 
namespace i3d
{
 
 
class CVector3d: public imath::TVector<3>
{
public:
       typedef imath::TVector<3> BaseClass;
 
       CVector3d();
       
       CVector3d(double x, double y, double z);
       
       CVector3d(const imath::TVector<3>& vector);
 
       CVector3d(const i2d::CVector2d& vector, double z = 0);
 
       double GetX() const;
       
       void SetX(double value);
       
       double GetY() const;
       
       void SetY(double value);
       
       double GetZ() const;
       
       void SetZ(double value);
 
       using BaseClass::GetTranslated;
       CVector3d GetTranslated(const imath::TVector<3>& vector);
 
       CVector3d GetCrossProduct(const imath::TVector<3>& vector) const;
 
       using BaseClass::GetNormalized;
       CVector3d GetNormalized(double length = 1.0) const;
 
       i2d::CVector2d GetPlaneCasted() const;
 
       bool Serialize(iser::IArchive& archive);
 
       CVector3d operator-() const;
 
       CVector3d operator+(const imath::TVector<3>& vector) const;
       CVector3d operator-(const imath::TVector<3>& vector) const;
       CVector3d operator*(double scalar) const;
       CVector3d operator/(double scalar) const;
 
       CVector3d& operator+=(const imath::TVector<3>& vector);
       CVector3d& operator-=(const imath::TVector<3>& vector);
       CVector3d& operator*=(double scalar);
       CVector3d& operator/=(double scalar);
};
 
 
// inline methods
 
inline CVector3d::CVector3d()
{
}
 
 
inline CVector3d::CVector3d(double x, double y, double z)
{
       operator[](0) = x;
       operator[](1) = y;
       operator[](2) = z;
}
 
 
inline CVector3d::CVector3d(const imath::TVector<3>& vector)
:      BaseClass(vector)
{
}
 
 
inline CVector3d::CVector3d(const i2d::CVector2d& vector, double z)
{
       operator[](0) = vector.GetX();
       operator[](1) = vector.GetY();
       operator[](2) = z;
}
 
 
inline double CVector3d::GetX() const
{
       return operator[](0);
}
 
 
inline void CVector3d::SetX(double value)
{
       operator[](0) = value;
}
 
 
inline double CVector3d::GetY() const
{
       return operator[](1);
}
 
 
inline void CVector3d::SetY(double value)
{
       operator[](1) = value;
}
 
 
inline double CVector3d::GetZ() const
{
       return operator[](2);
}
 
 
inline void CVector3d::SetZ(double value)
{
       operator[](2) = value;
}
 
 
inline CVector3d CVector3d::GetTranslated(const imath::TVector<3>& vector)
{
       return *this + vector;
}
 
 
inline i2d::CVector2d CVector3d::GetPlaneCasted() const
{
       return i2d::CVector2d(GetX(), GetY());
}
 
 
inline CVector3d CVector3d::operator-() const
{
       return CVector3d(-GetX(), -GetY(), -GetZ());
}
 
 
 
inline CVector3d CVector3d::operator+(const imath::TVector<3>& vector) const
{
       return CVector3d(GetX() + vector[0], GetY() + vector[1], GetZ() + vector[2]);
}
 
 
 
inline CVector3d CVector3d::operator-(const imath::TVector<3>& vector) const
{
       return CVector3d(GetX() - vector[0], GetY() - vector[1], GetZ() - vector[2]);
}
 
 
 
inline CVector3d CVector3d::operator*(double scalar) const
{
       return CVector3d(GetX() * scalar, GetY() * scalar, GetZ() * scalar);
}
 
 
 
inline CVector3d CVector3d::operator/(double scalar) const
{
       if (qAbs(scalar) < I_BIG_EPSILON){
              scalar = (scalar > 0)? I_BIG_EPSILON: -I_BIG_EPSILON;
       }
 
       return CVector3d(GetX() / scalar, GetY() / scalar, GetZ() / scalar);
}
 
 
 
inline CVector3d& CVector3d::operator+=(const imath::TVector<3>& vector)
{
       BaseClass::operator+=(vector);
 
       return *this;
}
 
 
 
inline CVector3d& CVector3d::operator-=(const imath::TVector<3>& vector)
{
       BaseClass::operator-=(vector);
 
       return *this;
}
 
 
inline CVector3d& CVector3d::operator*=(double scalar)
{
       BaseClass::operator*=(scalar);
 
       return *this;
}
 
 
inline CVector3d& CVector3d::operator/=(double scalar)
{
       BaseClass::operator/=(scalar);
 
       return *this;
}
 
 
} // namespace i3d