Rigid2d.h

// Rigid2d.h:
// ----------
//

#ifndef __IPSDKMATH_RIGID2D_H__
#define __IPSDKMATH_RIGID2D_H__

// suppression warnings
// warning C4251: 'ipsdk::math::transform::Rigid2d::g_registrator' : struct 'ipsdk::math::transform::Registrator<ipsdk::math::transform::Rigid2d>' needs to have dll-interface to be used by clients of class 'ipsdk::math::transform::Rigid2d'
#pragma warning (push)
#pragma warning (disable : 4251)

#include <IPSDKMath/Geometry/2d/Transform/BaseLinearGeometricTransform2d.h>
#include <IPSDKMath/Geometry/2d/Angles2d.h>

namespace ipsdk {
namespace math {
namespace transform {


class IPSDKMATH_API Rigid2d : public BaseLinearGeometricTransform2d
{
// predefined public type
public:
    IPSDK_ENUM(eTransformParams,

        (eTP_Theta)     
        (eTP_Tx)        
        (eTP_Ty)        
    );

    // declare geometric transformation 2d
    IPSDK_DECLARE_TRANSFORM2D(Rigid2d);

public:
    Rigid2d()
    {
        setParams(0, 0, 0);
    }
    Rigid2d(const ipReal64 theta, const ipReal64 tx, const ipReal64 ty)
    {
        setParams(theta, tx, ty);
    }
    ~Rigid2d() {}

// methods
public:
    static void             transform(const ipReal64 theta,
                                      const ipReal64 tx, const ipReal64 ty,
                                      ipReal64& x, ipReal64& y)
    {
        transform(std::cos(theta), std::sin(theta), tx, ty, x, y);
    }
    static void             transform(const ipReal64 cosTheta, const ipReal64 sinTheta,
                                      const ipReal64 tx, const ipReal64 ty,
                                      ipReal64& x, ipReal64& y)
    {
        rotate2dInSitu(cosTheta, sinTheta, x, y);
        x += tx;
        y += ty;
    }

    static Matrix3d         getHomogenousMatrix(const ipReal64 theta,
                                                const ipReal64 tx, const ipReal64 ty)
    {
        return getHomogenousMatrix(std::cos(theta), std::sin(theta), tx, ty);
    }
    static Matrix3d         getHomogenousMatrix(const ipReal64 cosTheta, const ipReal64 sinTheta,
                                                const ipReal64 tx, const ipReal64 ty)
    {
        Matrix3d transform;
        angleToMatrix(cosTheta, sinTheta,
                      transform(0, 0), transform(0, 1),
                      transform(1, 0), transform(1, 1));
        transform(0, 2) = tx;
        transform(1, 2) = ty;
        transform(2, 0) = 0; transform(2, 1) = 0; transform(2, 2) = 1;

        return transform;
    }

    static Matrix3d         getInvHomogenousMatrix(const ipReal64 theta,
                                                   const ipReal64 tx, const ipReal64 ty)
    {
        const ipReal64 cosTheta = std::cos(theta);
        const ipReal64 sinTheta = std::sin(theta);
        const ipReal64 invTx = -(cosTheta*tx + sinTheta*ty);
        const ipReal64 invTy = -(-sinTheta*tx + cosTheta*ty);
        return getHomogenousMatrix(cosTheta, -sinTheta, invTx, invTy);
    }

    static void             getInvParams(ipReal64& theta, ipReal64& tx, ipReal64& ty)
    {
        const ipReal64 cosTheta = std::cos(theta);
        const ipReal64 sinTheta = std::sin(theta);
        const ipReal64 invTx = -(cosTheta*tx + sinTheta*ty);
        const ipReal64 invTy = -(-sinTheta*tx + cosTheta*ty);
        theta = -theta;
        tx = invTx;
        ty = invTy;
    }

    static Vector           getIdentityParams();

    void                    setParams(const ipReal64 theta,
                                      const ipReal64 tx, const ipReal64 ty)
    {
        _theta = theta;
        _cosTheta = std::cos(_theta);
        _sinTheta = std::sin(_theta);
        _tx = tx;
        _ty = ty;
    }

    void                    setCenteredRotation(const ipReal64 theta,
                                                const ipReal64 centerX, const ipReal64 centerY)
    {
        // store angle informations
        _theta = theta;
        _cosTheta = std::cos(_theta);
        _sinTheta = std::sin(_theta);

        // we compute translation such as center point is invariant
        // (ie C = RxC + T => T = C - RxC)
        ipReal64 rx, ry;
        rotate2d<ipReal64>(centerX, centerY, _cosTheta, _sinTheta, rx, ry);
        _tx = centerX - rx;
        _ty = centerY - ry;
    }

    void                    setParams(const Vector& params);

    void                    setIdentity();

    void                    apply(ipReal64& x, ipReal64& y) const;

    Matrix3d                getHomogenousMatrix() const;

    Vector                  getParams() const;

    ipReal64                getTheta() const;
    ipReal64                getTx() const;
    ipReal64                getTy() const;

    Matrix3d                getInvHomogenousMatrix() const;

    Vector                  getInvParams() const;

// attributes
protected:
    ipReal64        _theta;

    ipReal64        _cosTheta;
    ipReal64        _sinTheta;

    ipReal64        _tx;

    ipReal64        _ty;
};


inline ipReal64
Rigid2d::getTheta() const
{
    return _theta;
}

inline ipReal64
Rigid2d::getTx() const
{
    return _tx;
}

inline ipReal64
Rigid2d::getTy() const
{
    return _ty;
}

inline void
Rigid2d::setIdentity()
{
    setParams(getIdentityParams());
}


} // end of namespace transform
} // end of namespace math
} // end of namespace ipsdk

#pragma warning (pop)

#endif // __IPSDKMATH_RIGID2D_H__