12 #include <mrpt/config.h> 41 #include <mrpt/otherlibs/sophus/so3.hpp> 42 #include <mrpt/otherlibs/sophus/se3.hpp> 56 m_coords[0] = m_coords[1] = m_coords[2] = 0;
61 const double x,
const double y,
const double z,
const double yaw,
79 : m_ypr_uptodate(false), m_yaw(), m_pitch(), m_roll()
89 for (
int r = 0;
r < 3;
r++)
90 for (
int c = 0;
c < 3;
c++)
m_ROT(
r,
c) = m.get_unsafe(
r,
c);
97 for (
int r = 0;
r < 3;
r++)
98 for (
int c = 0;
c < 3;
c++)
m_ROT(
r,
c) = m.get_unsafe(
r,
c);
122 p.quat().rotationMatrixNoResize(
m_ROT);
148 out <<
q[0] <<
q[1] <<
q[2] <<
q[3] <<
q[4] <<
q[5] <<
q[6];
167 m_ROT = HM2.block(0, 0, 3, 3).cast<
double>();
181 m_ROT = HM.block(0, 0, 3, 3);
193 in >>
p[0] >>
p[1] >>
p[2] >>
p[3] >>
p[4] >>
p[5] >>
p[6];
200 p.quat().rotationMatrixNoResize(
m_ROT);
212 const std::streamsize old_pre = o.precision();
213 const std::ios_base::fmtflags old_flags = o.flags();
214 o <<
"(x,y,z,yaw,pitch,roll)=(" << std::fixed << std::setprecision(4)
215 <<
p.m_coords[0] <<
"," <<
p.m_coords[1] <<
"," <<
p.m_coords[2] <<
"," 216 << std::setprecision(2) <<
RAD2DEG(
p.yaw()) <<
"deg," 219 o.precision(old_pre);
232 const char* fields[] = {
"R",
"t"};
233 mexplus::MxArray pose_struct(
234 mexplus::MxArray::Struct(
sizeof(fields) /
sizeof(fields[0]), fields));
237 return pose_struct.release();
249 const double x0,
const double y0,
const double z0,
const double yaw,
271 ::sincos(
m_yaw, &sy, &cy);
275 ::sincos(
m_roll, &sr, &cr);
277 const double cy = cos(
m_yaw);
278 const double sy = sin(
m_yaw);
279 const double cp = cos(
m_pitch);
280 const double sp = sin(
m_pitch);
281 const double cr = cos(
m_roll);
282 const double sr = sin(
m_roll);
285 alignas(16)
const double rot_vals[] = {cy * cp,
286 cy * sp * sr - sy * cr,
287 cy * sp * cr + sy * sr,
289 sy * sp * sr + cy * cr,
290 sy * sp * cr - cy * sr,
323 "Homogeneous matrix is not orthogonal & normalized!: " +
324 m_ROT.inMatlabFormat())
331 "Homogeneous matrix is not orthogonal & normalized!: " +
332 m_ROT.inMatlabFormat())
339 "Homogeneous matrix is not orthogonal & normalized!: " +
340 m_ROT.inMatlabFormat())
349 10 * std::numeric_limits<double>::epsilon())
389 const TPoint3D& point,
double& out_range,
double& out_yaw,
390 double& out_pitch)
const 398 out_range =
local.norm();
408 out_pitch = -asin(
local.z / out_range);
454 double lx,
double ly,
double lz,
double& gx,
double& gy,
double& gz,
458 bool use_small_rot_approx)
const 461 if (out_jacobian_df_dpoint) *out_jacobian_df_dpoint =
m_ROT;
464 if (out_jacobian_df_dpose)
466 if (use_small_rot_approx)
469 alignas(16)
const double nums[3 * 6] = {
470 1, 0, 0, -ly, lz, 0, 0, 1, 0, lx, 0, -lz, 0, 0, 1, 0, -lx, ly};
479 ::sincos(
m_yaw, &sy, &cy);
483 ::sincos(
m_roll, &sr, &cr);
485 const double cy = cos(
m_yaw);
486 const double sy = sin(
m_yaw);
487 const double cp = cos(
m_pitch);
488 const double sp = sin(
m_pitch);
489 const double cr = cos(
m_roll);
490 const double sr = sin(
m_roll);
493 alignas(16)
const double nums[3 * 6] = {
495 -lx * sy * cp + ly * (-sy * sp * sr - cy * cr) +
496 lz * (-sy * sp * cr + cy * sr),
497 -lx * cy * sp + ly * (cy * cp * sr) +
499 ly * (cy * sp * cr + sy * sr) +
500 lz * (-cy * sp * sr + sy * cr),
503 lx * cy * cp + ly * (cy * sp * sr - sy * cr) +
504 lz * (cy * sp * cr + sy * sr),
505 -lx * sy * sp + ly * (sy * cp * sr) +
507 ly * (sy * sp * cr - cy * sr) +
508 lz * (-sy * sp * sr - cy * cr),
512 -lx * cp - ly * sp * sr - lz * sp * cr,
513 ly * cp * cr - lz * cp * sr
524 if (out_jacobian_df_dse3)
526 alignas(16)
const double nums[3 * 6] = {
527 1, 0, 0, 0, gz, -gy, 0, 1, 0, -gz, 0, gx, 0, 0, 1, gy, -gx, 0};
533 #if MRPT_HAS_SSE2 && defined(MRPT_USE_SSE2) 580 b.getInverseHomogeneousMatrix(B_INV);
608 .maxCoeff() >= 1e-6);
646 for (
int r = 0;
r < 3;
r++)
648 A.
m_ROT(
r, 1) * B_coords[1] +
649 A.
m_ROT(
r, 2) * B_coords[2];
653 for (
int r = 0;
r < 3;
r++)
686 (fabs(
m_roll) <= tolerance ||
710 for (
int i = 0; i < 3; i++)
724 const double gx,
const double gy,
const double gz,
double& lx,
double& ly,
735 if (out_jacobian_df_dpoint) *out_jacobian_df_dpoint = R_inv;
738 if (out_jacobian_df_dpose)
746 ::sincos(
m_yaw, &sy, &cy);
750 ::sincos(
m_roll, &sr, &cr);
752 const double cy = cos(
m_yaw);
753 const double sy = sin(
m_yaw);
754 const double cp = cos(
m_pitch);
755 const double sp = sin(
m_pitch);
756 const double cr = cos(
m_roll);
757 const double sr = sin(
m_roll);
760 const double m11_dy = -sy * cp;
761 const double m12_dy = cy * cp;
762 const double m13_dy = 0;
763 const double m11_dp = -cy * sp;
764 const double m12_dp = -sy * sp;
765 const double m13_dp = -cp;
766 const double m11_dr = 0;
767 const double m12_dr = 0;
768 const double m13_dr = 0;
770 const double m21_dy = (-sy * sp * sr - cy * cr);
771 const double m22_dy = (cy * sp * sr - sy * cr);
772 const double m23_dy = 0;
773 const double m21_dp = (cy * cp * sr);
774 const double m22_dp = (sy * cp * sr);
775 const double m23_dp = -sp * sr;
776 const double m21_dr = (cy * sp * cr + sy * sr);
777 const double m22_dr = (sy * sp * cr - cy * sr);
778 const double m23_dr = cp * cr;
780 const double m31_dy = (-sy * sp * cr + cy * sr);
781 const double m32_dy = (cy * sp * cr + sy * sr);
782 const double m33_dy = 0;
783 const double m31_dp = (cy * cp * cr);
784 const double m32_dp = (sy * cp * cr);
785 const double m33_dp = -sp * cr;
786 const double m31_dr = (-cy * sp * sr + sy * cr);
787 const double m32_dr = (-sy * sp * sr - cy * cr);
788 const double m33_dr = -cp * sr;
794 alignas(16)
const double nums[3 * 6] = {
798 Ax * m11_dy + Ay * m12_dy + Az * m13_dy,
799 Ax * m11_dp + Ay * m12_dp + Az * m13_dp,
800 Ax * m11_dr + Ay * m12_dr + Az * m13_dr,
805 Ax * m21_dy + Ay * m22_dy + Az * m23_dy,
806 Ax * m21_dp + Ay * m22_dp + Az * m23_dp,
807 Ax * m21_dr + Ay * m22_dr + Az * m23_dr,
812 Ax * m31_dy + Ay * m32_dy + Az * m33_dy,
813 Ax * m31_dp + Ay * m32_dp + Az * m33_dp,
814 Ax * m31_dr + Ay * m32_dr + Az * m33_dr,
819 lx = t_inv[0] + R_inv(0, 0) * gx + R_inv(0, 1) * gy + R_inv(0, 2) * gz;
820 ly = t_inv[1] + R_inv(1, 0) * gx + R_inv(1, 1) * gy + R_inv(1, 2) * gz;
821 lz = t_inv[2] + R_inv(2, 0) * gx + R_inv(2, 1) * gy + R_inv(2, 2) * gz;
824 if (out_jacobian_df_dse3)
826 alignas(16)
const double nums[3 * 6] = {
827 -1, 0, 0, 0, -lz, ly, 0, -1, 0, lz, 0, -lx, 0, 0, -1, -ly, lx, 0};
842 bool pseudo_exponential)
844 if (pseudo_exponential)
846 auto R = Sophus::SO3<double>::exp(mu.block<3, 1>(3, 0));
854 auto R = Sophus::SE3<double>::exp(mu);
861 Sophus::SO3<double>
R(this->
m_ROT);
868 auto R = Sophus::SO3<double>::exp(
w);
884 template <
class VEC3,
class MAT33>
887 v[0] =
R(2, 1) -
R(1, 2);
888 v[1] =
R(0, 2) -
R(2, 0);
889 v[2] =
R(1, 0) -
R(0, 1);
892 template <
typename VEC3,
typename MAT3x3,
typename MAT3x9>
893 inline void M3x9(
const VEC3&
a,
const MAT3x3& B, MAT3x9& RES)
895 alignas(16)
const double vals[] = {
896 a[0], -B(0, 2), B(0, 1), B(0, 2),
a[0], -B(0, 0), -B(0, 1),
897 B(0, 0),
a[0],
a[1], -B(1, 2), B(1, 1), B(1, 2),
a[1],
898 -B(1, 0), -B(1, 1), B(1, 0),
a[1],
a[2], -B(2, 2), B(2, 1),
899 B(2, 2),
a[2], -B(2, 0), -B(2, 1), B(2, 0),
a[2]};
900 RES.loadFromArray(vals);
914 alignas(16)
const double vals[] = {
915 -
b *
t[1] -
c *
t[2], 2 *
b *
t[0] -
a *
t[1],
916 2 *
c *
t[0] -
a *
t[2], -
b *
t[0] + 2 *
a *
t[1],
917 -
a *
t[0] -
c *
t[2], 2 *
c *
t[1] -
b *
t[2],
918 -
c *
t[0] + 2 *
a *
t[2], -
c *
t[1] + 2 *
b *
t[2],
919 -
a *
t[0] -
b *
t[1]};
931 const double d = 0.5 * (
R(0, 0) +
R(1, 1) +
R(2, 2) - 1);
935 a[0] =
a[1] =
a[2] = 0;
940 const double theta = acos(d);
941 const double theta2 =
square(theta);
942 const double oned2 = (1 -
square(d));
943 const double sq = std::sqrt(oned2);
944 const double cot = 1. / tan(0.5 * theta);
945 const double csc2 =
square(1. / sin(0.5 * theta));
953 skewR.multiply_Ab(
t, skewR_t);
955 skewR_t *= -(d * theta - sq) / (8 * pow(sq, 3));
959 skewR2.multiply_AB(skewR, skewR);
962 skewR2.multiply_Ab(
t, skewR2_t);
964 (((theta * sq - d * theta2) * (0.5 * theta * cot - 1)) -
965 theta * sq * ((0.25 * theta * cot) + 0.125 * theta2 * csc2 - 1)) /
966 (4 * theta2 *
square(oned2));
970 B *= -0.5 * theta / (2 * sq);
972 B += -(theta * cot - 2) / (8 * oned2) *
ddeltaRt_dR(P);
995 J.insertMatrix(3, 0, M);
1000 J.insertMatrix(0, 0, M);
1010 const double d = 0.5 * (
R(0, 0) +
R(1, 1) +
R(2, 2) - 1);
1017 Omega2.multiply_AAt(Omega);
1018 Omega2 *= 1.0 / 12.0;
1029 const double theta = acos(d);
1030 omega *= theta / (2 * std::sqrt(1 - d * d));
1035 Omega2.multiply_AAt(Omega);
1037 Omega2 *= (1 - theta / (2 * std::tan(theta * 0.5))) /
square(theta);
1043 J.insertMatrix(0, 9, V_inv);
1049 const double d = 0.5 * (
R(0, 0) +
R(1, 1) +
R(2, 2) - 1);
1054 a[0] =
a[1] =
a[2] = 0;
1059 const double theta = acos(d);
1060 const double d2 =
square(d);
1061 const double sq = std::sqrt(1 - d2);
1063 a *= (d * theta - sq) / (4 * (sq * sq * sq));
1064 B.unit(3, -theta / (2 * sq));
1072 const CPose3D& D, Eigen::Matrix<double, 12, 6>& jacob)
1074 jacob.block<9, 3>(0, 0).setZero();
1075 jacob.block<3, 3>(9, 0).setIdentity();
1076 for (
int i = 0; i < 3; i++)
1078 Eigen::Block<Eigen::Matrix<double, 12, 6>, 3, 3,
false> trg_blc =
1079 jacob.block<3, 3>(3 * i, 3);
1083 Eigen::Block<Eigen::Matrix<double, 12, 6>, 3, 3,
false> trg_blc =
1084 jacob.block<3, 3>(9, 3);
1092 const CPose3D& A,
const CPose3D& D, Eigen::Matrix<double, 12, 6>& jacob)
1094 jacob.block<9, 3>(0, 0).setZero();
1096 Eigen::Matrix<double, 3, 3> aux;
1097 for (
int i = 0; i < 3; i++)
1101 jacob.block<3, 3>(3 * i, 3) = A.
m_ROT * aux;
1104 jacob.block<3, 3>(9, 3) = A.
m_ROT * aux;
1109 for (
int i = 0; i < 3; i++)
1110 for (
int j = 0; j < 3; j++)
1111 m_ROT(i, j) = std::numeric_limits<double>::quiet_NaN();
1113 for (
int i = 0; i < 3; i++)
1114 m_coords[i] = std::numeric_limits<double>::quiet_NaN();
double x() const
Common members of all points & poses classes.
void inverseComposeFrom(const CPose3D &A, const CPose3D &B)
Makes this method is slightly more efficient than "this= A - B;" since it avoids the temporary objec...
CPose3D getOppositeScalar() const
Return the opposite of the current pose instance by taking the negative of all its components individ...
Classes for serialization, sockets, ini-file manipulation, streams, list of properties-values, timewatch, extensions to STL.
static mrpt::math::CMatrixDouble33 exp_rotation(const mrpt::math::CArrayNumeric< double, 3 > &vect)
Exponentiate a vector in the Lie algebra to generate a new SO(3) (a 3x3 rotation matrix).
mxArray * convertToMatlab(const Eigen::EigenBase< Derived > &mat)
Convert vectors, arrays and matrices into Matlab vectors/matrices.
The virtual base class which provides a unified interface for all persistent objects in MRPT...
void skew_symmetric3(const VECTOR &v, MATRIX &M)
Computes the 3x3 skew symmetric matrix from a 3-vector or 3-array: .
mrpt::math::CMatrixDouble33 m_ROT
The 3x3 rotation matrix, access with getRotationMatrix(), setRotationMatrix() (It's not safe to set t...
void setToNaN() override
Set all data fields to quiet NaN.
bool isHorizontal(const double tolerance=0) const
Return true if the 6D pose represents a Z axis almost exactly vertical (upwards or downwards)...
double roll
Roll coordinate (rotation angle over X coordinate).
#define IMPLEMENTS_SERIALIZABLE(class_name, base, NameSpace)
This must be inserted in all CSerializable classes implementation files.
bool m_ypr_uptodate
Whether yaw/pitch/roll members are up-to-date since the last rotation matrix update.
GLdouble GLdouble GLdouble GLdouble q
mrpt::math::CArrayDouble< 3 > ln_rotation() const
Take the logarithm of the 3x3 rotation matrix, generating the corresponding vector in the Lie Algebra...
This file implements several operations that operate element-wise on individual or pairs of container...
CArrayNumeric is an array for numeric types supporting several mathematical operations (actually...
void getAsQuaternion(mrpt::math::CQuaternion< double > &q, mrpt::math::CMatrixFixedNumeric< double, 4, 3 > *out_dq_dr=NULL) const
Returns the quaternion associated to the rotation of this object (NOTE: XYZ translation is ignored) ...
Column vector, like Eigen::MatrixX*, but automatically initialized to zeros since construction...
double pitch() const
Get the PITCH angle (in radians)
double yaw() const
Get the YAW angle (in radians)
CPose3D operator+(const CPose3D &b) const
The operator is the pose compounding operator.
void rebuildRotationMatrix()
Rebuild the homog matrix from the angles.
void getAsQuaternion(mrpt::math::CQuaternionDouble &q, mrpt::math::CMatrixFixedNumeric< double, 4, 3 > *out_dq_dr=nullptr) const
Returns the quaternion associated to the rotation of this object (NOTE: XYZ translation is ignored) ...
CMatrixFixedNumeric< double, 3, 3 > CMatrixDouble33
double yaw
Yaw coordinate (rotation angle over Z axis).
void updateYawPitchRoll() const
Updates Yaw/pitch/roll members from the m_ROT.
void inverse()
Convert this pose into its inverse, saving the result in itself.
GLubyte GLubyte GLubyte GLubyte w
void setRotationMatrix(const mrpt::math::CMatrixDouble33 &ROT)
Sets the 3x3 rotation matrix.
void readFromStream(mrpt::utils::CStream &in, int version) override
Introduces a pure virtual method responsible for loading from a CStream This can not be used directly...
T square(const T x)
Inline function for the square of a number.
double distanceEuclidean6D(const CPose3D &o) const
The euclidean distance between two poses taken as two 6-length vectors (angles in radians)...
#define ASSERTDEBMSG_(f, __ERROR_MSG)
static void jacob_dexpeD_de(const CPose3D &D, Eigen::Matrix< double, 12, 6 > &jacob)
The Jacobian d (e^eps * D) / d eps , with eps=increment in Lie Algebra.
void skew_symmetric3_neg(const VECTOR &v, MATRIX &M)
Computes the negative version of a 3x3 skew symmetric matrix from a 3-vector or 3-array: ...
This base class is used to provide a unified interface to files,memory buffers,..Please see the deriv...
A numeric matrix of compile-time fixed size.
This base provides a set of functions for maths stuff.
void dVinvt_dR(const CPose3D &P, CMatrixFixedNumeric< double, 3, 9 > &J)
mrpt::math::CArrayDouble< 3 > m_coords
The translation vector [x,y,z] access directly or with x(), y(), z() setter/getter methods...
void composeFrom(const CPose3D &A, const CPose3D &B)
Makes "this = A (+) B"; this method is slightly more efficient than "this= A + B;" since it avoids th...
#define MRPT_THROW_UNKNOWN_SERIALIZATION_VERSION(__V)
For use in CSerializable implementations.
bool operator!=(const CPoint< DERIVEDCLASS > &p1, const CPoint< DERIVEDCLASS > &p2)
CPose2D operator-(const CPose2D &p)
Unary - operator: return the inverse pose "-p" (Note that is NOT the same than a pose with negative x...
void addComponents(const CPose3D &p)
Scalar sum of all 6 components: This is diferent from poses composition, which is implemented as "+" ...
void sphericalCoordinates(const mrpt::math::TPoint3D &point, double &out_range, double &out_yaw, double &out_pitch) const
Computes the spherical coordinates of a 3D point as seen from the 6D pose specified by this object...
void M3x9(const VEC3 &a, const MAT3x3 &B, MAT3x9 &RES)
#define IMPLEMENTS_MEXPLUS_FROM(complete_type)
double x
X,Y,Z coordinates.
A class used to store a 3D pose as a translation (x,y,z) and a quaternion (qr,qx,qy,qz).
void deltaR(const MAT33 &R, VEC3 &v)
T wrapToPi(T a)
Modifies the given angle to translate it into the ]-pi,pi] range.
double m_yaw
These variables are updated every time that the object rotation matrix is modified (construction...
A class used to store a 2D point.
A class used to store a 3D point.
Classes for 2D/3D geometry representation, both of single values and probability density distribution...
double roll() const
Get the ROLL angle (in radians)
double pitch
Pitch coordinate (rotation angle over Y axis).
void loadFromArray(const T *vals)
void operator*=(const double s)
Scalar multiplication of x,y,z,yaw,pitch & roll (angles will be wrapped to the ]-pi,pi] interval).
void getYawPitchRoll(double &yaw, double &pitch, double &roll) const
Returns the three angles (yaw, pitch, roll), in radians, from the rotation matrix.
void ln_jacob(mrpt::math::CMatrixFixedNumeric< double, 6, 12 > &J) const
Jacobian of the logarithm of the 3x4 matrix defined by this pose.
This is the global namespace for all Mobile Robot Programming Toolkit (MRPT) libraries.
CMatrixDouble33 ddeltaRt_dR(const CPose3D &P)
#define ASSERT_ABOVEEQ_(__A, __B)
GLdouble GLdouble GLdouble r
size_t size(const MATRIXLIKE &m, const int dim)
bool operator==(const CPoint< DERIVEDCLASS > &p1, const CPoint< DERIVEDCLASS > &p2)
virtual mxArray * writeToMatlab() const
Introduces a pure virtual method responsible for writing to a mxArray Matlab object, typically a MATLAB struct whose contents are documented in each derived class.
void homogeneousMatrixInverse(const MATRIXLIKE1 &M, MATRIXLIKE2 &out_inverse_M)
Efficiently compute the inverse of a 4x4 homogeneous matrix by only transposing the rotation 3x3 part...
A class used to store a 2D pose, including the 2D coordinate point and a heading (phi) angle...
A class used to store a 3D pose (a 3D translation + a rotation in 3D).
static void ln_rot_jacob(const mrpt::math::CMatrixDouble33 &R, mrpt::math::CMatrixFixedNumeric< double, 3, 9 > &M)
Static function to compute the Jacobian of the SO(3) Logarithm function, evaluated at a given 3x3 rot...
This file implements matrix/vector text and binary serialization.
void composePoint(double lx, double ly, double lz, double &gx, double &gy, double &gz, mrpt::math::CMatrixFixedNumeric< double, 3, 3 > *out_jacobian_df_dpoint=nullptr, mrpt::math::CMatrixFixedNumeric< double, 3, 6 > *out_jacobian_df_dpose=nullptr, mrpt::math::CMatrixFixedNumeric< double, 3, 6 > *out_jacobian_df_dse3=nullptr, bool use_small_rot_approx=false) const
An alternative, slightly more efficient way of doing with G and L being 3D points and P this 6D pose...
mrpt::math::CArrayDouble< 3 > m_rotvec
The rotation vector [vx,vy,vz].
CPose3D()
Default constructor, with all the coordinates set to zero.
void setFromValues(const double x0, const double y0, const double z0, const double yaw=0, const double pitch=0, const double roll=0)
Set the pose from a 3D position (meters) and yaw/pitch/roll angles (radians) - This method recomputes...
Lightweight 3D pose (three spatial coordinates, plus three angular coordinates).
A partial specialization of CArrayNumeric for double numbers.
void normalizeAngles()
Rebuild the internal matrix & update the yaw/pitch/roll angles within the ]-PI,PI] range (Must be cal...
mrpt::math::CArrayDouble< 6 > ln() const
A 3D pose, with a 3D translation and a rotation in 3D parameterized in rotation-vector form (equivale...
A quaternion, which can represent a 3D rotation as pair , with a real part "r" and a 3D vector ...
void getRotationMatrix(mrpt::math::CMatrixDouble33 &ROT) const
Get the 3x3 rotation matrix.
void getAsVector(mrpt::math::CVectorDouble &v) const
Returns a 1x6 vector with [x y z yaw pitch roll].
This class is a "CSerializable" wrapper for "CMatrixFloat".
void writeToStream(mrpt::utils::CStream &out, int *getVersion) const override
Introduces a pure virtual method responsible for writing to a CStream.
GLubyte GLubyte GLubyte a
static CPose3D exp(const mrpt::math::CArrayNumeric< double, 6 > &vect, bool pseudo_exponential=false)
Exponentiate a Vector in the SE(3) Lie Algebra to generate a new CPose3D (static method).
static void jacob_dAexpeD_de(const CPose3D &A, const CPose3D &D, Eigen::Matrix< double, 12, 6 > &jacob)
The Jacobian d (A * e^eps * D) / d eps , with eps=increment in Lie Algebra.
CMatrixFixedNumeric< double, 4, 4 > CMatrixDouble44
struct mxArray_tag mxArray
Forward declaration for mxArray (avoid #including as much as possible to speed up compiling) ...
void inverseComposePoint(const double gx, const double gy, const double gz, double &lx, double &ly, double &lz, mrpt::math::CMatrixFixedNumeric< double, 3, 3 > *out_jacobian_df_dpoint=nullptr, mrpt::math::CMatrixFixedNumeric< double, 3, 6 > *out_jacobian_df_dpose=nullptr, mrpt::math::CMatrixFixedNumeric< double, 3, 6 > *out_jacobian_df_dse3=nullptr) const
Computes the 3D point L such as .
std::ostream & operator<<(std::ostream &o, const CPoint< DERIVEDCLASS > &p)
Dumps a point as a string [x,y] or [x,y,z].