Translation3d.h

// Translation3d.h:
// ----------------
//

#ifndef __IPSDKMATH_TRANSLATION3D_H__
#define __IPSDKMATH_TRANSLATION3D_H__

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

#include <IPSDKMath/Geometry/3d/Transform/BaseLinearGeometricTransform3d.h>

namespace ipsdk {
namespace math {
namespace transform {


class IPSDKMATH_API Translation3d : public BaseLinearGeometricTransform3d
{
// predefined public type
public:
    IPSDK_ENUM(eTransformParams,

        (eTP_Tx)        
        (eTP_Ty)        
        (eTP_Tz)        
    );

    // declare geometric transformation 3d
    IPSDK_DECLARE_TRANSFORM3D(Translation3d);

public:
    Translation3d() :
        _tx(0), _ty(0), _tz(0)
    {

    }
    Translation3d(const ipReal64 tx, const ipReal64 ty, const ipReal64 tz) :
        _tx(tx), _ty(ty), _tz(tz)
    {

    }
    ~Translation3d() {}

// methods
public:
    static void             transform(const ipReal64 tx, const ipReal64 ty, const ipReal64 tz,
                                      ipReal64& x, ipReal64& y, ipReal64& z)
    {
        x += tx;
        y += ty;
        z += tz;
    }

    static Matrix3d         getHomogenousMatrix(const ipReal64 tx, const ipReal64 ty, const ipReal64 tz)
    {
        Matrix3d transform;
        transform(0, 0) = 1; transform(0, 1) = 0; transform(0, 2) = 0; transform(0, 3) = tx;
        transform(1, 0) = 0; transform(1, 1) = 1; transform(1, 2) = 0; transform(1, 3) = ty;
        transform(2, 0) = 0; transform(2, 1) = 0; transform(2, 2) = 1; transform(2, 3) = tz;
        transform(3, 0) = 0; transform(3, 1) = 0; transform(3, 2) = 0; transform(3, 2) = 1;

        return transform;
    }

    static Matrix3d         getInvHomogenousMatrix(const ipReal64 tx, const ipReal64 ty, const ipReal64 tz)
    {
        Matrix3d invTransform;
        invTransform(0, 0) = 1; invTransform(0, 1) = 0; invTransform(0, 2) = 0; invTransform(0, 3) = -tx;
        invTransform(1, 0) = 0; invTransform(1, 1) = 1; invTransform(1, 2) = 0; invTransform(1, 3) = -ty;
        invTransform(2, 0) = 0; invTransform(2, 1) = 0; invTransform(2, 2) = 1; invTransform(2, 3) = -tz;
        invTransform(3, 0) = 0; invTransform(3, 1) = 0; invTransform(3, 2) = 0; invTransform(3, 2) = 1;

        return invTransform;
    }

    static void             getInvParams(ipReal64& tx, ipReal64& ty, ipReal64& tz)
    {
        tx = -tx;
        ty = -ty;
        tz = -tz;
    }

    static Vector           getIdentityParams();

    void                    setParams(const ipReal64 tx, const ipReal64 ty, const ipReal64 tz)
    {
        _tx = tx;
        _ty = ty;
        _tz = tz;
    }

    void                    setParams(const Vector& params);

    void                    setIdentity();

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

    Matrix4d                getHomogenousMatrix() const;

    Vector                  getParams() const;

    ipReal64                getTx() const;
    ipReal64                getTy() const;
    ipReal64                getTz() const;

    Matrix4d                getInvHomogenousMatrix() const;

    Vector                  getInvParams() const;

// attributes
protected:
    ipReal64        _tx;

    ipReal64        _ty;

    ipReal64        _tz;
};


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

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

inline ipReal64
Translation3d::getTz() const
{
    return _tz;
}

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


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

#pragma warning (pop)

#endif // __IPSDKMATH_TRANSLATION3D_H__