CPose2D.cpp

Go to the documentation of this file.

/* +------------------------------------------------------------------------+
   |                     Mobile Robot Programming Toolkit (MRPT)            |
   |                          http://www.mrpt.org/                          |
   |                                                                        |
   | Copyright (c) 2005-2018, Individual contributors, see AUTHORS file     |
   | See: http://www.mrpt.org/Authors - All rights reserved.                |
   | Released under BSD License. See details in http://www.mrpt.org/License |
   +------------------------------------------------------------------------+ */
 
#include "poses-precomp.h"  // Precompiled headers
 
#include <mrpt/poses/CPose2D.h>
#include <mrpt/poses/CPoint2D.h>
#include <mrpt/poses/CPose3D.h>
#include <mrpt/poses/CPoint3D.h>
#include <mrpt/serialization/CArchive.h>
#include <mrpt/math/wrap2pi.h>
#include <mrpt/config.h>  // HAVE_SINCOS
#include <limits>
 
using namespace mrpt;
using namespace mrpt::math;
using namespace mrpt::poses;
 
IMPLEMENTS_SERIALIZABLE(CPose2D, CSerializable, mrpt::poses)
 
/*---------------------------------------------------------------
        Constructors
  ---------------------------------------------------------------*/
CPose2D::CPose2D() : m_phi(0), m_cossin_uptodate(false)
{
        m_coords[0] = m_coords[1] = 0;
}
 
CPose2D::CPose2D(const double x, const double y, const double _phi)
        : m_phi(_phi), m_cossin_uptodate(false)
{
        m_coords[0] = x;
        m_coords[1] = y;
        normalizePhi();
}
 
CPose2D::CPose2D(const CPoint2D& p) : m_phi(0), m_cossin_uptodate(false)
{
        m_coords[0] = p.x();
        m_coords[1] = p.y();
}
 
CPose2D::CPose2D(const CPose3D& p) : m_phi(p.yaw()), m_cossin_uptodate(false)
{
        m_coords[0] = p.x();
        m_coords[1] = p.y();
}
 
uint8_t CPose2D::serializeGetVersion() const { return 1; }
void CPose2D::serializeTo(mrpt::serialization::CArchive& out) const
{
        // The coordinates:
        out << m_coords[0] << m_coords[1] << m_phi;
}
void CPose2D::serializeFrom(mrpt::serialization::CArchive& in, uint8_t version)
{
        switch (version)
        {
                case 0:
                {
                        // The coordinates:
                        float x0, y0, phi0;
                        in >> x0 >> y0 >> phi0;
                        m_coords[0] = x0;
                        m_coords[1] = y0;
                        this->phi(phi0);
                }
                break;
                case 1:
                {
                        // The coordinates:
                        in >> m_coords[0] >> m_coords[1] >> m_phi;
                        m_cossin_uptodate = false;
                }
                break;
                default:
                        MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(version)
        };
}
 
/**  Textual output stream function.
 */
std::ostream& mrpt::poses::operator<<(std::ostream& o, const CPose2D& p)
{
        o << format("(%.03f,%.03f,%.02fdeg)", p.x(), p.y(), RAD2DEG(p.phi()));
        return o;
}
 
/*---------------------------------------------------------------
The operator a="this"+D is the pose compounding operator.
 ---------------------------------------------------------------*/
CPose2D CPose2D::operator+(const CPose2D& D) const
{
        update_cached_cos_sin();
 
        return CPose2D(
                m_coords[0] + D.m_coords[0] * m_cosphi - D.m_coords[1] * m_sinphi,
                m_coords[1] + D.m_coords[0] * m_sinphi + D.m_coords[1] * m_cosphi,
                m_phi + D.m_phi);
}
 
/*---------------------------------------------------------------
                                composeFrom
 ---------------------------------------------------------------*/
void CPose2D::composeFrom(const CPose2D& A, const CPose2D& B)
{
        A.update_cached_cos_sin();
 
        // Use temporary variables for the cases (A==this) or (B==this)
        const double new_x =
                A.m_coords[0] + B.m_coords[0] * A.m_cosphi - B.m_coords[1] * A.m_sinphi;
        const double new_y =
                A.m_coords[1] + B.m_coords[0] * A.m_sinphi + B.m_coords[1] * A.m_cosphi;
        m_coords[0] = new_x;
        m_coords[1] = new_y;
 
        m_phi = math::wrapToPi(A.m_phi + B.m_phi);
        m_cossin_uptodate = false;
}
 
/*---------------------------------------------------------------
                                getRotationMatrix
 ---------------------------------------------------------------*/
void CPose2D::getRotationMatrix(mrpt::math::CMatrixDouble22& R) const
{
        update_cached_cos_sin();
        R(0, 0) = m_cosphi;
        R(0, 1) = -m_sinphi;
        R(1, 0) = m_sinphi;
        R(1, 1) = m_cosphi;
}
 
void CPose2D::getRotationMatrix(mrpt::math::CMatrixDouble33& R) const
{
        update_cached_cos_sin();
        R(0, 0) = m_cosphi;
        R(0, 1) = -m_sinphi;
        R(0, 2) = 0;
        R(1, 0) = m_sinphi;
        R(1, 1) = m_cosphi;
        R(1, 2) = 0;
        R(2, 0) = 0;
        R(2, 1) = 0;
        R(2, 2) = 1;
}
 
/*---------------------------------------------------------------
The operator a="this"+D is the pose compounding operator.
 ---------------------------------------------------------------*/
CPose3D CPose2D::operator+(const CPose3D& D) const
{
        return CPose3D(*this) + D;
}
 
/*---------------------------------------------------------------
The operator u'="this"+u is the pose/point compounding operator.
 ---------------------------------------------------------------*/
CPoint2D CPose2D::operator+(const CPoint2D& u) const
{
        update_cached_cos_sin();
 
        return CPoint2D(
                m_coords[0] + u.x() * m_cosphi - u.y() * m_sinphi,
                m_coords[1] + u.x() * m_sinphi + u.y() * m_cosphi);
}
 
/** An alternative, slightly more efficient way of doing \f$ G = P \oplus L \f$
 * with G and L being 2D points and P this 2D pose.  */
void CPose2D::composePoint(double lx, double ly, double& gx, double& gy) const
{
        update_cached_cos_sin();
 
        gx = m_coords[0] + lx * m_cosphi - ly * m_sinphi;
        gy = m_coords[1] + lx * m_sinphi + ly * m_cosphi;
}
 
void CPose2D::composePoint(
        const mrpt::math::TPoint2D& l, mrpt::math::TPoint2D& g) const
{
        this->composePoint(l.x, l.y, g.x, g.y);
}
 
/** overload \f$ G = P \oplus L \f$ with G and L being 3D points and P this 2D
 * pose (the "z" coordinate remains unmodified) */
void CPose2D::composePoint(
        const mrpt::math::TPoint3D& l, mrpt::math::TPoint3D& g) const
{
        this->composePoint(l.x, l.y, l.z, g.x, g.y, g.z);
}
 
void CPose2D::composePoint(
        double lx, double ly, double lz, double& gx, double& gy, double& gz) const
{
        update_cached_cos_sin();
        gx = m_coords[0] + lx * m_cosphi - ly * m_sinphi;
        gy = m_coords[1] + lx * m_sinphi + ly * m_cosphi;
        gz = lz;
}
 
void CPose2D::inverseComposePoint(
        const double gx, const double gy, double& lx, double& ly) const
{
        update_cached_cos_sin();
 
        const double Ax = gx - m_coords[0];
        const double Ay = gy - m_coords[1];
 
        lx = Ax * m_cosphi + Ay * m_sinphi;
        ly = -Ax * m_sinphi + Ay * m_cosphi;
}
 
/*---------------------------------------------------------------
The operator u'="this"+u is the pose/point compounding operator.
 ---------------------------------------------------------------*/
CPoint3D CPose2D::operator+(const CPoint3D& u) const
{
        update_cached_cos_sin();
 
        return CPoint3D(
                m_coords[0] + u.x() * m_cosphi - u.y() * m_sinphi,
                m_coords[1] + u.x() * m_sinphi + u.y() * m_cosphi, u.z());
}
 
/*---------------------------------------------------------------
The operator D="this"-b is the pose inverse compounding operator.
   The resulting pose "D" is the diference between this pose and "b"
 ---------------------------------------------------------------*/
void CPose2D::inverseComposeFrom(const CPose2D& A, const CPose2D& B)
{
        B.update_cached_cos_sin();
 
        m_coords[0] = (A.m_coords[0] - B.m_coords[0]) * B.m_cosphi +
                                  (A.m_coords[1] - B.m_coords[1]) * B.m_sinphi;
        m_coords[1] = -(A.m_coords[0] - B.m_coords[0]) * B.m_sinphi +
                                  (A.m_coords[1] - B.m_coords[1]) * B.m_cosphi;
        m_phi = math::wrapToPi(A.m_phi - B.m_phi);
        m_cossin_uptodate = false;
}
 
/*---------------------------------------------------------------
 Scalar sum of components: This is diferent from poses
   composition, which is implemented as "+" operators in "CPose" derived
 classes.
 ---------------------------------------------------------------*/
void CPose2D::AddComponents(const CPose2D& p)
{
        m_coords[0] += p.m_coords[0];
        m_coords[1] += p.m_coords[1];
        m_phi += p.m_phi;
        m_cossin_uptodate = false;
}
 
/*---------------------------------------------------------------
 Scalar multiplication.
 ---------------------------------------------------------------*/
void CPose2D::operator*=(const double s)
{
        m_coords[0] *= s;
        m_coords[1] *= s;
        m_phi *= s;
        m_cossin_uptodate = false;
}
 
/*---------------------------------------------------------------
        Returns the corresponding 4x4 homogeneous
          transformation matrix for the point(translation),
          or pose (translation+orientation).
---------------------------------------------------------------*/
void CPose2D::getHomogeneousMatrix(CMatrixDouble44& m) const
{
        m.unit(4, 1.0);
 
        m.set_unsafe(0, 3, m_coords[0]);
        m.set_unsafe(1, 3, m_coords[1]);
 
        update_cached_cos_sin();
 
        m.get_unsafe(0, 0) = m_cosphi;
        m.get_unsafe(0, 1) = -m_sinphi;
        m.get_unsafe(1, 0) = m_sinphi;
        m.get_unsafe(1, 1) = m_cosphi;
}
 
/** Forces "phi" to be in the range [-pi,pi];
*/
void CPose2D::normalizePhi()
{
        m_phi = math::wrapToPi(m_phi);
        m_cossin_uptodate = false;
}
 
CPose2D::CPose2D(const mrpt::math::TPose2D& o)
        : m_phi(o.phi), m_cossin_uptodate(false)
{
        m_coords[0] = o.x;
        m_coords[1] = o.y;
}
 
CPose2D::CPose2D(const CPoint3D& o) : m_phi(0), m_cossin_uptodate(false)
{
        this->m_coords[0] = o.x();
        this->m_coords[1] = o.y();
        normalizePhi();
}
 
/*---------------------------------------------------------------
                unary -
---------------------------------------------------------------*/
CPose2D mrpt::poses::operator-(const CPose2D& b)
{
        CPose2D ret = b;
        ret.inverse();
        return ret;
}
 
/** Convert this pose into its inverse, saving the result in itself. \sa
 * operator- */
void CPose2D::inverse()
{
        update_cached_cos_sin();
        const double x = m_coords[0];
        const double y = m_coords[1];
 
        m_coords[0] = -x * m_cosphi - y * m_sinphi;
        m_coords[1] = x * m_sinphi - y * m_cosphi;
        m_phi = -m_phi;
        m_cossin_uptodate = false;
}
 
/*---------------------------------------------------------------
                getAsVector
---------------------------------------------------------------*/
void CPose2D::getAsVector(CVectorDouble& v) const
{
        v.resize(3);
        v[0] = m_coords[0];
        v[1] = m_coords[1];
        v[2] = m_phi;
}
 
void CPose2D::getAsVector(mrpt::math::CArrayDouble<3>& v) const
{
        v[0] = m_coords[0];
        v[1] = m_coords[1];
        v[2] = m_phi;
}
 
bool mrpt::poses::operator==(const CPose2D& p1, const CPose2D& p2)
{
        return (p1.x() == p2.x()) && (p1.y() == p2.y()) && (p1.phi() == p2.phi());
}
 
bool mrpt::poses::operator!=(const CPose2D& p1, const CPose2D& p2)
{
        return (p1.x() != p2.x()) || (p1.y() != p2.y()) || (p1.phi() != p2.phi());
}
 
TPoint2D mrpt::poses::operator+(const CPose2D& pose, const TPoint2D& u)
{
        const double ccos = pose.phi_cos();
        const double ssin = pose.phi_sin();
        return TPoint2D(
                pose.x() + u.x * ccos - u.y * ssin, pose.y() + u.x * ssin + u.y * ccos);
}
 
/** Make \f$ this = this \oplus b \f$  */
CPose2D& CPose2D::operator+=(const CPose2D& b)
{
        composeFrom(*this, b);
        return *this;
}
 
void CPose2D::fromString(const std::string& s)
{
        CMatrixDouble m;
        if (!m.fromMatlabStringFormat(s))
                THROW_EXCEPTION("Malformed expression in ::fromString");
        ASSERTMSG_(m.rows() == 1 && m.cols() == 3, "Expected vector length=3");
        x(m.get_unsafe(0, 0));
        y(m.get_unsafe(0, 1));
        phi(DEG2RAD(m.get_unsafe(0, 2)));
}
 
void CPose2D::fromStringRaw(const std::string& s)
{
        this->fromString("[" + s + "]");
}
 
double CPose2D::distance2DFrobeniusTo(const CPose2D& p) const
{
        return std::sqrt(
                square(p.x() - x()) + square(p.y() - y()) +
                4 * (1 - cos(p.phi() - phi())));
}
 
CPose3D CPose2D::operator-(const CPose3D& b) const
{
        CMatrixDouble44 B_INV(UNINITIALIZED_MATRIX);
        b.getInverseHomogeneousMatrix(B_INV);
        CMatrixDouble44 HM(UNINITIALIZED_MATRIX);
        this->getHomogeneousMatrix(HM);
        CMatrixDouble44 RES(UNINITIALIZED_MATRIX);
        RES.multiply(B_INV, HM);
        return CPose3D(RES);
}
 
CPose2D CPose2D::getOppositeScalar() const
{
        return CPose2D(-m_coords[0], -m_coords[1], -m_phi);
}
 
void CPose2D::asString(std::string& s) const
{
        s = mrpt::format("[%f %f %fdeg]", x(), y(), mrpt::RAD2DEG(m_phi));
}
 
void CPose2D::setToNaN()
{
        for (int i = 0; i < 3; i++)
                (*this)[i] = std::numeric_limits<double>::quiet_NaN();
}
 
void CPose2D::update_cached_cos_sin() const
{
        if (m_cossin_uptodate) return;
#ifdef HAVE_SINCOS
        ::sincos(m_phi, &m_sinphi, &m_cosphi);
#else
        m_cosphi = ::cos(m_phi);
        m_sinphi = ::sin(m_phi);
#endif
        m_cossin_uptodate = true;
}
 
mrpt::math::TPose2D CPose2D::asTPose() const
{
        return mrpt::math::TPose2D(x(), y(), phi());
}