D:/Programmierung/C/TRTK/include/TRTK/Transform2D.hpp

Go to the documentation of this file.

/*
    Computes a 2D transform in homogeneous coordinates.

    Copyright (C) 2010 - 2014 Christoph Haenisch

    Chair of Medical Engineering (mediTEC)
    RWTH Aachen University
    Pauwelsstr. 20
    52074 Aachen
    Germany

    See license.txt for more information.

    Version 0.1.2 (2011-09-24)
*/

/* Note: The concatenation of several affine matrices to one single
 *       matrix is possible without any problems. However, if a
 *       non-affine transform (e.g. a projective transform) is used,
 *       it may only be used once and at the very end (i.e. multiplied
 *       from left) due to the subsequent non-linear normalisation step.
 */


#ifndef TRANSFORM2D_HPP_9785873423
#define TRANSFORM2D_HPP_9785873423


#include <cassert>
#include <cmath>
#include <Eigen/Core>
#include <Eigen/Dense>

#include "Coordinate.hpp"
#include "ErrorObj.hpp"
#include "Tools.hpp"


namespace TRTK
{


template <class T>
class Transform2D
{
public:

    EIGEN_MAKE_ALIGNED_OPERATOR_NEW

    enum Unit  {DEGREES, RADIANS};

    enum Error {DIVISION_BY_ZERO,
                INVALID_ARGUMENT,
                INVALID_UNIT,
                UNKNOWN_ERROR,
                WRONG_COORDINATE_SIZE};

    typedef T value_type;
    typedef Eigen::Matrix<T, 3, 3> Matrix3T;
    typedef Eigen::Matrix<T, 3, 1> Vector3T;
    typedef Eigen::Matrix<T, 2, 1> Vector2T;
    typedef Coordinate<T> coordinate_type;

    Transform2D();

    Transform2D(const Matrix3T &);

    Transform2D(T a11, T a12, T a13,
                T a21, T a22, T a23,
                T a31, T a32, T a33);

    template <class U>
    Transform2D(const Transform2D<U> & transform2D);

    virtual ~Transform2D();

    T & a11();
    T & a12();
    T & a13();
    T & a21();
    T & a22();
    T & a23();
    T & a31();
    T & a32();
    T & a33();

    const T & a11() const;
    const T & a12() const;
    const T & a13() const;
    const T & a21() const;
    const T & a22() const;
    const T & a23() const;
    const T & a31() const;
    const T & a32() const;
    const T & a33() const;

    const Coordinate<T> operator* (const Coordinate<T> &) const;
    const Matrix3T operator* (const Matrix3T &) const;
    const Vector2T operator* (const Vector2T &) const;
    const Vector3T operator* (const Vector3T &) const;
    const Transform2D operator* (const Transform2D &) const;
    const Transform2D operator>> (const Transform2D &) const;

    Matrix3T & getTransformationMatrix();
    const Matrix3T & getTransformationMatrix() const;

    const Transform2D inverse() const;

    Transform2D & reset();

    Transform2D & rotate(const double angle, const Unit unit = RADIANS);

    Transform2D & scale(const T sx, const T sy);

    Transform2D & shear(const T sx, const T sy);

    Transform2D & translate(const T dx, const T dy);
    Transform2D & translate(const Coordinate<T> & position);

    bool is_affine() const;

    static const double pi;

private:

    void normalize(Vector3T &) const;

    Matrix3T m_matrix;
    bool m_is_affine;
};


template <class T>
const double Transform2D<T>::pi = 3.14159265358979323846264338327950288419716939937510;


template <class T>
Transform2D<T>::Transform2D() : m_is_affine(true)
{
    m_matrix.setIdentity();
}


template <class T>
Transform2D<T>::Transform2D(const Matrix3T & matrix)
{
    using Tools::isEqual;

    m_matrix = matrix;

    if (isEqual<T>(matrix(2,0), 0) &&
        isEqual<T>(matrix(2,1), 0) &&
        isEqual<T>(matrix(2,2), 1))
    {
        m_is_affine = true;
    }
    else
    {
        m_is_affine = false;
    }
}


template <class T>
Transform2D<T>::Transform2D(T a11, T a12, T a13,
                            T a21, T a22, T a23,
                            T a31, T a32, T a33)
{
    using Tools::isEqual;

    m_matrix << a11, a12, a13,
                a21, a22, a23,
                a31, a32, a33;

    if (isEqual<T>(a31, 0) &&
        isEqual<T>(a32, 0) &&
        isEqual<T>(a33, 1))
    {
        m_is_affine = true;
    }
    else
    {
        m_is_affine = false;
    }
}


template <class T>
template <class U>
Transform2D<T>::Transform2D(const Transform2D<U> & transform2D)
{
    const int rows = transform2D.getTransformationMatrix().rows();
    const int cols = transform2D.getTransformationMatrix().cols();

    m_matrix.resize(rows, cols);

    for (int m = 0; m < rows; ++m)
    {
        for (int n = 0; n < cols; ++n)
        {
            m_matrix(m, n) = T(transform2D.getTransformationMatrix()(m, n));
        }
    }

    m_is_affine = transform2D.is_affine();
}


template <class T>
Transform2D<T>::~Transform2D()
{
}


template <class T>
T & Transform2D<T>::a11()
{
    return m_matrix(0, 0);
}


template <class T>
T & Transform2D<T>::a12()
{
    return m_matrix(0, 1);
}


template <class T>
T & Transform2D<T>::a13()
{
    return m_matrix(0, 2);
}


template <class T>
T & Transform2D<T>::a21()
{
    return m_matrix(1, 0);
}


template <class T>
T & Transform2D<T>::a22()
{
    return m_matrix(1, 1);
}


template <class T>
T & Transform2D<T>::a23()
{
    return m_matrix(1, 2);
}


template <class T>
T & Transform2D<T>::a31()
{
    m_is_affine = false;
    return m_matrix(2, 0);
}


template <class T>
T & Transform2D<T>::a32()
{
    m_is_affine = false;
    return m_matrix(2, 1);
}


template <class T>
T & Transform2D<T>::a33()
{
    m_is_affine = false;
    return m_matrix(2, 2);
}


template <class T>
const T & Transform2D<T>::a11() const
{
    return m_matrix(0, 0);
}


template <class T>
const T & Transform2D<T>::a12() const
{
    return m_matrix(0, 1);
}


template <class T>
const T & Transform2D<T>::a13() const
{
    return m_matrix(0, 2);
}


template <class T>
const T & Transform2D<T>::a21() const
{
    return m_matrix(1, 0);
}


template <class T>
const T & Transform2D<T>::a22() const
{
    return m_matrix(1, 1);
}


template <class T>
const T & Transform2D<T>::a23() const
{
    return m_matrix(1, 2);
}


template <class T>
const T & Transform2D<T>::a31() const
{
    return m_matrix(2, 0);
}


template <class T>
const T & Transform2D<T>::a32() const
{
    return m_matrix(2, 1);
}


template <class T>
const T & Transform2D<T>::a33() const
{
    return m_matrix(2, 2);
}


template <class T>
const Coordinate<T> Transform2D<T>::operator* (const Coordinate<T> & coordinate) const
{
    // 'coordinate' must be of size two or three. If 'coordinate' has a size
    // of three, it is assumed that the third component is equal to one.

    const int size = coordinate.size();

    if (!(size == 2 || size == 3))
    {
        ErrorObj error;
        error.setClassName("Transform2D<T>");
        error.setFunctionName("operator*");
        error.setErrorMessage("'coordinate' must be of size two or three.");
        error.setErrorCode(WRONG_COORDINATE_SIZE);
        throw error;
    }

    assert(coordinate.size() == 2 || (coordinate.size() == 3 && coordinate.w() == 1));

    Vector3T vector(coordinate.x(), coordinate.y(), 1);
    Vector3T result = m_matrix * vector;

    if (!is_affine())
    {
        normalize(result);
    }

    if (size == 2)
    {
        return Coordinate<T>(result(0), result(1));
    }
    else // size == 3
    {
        return Coordinate<T>(result(0), result(1), 1);
    }
}


template <class T>
const typename Transform2D<T>::Vector2T Transform2D<T>::operator* (const Vector2T & vector) const
{
    Vector3T vector3D(vector(0), vector(1), 1);
    Vector3T result = m_matrix * vector3D;

    if (!is_affine())
    {
        normalize(result);
    }

    return result.head(2);
}


template <class T>
const typename Transform2D<T>::Vector3T Transform2D<T>::operator* (const Vector3T & vector) const
{
    assert(Tools::isEqual<T>(vector(2), 1));

    Vector3T result = m_matrix * vector;

    if (!is_affine())
    {
        normalize(result);
    }

    return result;
}


template <class T>
const typename Transform2D<T>::Matrix3T Transform2D<T>::operator* (const Matrix3T & matrix) const
{
    typename Transform2D<T>::Matrix3T result = m_matrix * matrix;

    return result;
}


template <class T>
const Transform2D<T> Transform2D<T>::operator* (const Transform2D & transform) const
{
    Transform2D<T> result = (m_matrix * transform.m_matrix).eval();
    result.m_is_affine = m_is_affine && transform.m_is_affine;

    return result;
}


template <class T>
const Transform2D<T> Transform2D<T>::operator>> (const Transform2D & transform) const
{
    Transform2D<T> result = (transform.m_matrix * m_matrix).eval();
    result.m_is_affine = m_is_affine && transform.m_is_affine;

    return result;
}


template <class T>
typename Transform2D<T>::Matrix3T & Transform2D<T>::getTransformationMatrix()
{
    return m_matrix;
}


template <class T>
const typename Transform2D<T>::Matrix3T & Transform2D<T>::getTransformationMatrix() const
{
    return m_matrix;
}


template <class T>
const Transform2D<T> Transform2D<T>::inverse() const
{
    return Transform2D(m_matrix.inverse());
}


template <class T>
Transform2D<T> & Transform2D<T>::reset()
{
    m_matrix.setIdentity();
    m_is_affine = true;

    return *this;
}


template <class T>
Transform2D<T> & Transform2D<T>::rotate(const double angle, const Unit unit)
{
    double angle_in_rad;

    switch (unit)
    {
        case RADIANS:
            angle_in_rad = angle;
            break;

        case DEGREES:
            angle_in_rad = angle / 180.0 * pi;
            break;

        default:
            ErrorObj error;
            error.setClassName("Transform2D<T>");
            error.setFunctionName("rotateX");
            error.setErrorMessage("Invalid unit.");
            error.setErrorCode(INVALID_UNIT);
            throw error;
    }

    Matrix3T rotation;

    const double c = std::cos(angle_in_rad);
    const double s = std::sin(angle_in_rad);

    rotation << c, -s, 0,
                s,  c, 0,
                0,  0, 1;

    m_matrix = rotation * m_matrix;

    return *this;
}


template <class T>
Transform2D<T> & Transform2D<T>::scale(const T sx, const T sy)
{
    Matrix3T scale;

    scale << sx,  0,  0,
              0, sy,  0,
              0,  0,  1;

    m_matrix = scale * m_matrix;

    return *this;
}


template <class T>
Transform2D<T> & Transform2D<T>::shear(const T sx, const T sy)
{
    Matrix3T shear;

    shear << 1, sx,  0,
             sy, 1,  0,
             0,  0,  1;

    m_matrix = shear * m_matrix;

    return *this;
}


template <class T>
Transform2D<T> & Transform2D<T>::translate(const T dx, const T dy)
{
    Matrix3T translation;

    translation << 1, 0, dx,
                   0, 1, dy,
                   0, 0, 1;

    m_matrix = translation * m_matrix;

    return *this;
}


template <class T>
Transform2D<T> & Transform2D<T>::translate(const Coordinate<T> & position)
{
    assert(position.size() == 2);

    Matrix3T translation;

    translation << 1, 0, position.x(),
                   0, 1, position.y(),
                   0, 0, 1;

    m_matrix = translation * m_matrix;

    return *this;
}


template <class T>
inline bool Transform2D<T>::is_affine() const
{
    return m_is_affine;
}


template <class T>
inline void Transform2D<T>::normalize(Vector3T & vec) const
{
    if (Tools::isZero<T>(vec(2)))
    {
        ErrorObj error;
        error.setClassName("Transform2D");
        error.setFunctionName("normalize");
        error.setErrorMessage("Division by zero.");
        error.setErrorCode(DIVISION_BY_ZERO);
        throw error;
    }
    else
    {
        vec(0) /= vec(2);
        vec(1) /= vec(2);
        vec(2) = 1;
    }
}


} // namespace TRTK


#endif // TRANSFORM2D_HPP_9785873423