CVector2d.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>
#if QT_VERSION >= 0x050000
#include <QtCore/QtMath>
#else
#include <QtCore/qmath.h>
#endif
#include <QtCore/QPointF>
 
// ACF includes
#include <istd/CIndex2d.h>
#include <imath/TVector.h>
 
#include <i2d/i2d.h>
 
 
namespace i2d
{
 
 
class CVector2d: public imath::TVector<2>
{
public:
       typedef imath::TVector<2> BaseClass;
 
       CVector2d();
       
       CVector2d(double x, double y);
       
       CVector2d(const istd::CIndex2d& index);
 
       CVector2d(const QPointF& point);
 
       CVector2d(const imath::TVector<2>& vector);
 
       double GetX() const;
       void SetX(double x);
       double GetY() const;
       void SetY(double y);
 
       void Init(double angle, double length = 1.0);
 
       using BaseClass::GetTranslated;
       CVector2d GetTranslated(const imath::TVector<2>& vector);
       CVector2d GetHorizontalTranslated(double offsetX) const;
       CVector2d GetVerticalTranslated(double offsetY) const;
 
       double GetCrossProductZ(const imath::TVector<2>& vector) const;
 
       double GetDotProduct(const CVector2d& vector) const;
       double GetAngle() const;
       CVector2d GetOrthogonal() const;
 
       istd::CIndex2d ToIndex2d() const;
 
       using BaseClass::GetNormalized;
       CVector2d GetNormalized(double length = 1.0) const;
 
       bool Serialize(iser::IArchive& archive);
 
       CVector2d operator-() const;
 
       CVector2d operator+(const imath::TVector<2>& vector) const;
       CVector2d operator-(const imath::TVector<2>& vector) const;
       CVector2d operator*(double scalar) const;
       CVector2d operator/(double scalar) const;
 
       CVector2d& operator+=(const imath::TVector<2>& vector);
       CVector2d& operator-=(const imath::TVector<2>& vector);
       CVector2d& operator*=(double scalar);
       CVector2d& operator/=(double scalar);
 
       operator QPointF() const;
 
       static const CVector2d& GetZero();
};
 
 
// inline methods
 
inline CVector2d::CVector2d(const QPointF& point)
{
       operator[](0) = point.x();
       operator[](1) = point.y();
}
 
 
inline CVector2d::CVector2d()
{
}
 
 
inline CVector2d::CVector2d(double x, double y)
{
       operator[](0) = x;
       operator[](1) = y;
}
 
 
inline CVector2d::CVector2d(const imath::TVector<2>& vector)
:      BaseClass(vector)
{
}
 
 
inline CVector2d::CVector2d(const istd::CIndex2d& index)
{
       operator[](0) = index.GetX();
       operator[](1) = index.GetY();
}
 
 
inline double CVector2d::GetX() const
{
       return operator[](0);
}
 
 
inline void CVector2d::SetX(double x)
{
       operator[](0) = x;
}
 
 
inline double CVector2d::GetY() const
{
       return operator[](1);
}
 
 
inline void CVector2d::SetY(double y)
{
       operator[](1) = y;
}
 
 
inline CVector2d CVector2d::GetTranslated(const imath::TVector<2>& vector)
{
       return *this + vector;
}
 
 
inline CVector2d CVector2d::GetHorizontalTranslated(double offsetX) const
{
       return CVector2d(GetX() + offsetX, GetY());
}
 
 
inline CVector2d CVector2d::GetVerticalTranslated(double offsetY) const
{
       return CVector2d(GetX(), GetY() + offsetY);
}
 
 
inline double CVector2d::GetCrossProductZ(const imath::TVector<2>& vector) const
{
       return GetX() * vector[1] - GetY() * vector[0];
}
 
 
inline double CVector2d::GetDotProduct(const CVector2d& vector) const
{
       return GetX() * vector.GetX() + GetY() * vector.GetY();
}
 
 
inline double CVector2d::GetAngle() const
{
       return qAtan2(GetY(), GetX());
}
 
 
inline CVector2d CVector2d::operator-() const
{
       return CVector2d(-GetX(), -GetY());
}
 
 
inline CVector2d CVector2d::operator+(const imath::TVector<2>& vector) const
{
       return CVector2d(GetX() + vector[0], GetY() + vector[1]);
}
 
 
inline CVector2d CVector2d::operator-(const imath::TVector<2>& vector) const
{
       return CVector2d(GetX() - vector[0], GetY() - vector[1]);
}
 
 
inline CVector2d CVector2d::operator*(double scalar) const
{
       return CVector2d(GetX() * scalar, GetY() * scalar);
}
 
 
inline CVector2d CVector2d::operator/(double scalar) const
{
       if (qAbs(scalar) < I_BIG_EPSILON){
              scalar = (scalar > 0)? I_BIG_EPSILON: -I_BIG_EPSILON;
       }
 
       return CVector2d(GetX() / scalar, GetY() / scalar);
}
 
 
inline CVector2d& CVector2d::operator+=(const imath::TVector<2>& vector)
{
       BaseClass::operator+=(vector);
 
       return *this;
}
 
 
inline CVector2d& CVector2d::operator-=(const imath::TVector<2>& vector)
{
       BaseClass::operator-=(vector);
 
       return *this;
}
 
 
inline CVector2d& CVector2d::operator*=(double scalar)
{
       BaseClass::operator*=(scalar);
 
       return *this;
}
 
 
inline CVector2d& CVector2d::operator/=(double scalar)
{
       BaseClass::operator/=(scalar);
 
       return *this;
}
 
 
inline CVector2d::operator QPointF() const
{
       return QPointF(qreal(GetX()), qreal(GetY()));
}
 
 
// static methods
 
inline const CVector2d& CVector2d::GetZero()
{
       return reinterpret_cast<const CVector2d&>(BaseClass::GetZero());
}
 
 
// related global functions
 
inline uint qHash(const CVector2d& key, uint seed = 0)
{
       Q_UNUSED(seed);
 
       return int(key.GetX()) ^ int(key.GetY());
}
 
 
} // namespace i2d