CAffine2d.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// ICF 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, bool isPosDef = true);
 
    void Reset(const CVector2d& translation, double angle, const CVector2d& scale, bool isPosDef = true);
 
    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