Homography3d.h

// Homography3d.h:
// ---------------
//

#ifndef __IPSDKMATH_HOMOGRAPHY3D_H__
#define __IPSDKMATH_HOMOGRAPHY3D_H__

// suppression warnings
// warning C4251: 'ipsdk::math::transform::Homography3d::_matA' : class 'boost::numeric::ublas::bounded_matrix<ipsdk::ipReal64,0x04,0x04,boost::numeric::ublas::row_major>' needs to have dll-interface to be used by clients of class 'ipsdk::math::transform::Homography3d'
#pragma warning (push)
#pragma warning (disable : 4251)

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

namespace ipsdk {
namespace math {
namespace transform {


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

        (eTP_Axx)       
        (eTP_Axy)       
        (eTP_Axz)       
        (eTP_Axw)       
        (eTP_Ayx)       
        (eTP_Ayy)       
        (eTP_Ayz)       
        (eTP_Ayw)       
        (eTP_Azx)       
        (eTP_Azy)       
        (eTP_Azz)       
        (eTP_Azw)       
        (eTP_Awx)       
        (eTP_Awy)       
        (eTP_Awz)       
        (eTP_Aww)       
    );

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

public:
    Homography3d()
    {
        _matA(0, 0) = 1; _matA(0, 1) = 0; _matA(0, 2) = 0; _matA(0, 3) = 0;
        _matA(1, 0) = 0; _matA(1, 1) = 1; _matA(1, 2) = 0; _matA(1, 3) = 0;
        _matA(2, 0) = 0; _matA(2, 1) = 0; _matA(2, 2) = 1; _matA(2, 3) = 0;
        _matA(3, 0) = 0; _matA(3, 1) = 0; _matA(3, 2) = 0; _matA(3, 3) = 1;
    }
    Homography3d(const Matrix4d& matA) :
        _matA(matA)
    {
    }
    Homography3d(const ipReal64 axx, const ipReal64 axy, const ipReal64 axz, const ipReal64 axw,
                 const ipReal64 ayx, const ipReal64 ayy, const ipReal64 ayz, const ipReal64 ayw,
                 const ipReal64 azx, const ipReal64 azy, const ipReal64 azz, const ipReal64 azw,
                 const ipReal64 awx, const ipReal64 awy, const ipReal64 awz, const ipReal64 aww)
    {
        _matA(0, 0) = axx; _matA(0, 1) = axy; _matA(0, 2) = axz; _matA(0, 3) = axw;
        _matA(1, 0) = ayx; _matA(1, 1) = ayy; _matA(1, 2) = ayz; _matA(1, 3) = ayw;
        _matA(2, 0) = azx; _matA(2, 1) = azy; _matA(2, 2) = azz; _matA(2, 2) = azw;
        _matA(3, 0) = awx; _matA(3, 1) = awy; _matA(3, 2) = awz; _matA(3, 2) = aww;
    }
    ~Homography3d() {}

// methods
public:
    static bool             transform(const Matrix4d& matA,
                                      ipReal64& x, ipReal64& y, ipReal64& z)
    {
        return transform(matA(0, 0), matA(0, 1), matA(0, 2), matA(0, 3),
                         matA(1, 0), matA(1, 1), matA(1, 2), matA(1, 3),
                         matA(2, 0), matA(2, 1), matA(2, 2), matA(2, 3),
                         matA(3, 0), matA(3, 1), matA(3, 2), matA(3, 3),
                         x, y, z);
    }
    static bool             transform(const ipReal64 axx, const ipReal64 axy, const ipReal64 axz, const ipReal64 axw,
                                      const ipReal64 ayx, const ipReal64 ayy, const ipReal64 ayz, const ipReal64 ayw,
                                      const ipReal64 azx, const ipReal64 azy, const ipReal64 azz, const ipReal64 azw,
                                      const ipReal64 awx, const ipReal64 awy, const ipReal64 awz, const ipReal64 aww,
                                      ipReal64& x, ipReal64& y, ipReal64& z)
    {
        const ipReal64 xTmp = axx*x + axy*y + axz*z + axw;
        const ipReal64 yTmp = ayx*x + ayy*y + ayz*z + ayw;
        const ipReal64 zTmp = azx*x + azy*y + azz*z + azw;
        const ipReal64 wTmp = awx*x + awy*y + awz*z + aww;
        if (wTmp == 0)
            return false;
        x = xTmp / wTmp;
        y = yTmp / wTmp;
        z = zTmp / wTmp;

        return true;
    }

    static Matrix4d         getHomogenousMatrix(const ipReal64 axx, const ipReal64 axy, const ipReal64 axz, const ipReal64 axw,
                                                const ipReal64 ayx, const ipReal64 ayy, const ipReal64 ayz, const ipReal64 ayw,
                                                const ipReal64 azx, const ipReal64 azy, const ipReal64 azz, const ipReal64 azw,
                                                const ipReal64 awx, const ipReal64 awy, const ipReal64 awz, const ipReal64 aww)
    {
        Matrix4d transform;
        transform(0, 0) = axx; transform(0, 1) = axy; transform(0, 2) = axz; transform(0, 3) = axw;
        transform(1, 0) = ayx; transform(1, 1) = ayy; transform(1, 2) = ayz; transform(1, 3) = ayw;
        transform(2, 0) = azx; transform(2, 1) = azy; transform(2, 2) = azz; transform(2, 2) = azw;
        transform(3, 0) = awx; transform(3, 1) = awy; transform(3, 2) = awz; transform(3, 2) = aww;

        return transform;
    }

    static bool             isInvertible(const ipReal64 axx, const ipReal64 axy, const ipReal64 axz, const ipReal64 axw,
                                         const ipReal64 ayx, const ipReal64 ayy, const ipReal64 ayz, const ipReal64 ayw,
                                         const ipReal64 azx, const ipReal64 azy, const ipReal64 azz, const ipReal64 azw,
                                         const ipReal64 awx, const ipReal64 awy, const ipReal64 awz, const ipReal64 aww);

    static Matrix4d         getInvHomogenousMatrix(const ipReal64 axx, const ipReal64 axy, const ipReal64 axz, const ipReal64 axw,
                                                   const ipReal64 ayx, const ipReal64 ayy, const ipReal64 ayz, const ipReal64 ayw,
                                                   const ipReal64 azx, const ipReal64 azy, const ipReal64 azz, const ipReal64 azw,
                                                   const ipReal64 awx, const ipReal64 awy, const ipReal64 awz, const ipReal64 aww)
    {
        // invert input parameters
        Matrix4d matA;
        matA(0, 0) = axx; matA(0, 1) = axy; matA(0, 2) = axz; matA(0, 3) = axw;
        matA(1, 0) = ayx; matA(1, 1) = ayy; matA(1, 2) = ayz; matA(1, 3) = ayw;
        matA(2, 0) = azx; matA(2, 1) = azy; matA(2, 2) = azz; matA(2, 2) = azw;
        matA(3, 0) = awx; matA(3, 1) = awy; matA(3, 2) = awz; matA(3, 2) = aww;
        getInvParams(matA(0, 0), matA(0, 1), matA(0, 2), matA(0, 3),
                     matA(1, 0), matA(1, 1), matA(1, 2), matA(1, 3),
                     matA(2, 0), matA(2, 1), matA(2, 2), matA(2, 3),
                     matA(3, 0), matA(3, 1), matA(3, 2), matA(3, 3));

        return matA;
    }

    static void             getInvParams(ipReal64& axx, ipReal64& axy, ipReal64& axz, ipReal64& axw,
                                         ipReal64& ayx, ipReal64& ayy, ipReal64& ayz, ipReal64& ayw,
                                         ipReal64& azx, ipReal64& azy, ipReal64& azz, ipReal64& azw,
                                         ipReal64& awx, ipReal64& awy, ipReal64& awz, ipReal64& aww);

    static Vector           getIdentityParams();

    void                    setParams(const Matrix4d& matA)
    {
        _matA = matA;
    }
    void                    setParams(const ipReal64 axx, const ipReal64 axy, const ipReal64 axz, const ipReal64 axw,
                                      const ipReal64 ayx, const ipReal64 ayy, const ipReal64 ayz, const ipReal64 ayw,
                                      const ipReal64 azx, const ipReal64 azy, const ipReal64 azz, const ipReal64 azw,
                                      const ipReal64 awx, const ipReal64 awy, const ipReal64 awz, const ipReal64 aww)
    {
        _matA(0, 0) = axx; _matA(0, 1) = axy; _matA(0, 2) = axz; _matA(0, 3) = axw;
        _matA(1, 0) = ayx; _matA(1, 1) = ayy; _matA(1, 2) = ayz; _matA(1, 3) = ayw;
        _matA(2, 0) = azx; _matA(2, 1) = azy; _matA(2, 2) = azz; _matA(2, 2) = azw;
        _matA(3, 0) = awx; _matA(3, 1) = awy; _matA(3, 2) = awz; _matA(3, 2) = aww;
    }

    void                    setParams(const Vector& params);

    void                    setIdentity();

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

    Matrix4d                getHomogenousMatrix() const;

    Vector                  getParams() const;

    bool                    isInvertible() const;

    Matrix4d                getInvHomogenousMatrix() const;

    Vector                  getInvParams() const;

// attributes
protected:
    Matrix4d        _matA;
};


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


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

#pragma warning (pop)

#endif // __IPSDKMATH_HOMOGRAPHY3D_H__