CMatrix2d.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
 
 
// ACF includes
#include <imath/TMatrix.h>
 
#include <i2d/CVector2d.h>
 
 
namespace i2d
{
 
 
class CMatrix2d: public imath::TMatrix<2, 2>
{
public:
       typedef imath::TMatrix<2, 2> BaseClass;
 
       CMatrix2d();
       CMatrix2d(const CMatrix2d& transform);
       CMatrix2d(const CVector2d& axisX, const CVector2d& axisY);
       CMatrix2d(double m11, double m12, double m21, double m22);
 
       void Reset();
       void Reset(double angle, double scale = 1.0);
       void Reset(double angle, const CVector2d& scale);
 
       // operations
       using BaseClass::GetMultiplied;
       CVector2d GetMultiplied(const CVector2d& position) const;
       CMatrix2d GetMultiplied(const CMatrix2d& matrix) const;
       void Multiply(const CMatrix2d& matrix);
       void MultiplyLeft(const CMatrix2d& matrix);
 
       CVector2d GetAxisX() const;
       CVector2d GetAxisY() const;
 
       CVector2d GetAxesLengths() const;
       void GetAxesLengths(CVector2d& result) const;
       double GetApproxAngle() const;
       double GetApproxScale() const;
 
       i2d::CVector2d GetInvMultiplied(const i2d::CVector2d& position) const;
       bool GetInvMultiplied(const i2d::CVector2d& position, i2d::CVector2d& result) const;
 
       CMatrix2d GetInverted() const;
       bool GetInverted(CMatrix2d& result) const;
 
       using BaseClass::GetTransposed;
       CMatrix2d GetTransposed() const;
 
       bool GetEigenVectors(i2d::CVector2d& vector1, i2d::CVector2d& vector2, double& value1, double& value2) const;
 
       double GetDet() const;
 
       // operators
       CMatrix2d& operator=(const CMatrix2d& matrix);
 
       CMatrix2d operator+(const BaseClass& matrix) const;
       CMatrix2d operator-(const BaseClass& matrix) const;
       CMatrix2d operator-();
       CMatrix2d operator*(double scale) const;
       CMatrix2d operator/(double scale) const;
 
       // static methods
       static const CMatrix2d& GetIdentity();
 
private:
       // static members
       static CMatrix2d s_identity;
};
 
 
// inline methods
 
inline CMatrix2d::CMatrix2d()
{
}
 
 
inline CMatrix2d::CMatrix2d(const CMatrix2d& matrix)
:      BaseClass(matrix)
{
}
 
 
inline CMatrix2d::CMatrix2d(const CVector2d& axisX, const CVector2d& axisY)
{
       SetAt(0, 0, axisX[0]);
       SetAt(0, 1, axisX[1]);
       SetAt(1, 0, axisY[0]);
       SetAt(1, 1, axisY[1]);
}
 
 
inline CMatrix2d::CMatrix2d(double m11, double m12, double m21, double m22)
{
       SetAt(0, 0, m11);
       SetAt(0, 1, m12);
       SetAt(1, 0, m21);
       SetAt(1, 1, m22);
}
 
 
inline CVector2d CMatrix2d::GetMultiplied(const CVector2d& position) const
{
       CVector2d retVal;
 
       GetMultiplied(position, retVal);
 
       return retVal;
}
 
 
inline CMatrix2d CMatrix2d::GetMultiplied(const CMatrix2d& matrix) const
{
       CMatrix2d retVal;
 
       GetMultiplied(matrix, retVal);
 
       return retVal;
}
 
 
inline CVector2d CMatrix2d::GetAxisX() const
{
       return CVector2d(GetAt(0, 0), GetAt(0, 1));
}
 
 
inline CVector2d CMatrix2d::GetAxisY() const
{
       return CVector2d(GetAt(1, 0), GetAt(1, 1));
}
 
 
inline CVector2d CMatrix2d::GetAxesLengths() const
{
       CVector2d result;
 
       GetAxesLengths(result);
       
       return result;
}
 
 
inline void CMatrix2d::GetAxesLengths(CVector2d& result) const
{
       result.SetX(GetAxisX().GetLength());
       result.SetY(GetAxisY().GetLength());
}
 
 
inline CMatrix2d CMatrix2d::GetInverted() const
{
       CMatrix2d result;
 
       GetInverted(result);
 
       return result;
}
 
 
inline CMatrix2d CMatrix2d::GetTransposed() const
{
       return CMatrix2d(GetAt(0, 0), GetAt(1, 0), GetAt(0, 1), GetAt(1, 1));
}
 
 
inline double CMatrix2d::GetDet() const
{
       return GetAt(0, 0) * GetAt(1, 1) - GetAt(0, 1) * GetAt(1, 0);
}
 
 
// operators
 
inline CMatrix2d CMatrix2d::operator+(const BaseClass& matrix) const
{
       CMatrix2d retVal;
 
       BaseClass::GetAdded(matrix, retVal);
 
       return retVal;
}
 
 
inline CMatrix2d CMatrix2d::operator-(const BaseClass& matrix) const
{
       CMatrix2d retVal;
 
       BaseClass::GetSubstracted(matrix, retVal);
 
       return retVal;
}
 
 
inline CMatrix2d CMatrix2d::operator-()
{
       CMatrix2d retVal;
 
       BaseClass::GetNegated(retVal);
 
       return retVal;
}
 
 
inline CMatrix2d& CMatrix2d::operator=(const CMatrix2d& matrix)
{
       BaseClass::operator=(matrix);
 
       return *this;
}
 
 
inline CMatrix2d CMatrix2d::operator*(double scale) const
{
       CMatrix2d retVal;
 
       GetScaled(scale, retVal);
 
       return retVal;
}
 
 
inline CMatrix2d CMatrix2d::operator/(double scale) const
{
       return CMatrix2d(GetAt(0, 0) / scale, GetAt(0, 1) / scale, GetAt(1, 0) / scale, GetAt(1, 1) / scale);
}
 
 
// static methods
 
inline const CMatrix2d& CMatrix2d::GetIdentity()
{
       return s_identity;
}
 
 
} // namespace i2d