Pose2f 应该是 BHuman 中的一个比较重要的工具类吧,在代码中经常用到,以前不知道是干啥的,刚才看了下,记录下来。

Src/Tools/Math/Pose2f.h

TODO: 学习类 Angle、Pose3f、Vector2f(我猜是个类似于vector的容器,不过里面存的东西要仔细研究下)等。
ADD: Pose3f 与 Pose2f 大致相同,不过使用了 Vector3f,多了一个 z 作为参数。。。
在 Vector2f 的变量中还可以调用 angle() 函数,猜想:应该这两个类中有这个方法。
在 Egien.h 中只看到了一些容器的声明,引入了头文件 Egien/Dense,看了下,应该是 naoqi 的库中带的。
ADD: 刚才看代码的过程中发现,有下面这两句:图像中的位置 Vector2i(image),场地中的位置 Vector2f(field)。

1
2
(Vector2i)(Vector2i::Zero()) positionInImage, /**< Position in the image. 在图像中的位置 */
(Vector2f)(Vector2f::Zero()) positionOnField, /**< Position relative to robot on the field. 在场地中的位置 */

成员变量

1
2
3
4
// Angle是类型,0是默认值,rotation是变量名。
(Angle)(0) rotation, /** rotation 旋转/转动 */
// 同上,还有就是在BHuman中的流式结构体中经常看到这种的变量声明,包括以后自己添加也是要按照这样的规范来写。
(Vector2f)(Vector2f::Zero()) translation, /** translation 转化 */

构造函数

声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 构造函数,默认
Pose2f() = default;
// 拷贝构造,默认
Pose2f(const Pose2f& other) = default;
// 传入两个float类型的变量x,y。
Pose2f(const float x, const float y);
// 传入一个Vector2f对象的引用,至于这个对象是干啥的,我再看看。。。我的猜想是从这个转换到这个。。。哈哈哈
Pose2f(const Vector2f& translation);
// 传入一个Angle(角度)
Pose2f(const Angle rotation);

Pose2f(const Angle rotation, const Vector2f& translation);
Pose2f(const Angle rotation, const float x, const float y);
Pose2f(const float rot, const float x, const float y);

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
inline Pose2f::Pose2f(const float x, const float y) :
translation(x, y){}

inline Pose2f::Pose2f(const Vector2f& translation) :
translation(translation){}

inline Pose2f::Pose2f(const Angle rotation) :
rotation(rotation){}

inline Pose2f::Pose2f(const Angle rotation, const Vector2f& translation) :
rotation(rotation), translation(translation){}

inline Pose2f::Pose2f(const Angle rotation, const float x, const float y) :
rotation(rotation), translation(x, y){}

inline Pose2f::Pose2f(const float rot, const float x, const float y) :
rotation(rot), translation(x, y){}

操作符重载

声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
Pose2f& operator=(const Pose2f& other) = default;

Vector2f operator*(const Vector2f& other) const;

/**
* Concatenation of this pose with another. The resulting rotation is not normalized!
* 这个姿势和另一个 pose 的串联。结果的旋转没有标准化!
* Use operator+ / operator+= for normalized(标准化的) rotations(旋转).
*/
Pose2f operator*(const Pose2f& other) const;
Pose2f& operator*=(const Pose2f& other);

/**
* Concatenation of this pose with another pose. The resulting rotation is not normalized!
* 这个姿势和另一个 pose 的连接。结果的旋转没有标准化!
*/
Pose2f operator+(const Pose2f& other) const;
Pose2f& operator+=(const Pose2f& other);

/**
* Difference of this pose relative to another pose. So if A+B=C is the addition/concatenation, this calculates C-A=B.
* 这个姿势相对于另一个 pose 的不同之处。如果A+B=C是加法/串联,这就计算出C-A=B。
*
* @param other The other pose that will be used as origin for the new pose.
* @return A reference to this pose after calculating the difference.
*/
Pose2f& operator-=(const Pose2f& other);

/**
* Difference of this pose relative to another pose.
* 这个姿势相对于另一个 pose 的不同之处。
*
* @param other The other pose that will be used as origin for the new pose.
* @return The resulting pose.
*/
Pose2f operator-(const Pose2f& other) const;

/** unary minus */
Pose2f operator-() const;

/**
* Comparison of another pose with this one.
* 比较另一个 pose 和这个。
*
* @param other The other pose that will be compared to this one
* @return Whether the two poses are equal.
*/
bool operator==(const Pose2f& other) const;

/**
* Comparison of another pose with this one.
* 比较另一个 pose 和这个。
*
* @param other The other pose that will be compared to this one
* @return Whether the two poses are unequal.
*/
bool operator!=(const Pose2f& other) const;

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
inline Vector2f Pose2f::operator*(const Vector2f& other) const
{
const float s = std::sin(rotation);
const float c = std::cos(rotation);
return (Vector2f(other.x() * c - other.y() * s, other.x() * s + other.y() * c) + translation);
}

inline Pose2f Pose2f::operator*(const Pose2f& other) const
{
return Pose2f(*this) *= other;
}

inline Pose2f& Pose2f::operator*=(const Pose2f& other)
{
translation = *this * other.translation;
rotation += other.rotation;
rotation.normalize();
return *this;
}

inline Pose2f Pose2f::operator+(const Pose2f& other) const
{
return Pose2f(*this) += other;
}

inline Pose2f& Pose2f::operator+=(const Pose2f& other)
{
translation = *this * other.translation;
rotation += other.rotation;
rotation.normalize();
return *this;
}

inline Pose2f& Pose2f::operator-=(const Pose2f& other)
{
translation -= other.translation;
Pose2f p(-other.rotation);
return *this = p + *this;
}

inline Pose2f Pose2f::operator-(const Pose2f& other) const
{
return Pose2f(*this) -= other;
}

inline Pose2f Pose2f::operator-() const
{
return Pose2f() - (*this);
}

inline bool Pose2f::operator==(const Pose2f& other) const
{
return ((translation == other.translation) && (rotation == other.rotation));
}

inline bool Pose2f::operator!=(const Pose2f& other) const
{
return !(Pose2f(*this) == other);
}

成员函数

声明

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Pose2f& translate(const Vector2f& trans);
Pose2f& translate(const float x, const float y);
Pose2f& rotate(const Angle& rot);

/** Inverts this pose and returns reference to this.
* 反转此pose并返回对该位姿的引用。*/
Pose2f& invert();
/** Calculates the inverse transformation of this pose
* 计算这个位姿的逆变换*/
Pose2f inverse() const;

Pose2f dotMirror() const;

bool isFinite() const;

/**
* The function creates a random pose.
* 该函数创建一个随机的姿态。
* @param x The range for x-values of the pose.
* @param y The range for y-values of the pose.
* @param angle The range for the rotation of the pose.
*/
static Pose2f random(const Rangef& angle, const Rangef& x, const Rangef& y),

实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
inline Pose2f& Pose2f::translate(const Vector2f& trans)
{
translation = *this * trans;
return *this;
}

inline Pose2f& Pose2f::translate(const float x, const float y)
{
translation = *this * Vector2f(x, y);
return *this;
}

inline Pose2f& Pose2f::rotate(const Angle& rot)
{
rotation += rot;
return *this;
}

inline Pose2f& Pose2f::invert()
{
rotation = -rotation;
const Vector2f trans = -translation;
translation = Eigen::Rotation2D<float>(rotation) * trans;
return *this;
}

inline Pose2f Pose2f::inverse() const
{
return Pose2f(*this).invert();
}

inline Pose2f Pose2f::dotMirror() const
{
return Pose2f(Angle::normalize(rotation + pi), -translation);
}

inline bool Pose2f::isFinite() const
{
return std::isfinite(translation.x()) && std::isfinite(translation.y()) && std::isfinite(rotation);
}

inline Pose2f Pose2f::random(const Rangef& angle, const Rangef& x, const Rangef& y)
{
return Pose2f(Random::uniform(angle.min, angle.max), Vector2f(Random::uniform(x.min, x.max), Random::uniform(y.min, y.max)));
}