tracking.hpp
#ifndef PCL_TRACKING_IMPL_TRACKING_H_
#define PCL_TRACKING_IMPL_TRACKING_H_
#include <pcl/common/eigen.h>
#include <ctime>
#include <pcl/tracking/boost.h>
#include <pcl/tracking/tracking.h>
namespace pcl
{
namespace tracking
{
struct _ParticleXYZRPY
{
PCL_ADD_POINT4D;
union
{
struct
{
float roll;
float pitch;
float yaw;
float weight;
};
float data_c[4];
};
};
// particle definition
struct EIGEN_ALIGN16 ParticleXYZRPY : public _ParticleXYZRPY
{
inline ParticleXYZRPY ()
{
x = y = z = roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYZRPY (float _x, float _y, float _z)
{
x = _x; y = _y; z = _z;
roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYZRPY (float _x, float _y, float _z, float _roll, float _pitch, float _yaw)
{
x = _x; y = _y; z = _z;
roll = _roll; pitch = _pitch; yaw = _yaw;
data[3] = 1.0f;
}
inline static int
stateDimension () { return 6; }
void
sample (const std::vector<double>& mean, const std::vector<double>& cov)
{
x += static_cast<float> (sampleNormal (mean[0], cov[0]));
y += static_cast<float> (sampleNormal (mean[1], cov[1]));
z += static_cast<float> (sampleNormal (mean[2], cov[2]));
roll += static_cast<float> (sampleNormal (mean[3], cov[3]));
pitch += static_cast<float> (sampleNormal (mean[4], cov[4]));
yaw += static_cast<float> (sampleNormal (mean[5], cov[5]));
}
void
zero ()
{
x = 0.0;
y = 0.0;
z = 0.0;
roll = 0.0;
pitch = 0.0;
yaw = 0.0;
}
inline Eigen::Affine3f
toEigenMatrix () const
{
return getTransformation(x, y, z, roll, pitch, yaw);
}
static pcl::tracking::ParticleXYZRPY
toState (const Eigen::Affine3f &trans)
{
float trans_x, trans_y, trans_z, trans_roll, trans_pitch, trans_yaw;
getTranslationAndEulerAngles (trans,
trans_x, trans_y, trans_z,
trans_roll, trans_pitch, trans_yaw);
return pcl::tracking::ParticleXYZRPY (trans_x, trans_y, trans_z, trans_roll, trans_pitch, trans_yaw);
}
// a[i]
inline float operator [] (unsigned int i)
{
switch (i)
{
case 0: return x;
case 1: return y;
case 2: return z;
case 3: return roll;
case 4: return pitch;
case 5: return yaw;
default: return 0.0;
}
}
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};
inline std::ostream& operator << (std::ostream& os, const ParticleXYZRPY& p)
{
os << "(" << p.x << "," << p.y << "," << p.z << ","
<< p.roll << "," << p.pitch << "," << p.yaw << ")";
return (os);
}
// a * k
inline pcl::tracking::ParticleXYZRPY operator * (const ParticleXYZRPY& p, double val)
{
pcl::tracking::ParticleXYZRPY newp;
newp.x = static_cast<float> (p.x * val);
newp.y = static_cast<float> (p.y * val);
newp.z = static_cast<float> (p.z * val);
newp.roll = static_cast<float> (p.roll * val);
newp.pitch = static_cast<float> (p.pitch * val);
newp.yaw = static_cast<float> (p.yaw * val);
return (newp);
}
// a + b
inline pcl::tracking::ParticleXYZRPY operator + (const ParticleXYZRPY& a, const ParticleXYZRPY& b)
{
pcl::tracking::ParticleXYZRPY newp;
newp.x = a.x + b.x;
newp.y = a.y + b.y;
newp.z = a.z + b.z;
newp.roll = a.roll + b.roll;
newp.pitch = a.pitch + b.pitch;
newp.yaw = a.yaw + b.yaw;
return (newp);
}
// a - b
inline pcl::tracking::ParticleXYZRPY operator - (const ParticleXYZRPY& a, const ParticleXYZRPY& b)
{
pcl::tracking::ParticleXYZRPY newp;
newp.x = a.x - b.x;
newp.y = a.y - b.y;
newp.z = a.z - b.z;
newp.roll = a.roll - b.roll;
newp.pitch = a.pitch - b.pitch;
newp.yaw = a.yaw - b.yaw;
return (newp);
}
}
}
//########################################################################33
namespace pcl
{
namespace tracking
{
struct _ParticleXYZR
{
PCL_ADD_POINT4D;
union
{
struct
{
float roll;
float pitch;
float yaw;
float weight;
};
float data_c[4];
};
};
// particle definition
struct EIGEN_ALIGN16 ParticleXYZR : public _ParticleXYZR
{
inline ParticleXYZR ()
{
x = y = z = roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYZR (float _x, float _y, float _z)
{
x = _x; y = _y; z = _z;
roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYZR (float _x, float _y, float _z, float, float _pitch, float)
{
x = _x; y = _y; z = _z;
roll = 0; pitch = _pitch; yaw = 0;
data[3] = 1.0f;
}
inline static int
stateDimension () { return 6; }
void
sample (const std::vector<double>& mean, const std::vector<double>& cov)
{
x += static_cast<float> (sampleNormal (mean[0], cov[0]));
y += static_cast<float> (sampleNormal (mean[1], cov[1]));
z += static_cast<float> (sampleNormal (mean[2], cov[2]));
roll = 0;
pitch += static_cast<float> (sampleNormal (mean[4], cov[4]));
yaw = 0;
}
void
zero ()
{
x = 0.0;
y = 0.0;
z = 0.0;
roll = 0.0;
pitch = 0.0;
yaw = 0.0;
}
inline Eigen::Affine3f
toEigenMatrix () const
{
return getTransformation(x, y, z, roll, pitch, yaw);
}
static pcl::tracking::ParticleXYZR
toState (const Eigen::Affine3f &trans)
{
float trans_x, trans_y, trans_z, trans_roll, trans_pitch, trans_yaw;
getTranslationAndEulerAngles (trans,
trans_x, trans_y, trans_z,
trans_roll, trans_pitch, trans_yaw);
return (pcl::tracking::ParticleXYZR (trans_x, trans_y, trans_z, 0, trans_pitch, 0));
}
// a[i]
inline float operator [] (unsigned int i)
{
switch (i)
{
case 0: return x;
case 1: return y;
case 2: return z;
case 3: return roll;
case 4: return pitch;
case 5: return yaw;
default: return 0.0;
}
}
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};
inline std::ostream& operator << (std::ostream& os, const ParticleXYZR& p)
{
os << "(" << p.x << "," << p.y << "," << p.z << ","
<< p.roll << "," << p.pitch << "," << p.yaw << ")";
return (os);
}
// a * k
inline pcl::tracking::ParticleXYZR operator * (const ParticleXYZR& p, double val)
{
pcl::tracking::ParticleXYZR newp;
newp.x = static_cast<float> (p.x * val);
newp.y = static_cast<float> (p.y * val);
newp.z = static_cast<float> (p.z * val);
newp.roll = static_cast<float> (p.roll * val);
newp.pitch = static_cast<float> (p.pitch * val);
newp.yaw = static_cast<float> (p.yaw * val);
return (newp);
}
// a + b
inline pcl::tracking::ParticleXYZR operator + (const ParticleXYZR& a, const ParticleXYZR& b)
{
pcl::tracking::ParticleXYZR newp;
newp.x = a.x + b.x;
newp.y = a.y + b.y;
newp.z = a.z + b.z;
newp.roll = 0;
newp.pitch = a.pitch + b.pitch;
newp.yaw = 0.0;
return (newp);
}
// a - b
inline pcl::tracking::ParticleXYZR operator - (const ParticleXYZR& a, const ParticleXYZR& b)
{
pcl::tracking::ParticleXYZR newp;
newp.x = a.x - b.x;
newp.y = a.y - b.y;
newp.z = a.z - b.z;
newp.roll = 0.0;
newp.pitch = a.pitch - b.pitch;
newp.yaw = 0.0;
return (newp);
}
}
}
//########################################################################33
namespace pcl
{
namespace tracking
{
struct _ParticleXYRPY
{
PCL_ADD_POINT4D;
union
{
struct
{
float roll;
float pitch;
float yaw;
float weight;
};
float data_c[4];
};
};
// particle definition
struct EIGEN_ALIGN16 ParticleXYRPY : public _ParticleXYRPY
{
inline ParticleXYRPY ()
{
x = y = z = roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYRPY (float _x, float, float _z)
{
x = _x; y = 0; z = _z;
roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYRPY (float _x, float, float _z, float _roll, float _pitch, float _yaw)
{
x = _x; y = 0; z = _z;
roll = _roll; pitch = _pitch; yaw = _yaw;
data[3] = 1.0f;
}
inline static int
stateDimension () { return 6; }
void
sample (const std::vector<double>& mean, const std::vector<double>& cov)
{
x += static_cast<float> (sampleNormal (mean[0], cov[0]));
y = 0;
z += static_cast<float> (sampleNormal (mean[2], cov[2]));
roll += static_cast<float> (sampleNormal (mean[3], cov[3]));
pitch += static_cast<float> (sampleNormal (mean[4], cov[4]));
yaw += static_cast<float> (sampleNormal (mean[5], cov[5]));
}
void
zero ()
{
x = 0.0;
y = 0.0;
z = 0.0;
roll = 0.0;
pitch = 0.0;
yaw = 0.0;
}
inline Eigen::Affine3f
toEigenMatrix () const
{
return getTransformation(x, y, z, roll, pitch, yaw);
}
static pcl::tracking::ParticleXYRPY
toState (const Eigen::Affine3f &trans)
{
float trans_x, trans_y, trans_z, trans_roll, trans_pitch, trans_yaw;
getTranslationAndEulerAngles (trans,
trans_x, trans_y, trans_z,
trans_roll, trans_pitch, trans_yaw);
return (pcl::tracking::ParticleXYRPY (trans_x, 0, trans_z, trans_roll, trans_pitch, trans_yaw));
}
// a[i]
inline float operator [] (unsigned int i)
{
switch (i)
{
case 0: return x;
case 1: return y;
case 2: return z;
case 3: return roll;
case 4: return pitch;
case 5: return yaw;
default: return 0.0;
}
}
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};
inline std::ostream& operator << (std::ostream& os, const ParticleXYRPY& p)
{
os << "(" << p.x << "," << p.y << "," << p.z << ","
<< p.roll << "," << p.pitch << "," << p.yaw << ")";
return (os);
}
// a * k
inline pcl::tracking::ParticleXYRPY operator * (const ParticleXYRPY& p, double val)
{
pcl::tracking::ParticleXYRPY newp;
newp.x = static_cast<float> (p.x * val);
newp.y = static_cast<float> (p.y * val);
newp.z = static_cast<float> (p.z * val);
newp.roll = static_cast<float> (p.roll * val);
newp.pitch = static_cast<float> (p.pitch * val);
newp.yaw = static_cast<float> (p.yaw * val);
return (newp);
}
// a + b
inline pcl::tracking::ParticleXYRPY operator + (const ParticleXYRPY& a, const ParticleXYRPY& b)
{
pcl::tracking::ParticleXYRPY newp;
newp.x = a.x + b.x;
newp.y = 0;
newp.z = a.z + b.z;
newp.roll = a.roll + b.roll;
newp.pitch = a.pitch + b.pitch;
newp.yaw = a.yaw + b.yaw;
return (newp);
}
// a - b
inline pcl::tracking::ParticleXYRPY operator - (const ParticleXYRPY& a, const ParticleXYRPY& b)
{
pcl::tracking::ParticleXYRPY newp;
newp.x = a.x - b.x;
newp.z = a.z - b.z;
newp.y = 0;
newp.roll = a.roll - b.roll;
newp.pitch = a.pitch - b.pitch;
newp.yaw = a.yaw - b.yaw;
return (newp);
}
}
}
//########################################################################33
namespace pcl
{
namespace tracking
{
struct _ParticleXYRP
{
PCL_ADD_POINT4D;
union
{
struct
{
float roll;
float pitch;
float yaw;
float weight;
};
float data_c[4];
};
};
// particle definition
struct EIGEN_ALIGN16 ParticleXYRP : public _ParticleXYRP
{
inline ParticleXYRP ()
{
x = y = z = roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYRP (float _x, float, float _z)
{
x = _x; y = 0; z = _z;
roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYRP (float _x, float, float _z, float, float _pitch, float _yaw)
{
x = _x; y = 0; z = _z;
roll = 0; pitch = _pitch; yaw = _yaw;
data[3] = 1.0f;
}
inline static int
stateDimension () { return 6; }
void
sample (const std::vector<double>& mean, const std::vector<double>& cov)
{
x += static_cast<float> (sampleNormal (mean[0], cov[0]));
y = 0;
z += static_cast<float> (sampleNormal (mean[2], cov[2]));
roll = 0;
pitch += static_cast<float> (sampleNormal (mean[4], cov[4]));
yaw += static_cast<float> (sampleNormal (mean[5], cov[5]));
}
void
zero ()
{
x = 0.0;
y = 0.0;
z = 0.0;
roll = 0.0;
pitch = 0.0;
yaw = 0.0;
}
inline Eigen::Affine3f
toEigenMatrix () const
{
return getTransformation(x, y, z, roll, pitch, yaw);
}
static pcl::tracking::ParticleXYRP
toState (const Eigen::Affine3f &trans)
{
float trans_x, trans_y, trans_z, trans_roll, trans_pitch, trans_yaw;
getTranslationAndEulerAngles (trans,
trans_x, trans_y, trans_z,
trans_roll, trans_pitch, trans_yaw);
return (pcl::tracking::ParticleXYRP (trans_x, 0, trans_z, 0, trans_pitch, trans_yaw));
}
// a[i]
inline float operator [] (unsigned int i)
{
switch (i)
{
case 0: return x;
case 1: return y;
case 2: return z;
case 3: return roll;
case 4: return pitch;
case 5: return yaw;
default: return 0.0;
}
}
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};
inline std::ostream& operator << (std::ostream& os, const ParticleXYRP& p)
{
os << "(" << p.x << "," << p.y << "," << p.z << ","
<< p.roll << "," << p.pitch << "," << p.yaw << ")";
return (os);
}
// a * k
inline pcl::tracking::ParticleXYRP operator * (const ParticleXYRP& p, double val)
{
pcl::tracking::ParticleXYRP newp;
newp.x = static_cast<float> (p.x * val);
newp.y = static_cast<float> (p.y * val);
newp.z = static_cast<float> (p.z * val);
newp.roll = static_cast<float> (p.roll * val);
newp.pitch = static_cast<float> (p.pitch * val);
newp.yaw = static_cast<float> (p.yaw * val);
return (newp);
}
// a + b
inline pcl::tracking::ParticleXYRP operator + (const ParticleXYRP& a, const ParticleXYRP& b)
{
pcl::tracking::ParticleXYRP newp;
newp.x = a.x + b.x;
newp.y = 0;
newp.z = a.z + b.z;
newp.roll = 0;
newp.pitch = a.pitch + b.pitch;
newp.yaw = a.yaw + b.yaw;
return (newp);
}
// a - b
inline pcl::tracking::ParticleXYRP operator - (const ParticleXYRP& a, const ParticleXYRP& b)
{
pcl::tracking::ParticleXYRP newp;
newp.x = a.x - b.x;
newp.z = a.z - b.z;
newp.y = 0;
newp.roll = 0.0;
newp.pitch = a.pitch - b.pitch;
newp.yaw = a.yaw - b.yaw;
return (newp);
}
}
}
//########################################################################33
namespace pcl
{
namespace tracking
{
struct _ParticleXYR
{
PCL_ADD_POINT4D;
union
{
struct
{
float roll;
float pitch;
float yaw;
float weight;
};
float data_c[4];
};
};
// particle definition
struct EIGEN_ALIGN16 ParticleXYR : public _ParticleXYR
{
inline ParticleXYR ()
{
x = y = z = roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYR (float _x, float, float _z)
{
x = _x; y = 0; z = _z;
roll = pitch = yaw = 0.0;
data[3] = 1.0f;
}
inline ParticleXYR (float _x, float, float _z, float, float _pitch, float)
{
x = _x; y = 0; z = _z;
roll = 0; pitch = _pitch; yaw = 0;
data[3] = 1.0f;
}
inline static int
stateDimension () { return 6; }
void
sample (const std::vector<double>& mean, const std::vector<double>& cov)
{
x += static_cast<float> (sampleNormal (mean[0], cov[0]));
y = 0;
z += static_cast<float> (sampleNormal (mean[2], cov[2]));
roll = 0;
pitch += static_cast<float> (sampleNormal (mean[4], cov[4]));
yaw = 0;
}
void
zero ()
{
x = 0.0;
y = 0.0;
z = 0.0;
roll = 0.0;
pitch = 0.0;
yaw = 0.0;
}
inline Eigen::Affine3f
toEigenMatrix () const
{
return getTransformation(x, y, z, roll, pitch, yaw);
}
static pcl::tracking::ParticleXYR
toState (const Eigen::Affine3f &trans)
{
float trans_x, trans_y, trans_z, trans_roll, trans_pitch, trans_yaw;
getTranslationAndEulerAngles (trans,
trans_x, trans_y, trans_z,
trans_roll, trans_pitch, trans_yaw);
return (pcl::tracking::ParticleXYR (trans_x, 0, trans_z, 0, trans_pitch, 0));
}
// a[i]
inline float operator [] (unsigned int i)
{
switch (i)
{
case 0: return x;
case 1: return y;
case 2: return z;
case 3: return roll;
case 4: return pitch;
case 5: return yaw;
default: return 0.0;
}
}
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};
inline std::ostream& operator << (std::ostream& os, const ParticleXYR& p)
{
os << "(" << p.x << "," << p.y << "," << p.z << ","
<< p.roll << "," << p.pitch << "," << p.yaw << ")";
return (os);
}
// a * k
inline pcl::tracking::ParticleXYR operator * (const ParticleXYR& p, double val)
{
pcl::tracking::ParticleXYR newp;
newp.x = static_cast<float> (p.x * val);
newp.y = static_cast<float> (p.y * val);
newp.z = static_cast<float> (p.z * val);
newp.roll = static_cast<float> (p.roll * val);
newp.pitch = static_cast<float> (p.pitch * val);
newp.yaw = static_cast<float> (p.yaw * val);
return (newp);
}
// a + b
inline pcl::tracking::ParticleXYR operator + (const ParticleXYR& a, const ParticleXYR& b)
{
pcl::tracking::ParticleXYR newp;
newp.x = a.x + b.x;
newp.y = 0;
newp.z = a.z + b.z;
newp.roll = 0;
newp.pitch = a.pitch + b.pitch;
newp.yaw = 0.0;
return (newp);
}
// a - b
inline pcl::tracking::ParticleXYR operator - (const ParticleXYR& a, const ParticleXYR& b)
{
pcl::tracking::ParticleXYR newp;
newp.x = a.x - b.x;
newp.z = a.z - b.z;
newp.y = 0;
newp.roll = 0.0;
newp.pitch = a.pitch - b.pitch;
newp.yaw = 0.0;
return (newp);
}
}
}
#define PCL_STATE_POINT_TYPES \
(pcl::tracking::ParticleXYR) \
(pcl::tracking::ParticleXYZRPY) \
(pcl::tracking::ParticleXYZR) \
(pcl::tracking::ParticleXYRPY) \
(pcl::tracking::ParticleXYRP)
#endif //
pcl::tracking::_ParticleXYRP::roll
float roll
Definition: tracking.hpp:483
pcl::tracking::_ParticleXYRP::weight
float weight
Definition: tracking.hpp:486
pcl::tracking::ParticleXYZR::ParticleXYZR
ParticleXYZR()
Definition: tracking.hpp:187
pcl::tracking::_ParticleXYRPY::weight
float weight
Definition: tracking.hpp:333
pcl::tracking::ParticleXYRPY::zero
void zero()
Definition: tracking.hpp:377
pcl::tracking::_ParticleXYR::weight
float weight
Definition: tracking.hpp:639
pcl::tracking::ParticleXYRP::zero
void zero()
Definition: tracking.hpp:530
pcl::tracking::ParticleXYRP::sample
void sample(const std::vector< double > &mean, const std::vector< double > &cov)
Definition: tracking.hpp:519
pcl::tracking::ParticleXYZRPY::ParticleXYZRPY
ParticleXYZRPY(float _x, float _y, float _z, float _roll, float _pitch, float _yaw)
Definition: tracking.hpp:45
pcl::tracking::ParticleXYRPY::ParticleXYRPY
ParticleXYRPY()
Definition: tracking.hpp:342
pcl::tracking::_ParticleXYZR::weight
float weight
Definition: tracking.hpp:178
pcl::tracking::ParticleXYZR::zero
void zero()
Definition: tracking.hpp:222
pcl::tracking::_ParticleXYZR::pitch
float pitch
Definition: tracking.hpp:176
pcl::tracking::ParticleXYRPY::stateDimension
static int stateDimension()
Definition: tracking.hpp:363
pcl::tracking::_ParticleXYRPY
Definition: tracking.hpp:323
pcl::EIGEN_ALIGN16
struct pcl::_PointXYZHSV EIGEN_ALIGN16
pcl::tracking::_ParticleXYR::roll
float roll
Definition: tracking.hpp:636
pcl::tracking::ParticleXYRP::toEigenMatrix
Eigen::Affine3f toEigenMatrix() const
Definition: tracking.hpp:541
pcl::tracking::_ParticleXYZRPY
Definition: tracking.hpp:13
pcl::tracking::_ParticleXYZR::roll
float roll
Definition: tracking.hpp:175
pcl::tracking::ParticleXYR::stateDimension
static int stateDimension()
Definition: tracking.hpp:669
pcl
Definition: cloud_iterator.h:46
pcl::tracking::_ParticleXYZRPY::roll
float roll
Definition: tracking.hpp:20
pcl::tracking::_ParticleXYRPY::roll
float roll
Definition: tracking.hpp:330
pcl::tracking::ParticleXYR
Definition: tracking.hpp:646
pcl::tracking::ParticleXYZRPY::ParticleXYZRPY
ParticleXYZRPY()
Definition: tracking.hpp:32
pcl::tracking::_ParticleXYZRPY::weight
float weight
Definition: tracking.hpp:23
pcl::tracking::_ParticleXYR::yaw
float yaw
Definition: tracking.hpp:638
pcl::tracking::ParticleXYRPY::toState
static pcl::tracking::ParticleXYRPY toState(const Eigen::Affine3f &trans)
Definition: tracking.hpp:394
pcl::tracking::ParticleXYR::ParticleXYR
ParticleXYR(float _x, float, float _z, float, float _pitch, float)
Definition: tracking.hpp:661
pcl::tracking::operator-
pcl::tracking::ParticleXYZRPY operator-(const ParticleXYZRPY &a, const ParticleXYZRPY &b)
Definition: tracking.hpp:145
pcl::tracking::_ParticleXYZRPY::pitch
float pitch
Definition: tracking.hpp:21
pcl::tracking::ParticleXYZR::stateDimension
static int stateDimension()
Definition: tracking.hpp:208
pcl::tracking::ParticleXYZR::toState
static pcl::tracking::ParticleXYZR toState(const Eigen::Affine3f &trans)
Definition: tracking.hpp:239
pcl::tracking::ParticleXYRP::toState
static pcl::tracking::ParticleXYRP toState(const Eigen::Affine3f &trans)
Definition: tracking.hpp:547
pcl::tracking::ParticleXYR::toState
static pcl::tracking::ParticleXYR toState(const Eigen::Affine3f &trans)
Definition: tracking.hpp:700
pcl::tracking::_ParticleXYZRPY::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: tracking.hpp:15
pcl::tracking::ParticleXYZR::toEigenMatrix
Eigen::Affine3f toEigenMatrix() const
Definition: tracking.hpp:233
pcl::tracking::ParticleXYZRPY::ParticleXYZRPY
ParticleXYZRPY(float _x, float _y, float _z)
Definition: tracking.hpp:38
pcl::tracking::ParticleXYZR::sample
void sample(const std::vector< double > &mean, const std::vector< double > &cov)
Definition: tracking.hpp:211
pcl::tracking::_ParticleXYRPY::pitch
float pitch
Definition: tracking.hpp:331
pcl::tracking::_ParticleXYR::pitch
float pitch
Definition: tracking.hpp:637
pcl::tracking::ParticleXYRPY::ParticleXYRPY
ParticleXYRPY(float _x, float, float _z, float _roll, float _pitch, float _yaw)
Definition: tracking.hpp:355
pcl::tracking::ParticleXYRPY
Definition: tracking.hpp:340
pcl::tracking::ParticleXYRP::ParticleXYRP
ParticleXYRP(float _x, float, float _z)
Definition: tracking.hpp:501
pcl::tracking::ParticleXYZRPY::stateDimension
static int stateDimension()
Definition: tracking.hpp:53
pcl::tracking::ParticleXYRP::stateDimension
static int stateDimension()
Definition: tracking.hpp:516
pcl::tracking::ParticleXYRP
Definition: tracking.hpp:493
pcl::tracking::_ParticleXYRP
Definition: tracking.hpp:476
pcl::tracking::ParticleXYZRPY::sample
void sample(const std::vector< double > &mean, const std::vector< double > &cov)
Definition: tracking.hpp:56
pcl::tracking::ParticleXYR::ParticleXYR
ParticleXYR()
Definition: tracking.hpp:648
pcl::getTranslationAndEulerAngles
void getTranslationAndEulerAngles(const Eigen::Transform< Scalar, 3, Eigen::Affine > &t, Scalar &x, Scalar &y, Scalar &z, Scalar &roll, Scalar &pitch, Scalar &yaw)
Extract x,y,z and the Euler angles (XYZ-convention) from the given transformation.
Definition: eigen.hpp:673
pcl::tracking::ParticleXYR::zero
void zero()
Definition: tracking.hpp:683
pcl::tracking::ParticleXYRP::ParticleXYRP
ParticleXYRP(float _x, float, float _z, float, float _pitch, float _yaw)
Definition: tracking.hpp:508
pcl::tracking::ParticleXYZRPY
Definition: tracking.hpp:30
pcl::tracking::ParticleXYRPY::toEigenMatrix
Eigen::Affine3f toEigenMatrix() const
Definition: tracking.hpp:388
pcl::tracking::_ParticleXYZR::yaw
float yaw
Definition: tracking.hpp:177
pcl::tracking::_ParticleXYZRPY::data_c
float data_c[4]
Definition: tracking.hpp:25
pcl::tracking::_ParticleXYRP::yaw
float yaw
Definition: tracking.hpp:485
pcl::tracking::ParticleXYZR::ParticleXYZR
ParticleXYZR(float _x, float _y, float _z, float, float _pitch, float)
Definition: tracking.hpp:200
pcl::tracking::_ParticleXYZRPY::yaw
float yaw
Definition: tracking.hpp:22
pcl::tracking::_ParticleXYZR
Definition: tracking.hpp:168
pcl::tracking::ParticleXYZRPY::toEigenMatrix
Eigen::Affine3f toEigenMatrix() const
Definition: tracking.hpp:78
pcl::getTransformation
void getTransformation(Scalar x, Scalar y, Scalar z, Scalar roll, Scalar pitch, Scalar yaw, Eigen::Transform< Scalar, 3, Eigen::Affine > &t)
Create a transformation from the given translation and Euler angles (XYZ-convention) ...
Definition: eigen.hpp:687
pcl::tracking::ParticleXYZRPY::zero
void zero()
Definition: tracking.hpp:67
pcl::tracking::ParticleXYRP::ParticleXYRP
ParticleXYRP()
Definition: tracking.hpp:495
pcl::tracking::_ParticleXYZR::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: tracking.hpp:170
pcl::tracking::operator*
pcl::tracking::ParticleXYZRPY operator*(const ParticleXYZRPY &p, double val)
Definition: tracking.hpp:119
pcl::tracking::ParticleXYZR::ParticleXYZR
ParticleXYZR(float _x, float _y, float _z)
Definition: tracking.hpp:193
pcl::tracking::_ParticleXYRP::pitch
float pitch
Definition: tracking.hpp:484
pcl::tracking::ParticleXYRPY::sample
void sample(const std::vector< double > &mean, const std::vector< double > &cov)
Definition: tracking.hpp:366
pcl::tracking::operator+
pcl::tracking::ParticleXYZRPY operator+(const ParticleXYZRPY &a, const ParticleXYZRPY &b)
Definition: tracking.hpp:132
pcl::tracking::ParticleXYR::sample
void sample(const std::vector< double > &mean, const std::vector< double > &cov)
Definition: tracking.hpp:672
pcl::tracking::ParticleXYZRPY::toState
static pcl::tracking::ParticleXYZRPY toState(const Eigen::Affine3f &trans)
Definition: tracking.hpp:84
pcl::tracking::operator<<
std::ostream & operator<<(std::ostream &os, const ParticleXYZRPY &p)
Definition: tracking.hpp:111
pcl::tracking::_ParticleXYR
Definition: tracking.hpp:629
pcl::tracking::ParticleXYR::toEigenMatrix
Eigen::Affine3f toEigenMatrix() const
Definition: tracking.hpp:694
pcl::tracking::_ParticleXYRP::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: tracking.hpp:478
pcl::tracking::sampleNormal
PCL_EXPORTS double sampleNormal(double mean, double sigma)
pcl::tracking::_ParticleXYR::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: tracking.hpp:631
pcl::tracking::_ParticleXYRPY::PCL_ADD_POINT4D
PCL_ADD_POINT4D
Definition: tracking.hpp:325
pcl::tracking::ParticleXYR::ParticleXYR
ParticleXYR(float _x, float, float _z)
Definition: tracking.hpp:654
pcl::tracking::_ParticleXYRPY::yaw
float yaw
Definition: tracking.hpp:332
pcl::tracking::ParticleXYZR
Definition: tracking.hpp:185
pcl::tracking::ParticleXYRPY::ParticleXYRPY
ParticleXYRPY(float _x, float, float _z)
Definition: tracking.hpp:348