CAffine2d.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 <i2d/CVector2d.h>
#include <i2d/CMatrix2d.h>
 
 
namespace i2d
{
 
 
class CAffine2d
{
public:
       CAffine2d();
 
       CAffine2d(const CAffine2d& transform);
 
       explicit CAffine2d(const CMatrix2d& deform, const CVector2d& translation = CVector2d(0.0, 0.0));
 
       explicit CAffine2d(const CVector2d& translation);
 
       const CVector2d& GetTranslation() const;
 
       void SetTranslation(const CVector2d& translation);
 
       const CMatrix2d& GetDeformMatrix() const;
 
       CVector2d GetScaleVector() const;
 
       CMatrix2d GetRotationMatrix() const;
 
       void SetDeformMatrix(const CMatrix2d& deform);
 
       // internal access operations
 
       CVector2d& GetTranslationRef();
 
       CMatrix2d& GetDeformMatrixRef();
 
       // init operations
 
       void Reset();
 
       void Reset(const CVector2d& translation);
 
       void Reset(const CVector2d& translation, double angle, double scale = 1.0);
 
       void Reset(const CVector2d& translation, double angle, const CVector2d& scale);
 
       CVector2d GetApply(const CVector2d& position) const;
 
       void GetApply(const CVector2d& position, CVector2d& result) const;
 
       CVector2d GetApplyToDelta(const CVector2d& delta) const;
 
       void GetApplyToDelta(const CVector2d& delta, CVector2d& result) const;
 
       CAffine2d GetApply(const CAffine2d& transform) const;
 
       void GetApply(const CAffine2d& transform, CAffine2d& result) const;
 
       void Apply(const CAffine2d& transform);
 
       void ApplyLeft(const CAffine2d& transform);
 
       CVector2d GetInvertedApply(const CVector2d& position) const;
 
       bool GetInvertedApply(const CVector2d& position, CVector2d& result) const;
 
       CAffine2d GetTranslated(const CVector2d& delta) const;
 
       void GetTranslated(const CVector2d& delta, CAffine2d& result) const;
 
       void Translate(const CVector2d& delta);
 
       CAffine2d GetInverted() const;
 
       bool GetInverted(CAffine2d& result) const;
 
       bool Serialize(iser::IArchive& archive);
 
       // operators
       bool operator==(const CAffine2d& transform) const;
       bool operator!=(const CAffine2d& transform) const;
       CAffine2d& operator=(const CAffine2d& transform);
 
       // static methods
       static const CAffine2d& GetIdentity();
 
private:
       CVector2d m_translation;
       CMatrix2d m_deformMatrix;
 
       // static members
       static CAffine2d s_identity;
};
 
 
// inline methods
 
inline CAffine2d::CAffine2d()
:      m_translation(0.0, 0.0),
       m_deformMatrix(CMatrix2d::GetIdentity())
{
}
 
 
inline CAffine2d::CAffine2d(const CAffine2d& transform)
:      m_translation(transform.m_translation),
       m_deformMatrix(transform.m_deformMatrix)
{
}
 
 
// access to members
 
inline const CVector2d& CAffine2d::GetTranslation() const
{
       return m_translation;
}
 
 
inline void CAffine2d::SetTranslation(const CVector2d& translation)
{
       m_translation = translation;
}
 
 
inline const CMatrix2d& CAffine2d::GetDeformMatrix() const
{
       return m_deformMatrix;
}
 
 
inline void CAffine2d::SetDeformMatrix(const CMatrix2d& deform)
{
       m_deformMatrix = deform;
}
 
 
// internal access operations
 
inline CVector2d& CAffine2d::GetTranslationRef()
{
       return m_translation;
}
 
 
inline CMatrix2d& CAffine2d::GetDeformMatrixRef()
{
       return m_deformMatrix;
}
 
 
// operations
 
inline CVector2d CAffine2d::GetApply(const CVector2d& position) const
{
       CVector2d result;
       m_deformMatrix.GetMultiplied(position, result);
 
       return result + m_translation;
}
 
 
inline void CAffine2d::GetApply(const CVector2d& position, CVector2d& result) const
{
       m_deformMatrix.GetMultiplied(position, result);
       result += m_translation;
}
 
 
inline CVector2d CAffine2d::GetApplyToDelta(const CVector2d& delta) const
{
       CVector2d retVal;
 
       m_deformMatrix.GetMultiplied(delta, retVal);
 
       return retVal;
}
 
 
inline void CAffine2d::GetApplyToDelta(const CVector2d& delta, CVector2d& result) const
{
       m_deformMatrix.GetMultiplied(delta, result);
}
 
 
inline CAffine2d CAffine2d::GetTranslated(const CVector2d& vector) const
{
       return CAffine2d(m_deformMatrix, m_translation + vector);
}
 
 
inline void CAffine2d::GetTranslated(const CVector2d& vector, CAffine2d& result) const
{
       result.GetDeformMatrixRef() = m_deformMatrix;
       result.GetTranslationRef() = m_translation + vector;
}
 
 
inline void CAffine2d::Translate(const CVector2d& vector)
{
       m_translation += vector;
}
 
 
inline CVector2d CAffine2d::GetInvertedApply(const CVector2d& position) const
{
       CVector2d result;
 
       GetInvertedApply(position, result);
 
       return result;
}
 
 
inline CAffine2d CAffine2d::GetInverted() const
{
       CAffine2d result;
 
       GetInverted(result);
 
       return result;
}
 
 
// operators
 
inline bool CAffine2d::operator==(const CAffine2d& transform) const
{
       return (m_translation == transform.m_translation) && (m_deformMatrix == transform.m_deformMatrix);
}
 
 
inline bool CAffine2d::operator!=(const CAffine2d& transform) const
{
       return (m_translation != transform.m_translation) || (m_deformMatrix != transform.m_deformMatrix);
}
 
 
// static methods
 
inline const CAffine2d& CAffine2d::GetIdentity()
{
       return s_identity;
}
 
 
} // namespace i2d