14459937051

Committed 15 Apr 2025 02:29AM UTC coverage: 44.201% (-0.1%) from 44.296%

Build # 14459937051

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #2538 from Luc-Meunier/vio

mocap: Add vision speed estimate

Run Details

0 of 63 new or added lines in 2 files covered. (0.0%)

7 existing lines in 2 files now uncovered.

14603 of 33038 relevant lines covered (44.2%)

281.89 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/mavsdk/plugins/mocap/mocap.cpp

// WARNING: THIS FILE IS AUTOGENERATED! As such, it should not be edited.
// Edits need to be made to the proto files
// (see https://github.com/mavlink/MAVSDK-Proto/blob/master/protos/mocap/mocap.proto)

#include <iomanip>

#include "mocap_impl.h"
#include "plugins/mocap/mocap.h"

namespace mavsdk {

using PositionBody = Mocap::PositionBody;
using AngleBody = Mocap::AngleBody;
using SpeedBody = Mocap::SpeedBody;
using SpeedNed = Mocap::SpeedNed;
using AngularVelocityBody = Mocap::AngularVelocityBody;
using Covariance = Mocap::Covariance;
using Quaternion = Mocap::Quaternion;
using VisionPositionEstimate = Mocap::VisionPositionEstimate;
using VisionSpeedEstimate = Mocap::VisionSpeedEstimate;
using AttitudePositionMocap = Mocap::AttitudePositionMocap;
using Odometry = Mocap::Odometry;

Mocap::Mocap(System& system) : PluginBase(), _impl{std::make_unique<MocapImpl>(system)} {}

Mocap::Mocap(std::shared_ptr<System> system) :
    PluginBase(),
    _impl{std::make_unique<MocapImpl>(system)}
{}

Mocap::~Mocap() {}

Mocap::Result
Mocap::set_vision_position_estimate(VisionPositionEstimate vision_position_estimate) const
{
    return _impl->set_vision_position_estimate(vision_position_estimate);
}

Mocap::Result Mocap::set_vision_speed_estimate(VisionSpeedEstimate vision_speed_estimate) const
{
    return _impl->set_vision_speed_estimate(vision_speed_estimate);
}

Mocap::Result
Mocap::set_attitude_position_mocap(AttitudePositionMocap attitude_position_mocap) const
{
    return _impl->set_attitude_position_mocap(attitude_position_mocap);
}

Mocap::Result Mocap::set_odometry(Odometry odometry) const
{
    return _impl->set_odometry(odometry);
}

bool operator==(const Mocap::PositionBody& lhs, const Mocap::PositionBody& rhs)
{
    return ((std::isnan(rhs.x_m) && std::isnan(lhs.x_m)) || rhs.x_m == lhs.x_m) &&
           ((std::isnan(rhs.y_m) && std::isnan(lhs.y_m)) || rhs.y_m == lhs.y_m) &&
           ((std::isnan(rhs.z_m) && std::isnan(lhs.z_m)) || rhs.z_m == lhs.z_m);
}

std::ostream& operator<<(std::ostream& str, Mocap::PositionBody const& position_body)
{
    str << std::setprecision(15);
    str << "position_body:" << '\n' << "{\n";
    str << "    x_m: " << position_body.x_m << '\n';
    str << "    y_m: " << position_body.y_m << '\n';
    str << "    z_m: " << position_body.z_m << '\n';
    str << '}';
    return str;
}

bool operator==(const Mocap::AngleBody& lhs, const Mocap::AngleBody& rhs)
{
    return ((std::isnan(rhs.roll_rad) && std::isnan(lhs.roll_rad)) ||
            rhs.roll_rad == lhs.roll_rad) &&
           ((std::isnan(rhs.pitch_rad) && std::isnan(lhs.pitch_rad)) ||
            rhs.pitch_rad == lhs.pitch_rad) &&
           ((std::isnan(rhs.yaw_rad) && std::isnan(lhs.yaw_rad)) || rhs.yaw_rad == lhs.yaw_rad);
}

std::ostream& operator<<(std::ostream& str, Mocap::AngleBody const& angle_body)
{
    str << std::setprecision(15);
    str << "angle_body:" << '\n' << "{\n";
    str << "    roll_rad: " << angle_body.roll_rad << '\n';
    str << "    pitch_rad: " << angle_body.pitch_rad << '\n';
    str << "    yaw_rad: " << angle_body.yaw_rad << '\n';
    str << '}';
    return str;
}

bool operator==(const Mocap::SpeedBody& lhs, const Mocap::SpeedBody& rhs)
{
    return ((std::isnan(rhs.x_m_s) && std::isnan(lhs.x_m_s)) || rhs.x_m_s == lhs.x_m_s) &&
           ((std::isnan(rhs.y_m_s) && std::isnan(lhs.y_m_s)) || rhs.y_m_s == lhs.y_m_s) &&
           ((std::isnan(rhs.z_m_s) && std::isnan(lhs.z_m_s)) || rhs.z_m_s == lhs.z_m_s);
}

std::ostream& operator<<(std::ostream& str, Mocap::SpeedBody const& speed_body)
{
    str << std::setprecision(15);
    str << "speed_body:" << '\n' << "{\n";
    str << "    x_m_s: " << speed_body.x_m_s << '\n';
    str << "    y_m_s: " << speed_body.y_m_s << '\n';
    str << "    z_m_s: " << speed_body.z_m_s << '\n';
    str << '}';
    return str;
}

bool operator==(const Mocap::SpeedNed& lhs, const Mocap::SpeedNed& rhs)
{
    return ((std::isnan(rhs.north_m_s) && std::isnan(lhs.north_m_s)) ||
            rhs.north_m_s == lhs.north_m_s) &&
           ((std::isnan(rhs.east_m_s) && std::isnan(lhs.east_m_s)) ||
            rhs.east_m_s == lhs.east_m_s) &&
           ((std::isnan(rhs.down_m_s) && std::isnan(lhs.down_m_s)) || rhs.down_m_s == lhs.down_m_s);
}

std::ostream& operator<<(std::ostream& str, Mocap::SpeedNed const& speed_ned)
{
    str << std::setprecision(15);
    str << "speed_ned:" << '\n' << "{\n";
    str << "    north_m_s: " << speed_ned.north_m_s << '\n';
    str << "    east_m_s: " << speed_ned.east_m_s << '\n';
    str << "    down_m_s: " << speed_ned.down_m_s << '\n';
    str << '}';
    return str;
}

bool operator==(const Mocap::AngularVelocityBody& lhs, const Mocap::AngularVelocityBody& rhs)
{
    return ((std::isnan(rhs.roll_rad_s) && std::isnan(lhs.roll_rad_s)) ||
            rhs.roll_rad_s == lhs.roll_rad_s) &&
           ((std::isnan(rhs.pitch_rad_s) && std::isnan(lhs.pitch_rad_s)) ||
            rhs.pitch_rad_s == lhs.pitch_rad_s) &&
           ((std::isnan(rhs.yaw_rad_s) && std::isnan(lhs.yaw_rad_s)) ||
            rhs.yaw_rad_s == lhs.yaw_rad_s);
}

std::ostream& operator<<(std::ostream& str, Mocap::AngularVelocityBody const& angular_velocity_body)
{
    str << std::setprecision(15);
    str << "angular_velocity_body:" << '\n' << "{\n";
    str << "    roll_rad_s: " << angular_velocity_body.roll_rad_s << '\n';
    str << "    pitch_rad_s: " << angular_velocity_body.pitch_rad_s << '\n';
    str << "    yaw_rad_s: " << angular_velocity_body.yaw_rad_s << '\n';
    str << '}';
    return str;
}

bool operator==(const Mocap::Covariance& lhs, const Mocap::Covariance& rhs)
{
    return (rhs.covariance_matrix == lhs.covariance_matrix);
}

std::ostream& operator<<(std::ostream& str, Mocap::Covariance const& covariance)
{
    str << std::setprecision(15);
    str << "covariance:" << '\n' << "{\n";
    str << "    covariance_matrix: [";
    for (auto it = covariance.covariance_matrix.begin(); it != covariance.covariance_matrix.end();
         ++it) {
        str << *it;
        str << (it + 1 != covariance.covariance_matrix.end() ? ", " : "]\n");
    }
    str << '}';
    return str;
}

bool operator==(const Mocap::Quaternion& lhs, const Mocap::Quaternion& rhs)
{
    return ((std::isnan(rhs.w) && std::isnan(lhs.w)) || rhs.w == lhs.w) &&
           ((std::isnan(rhs.x) && std::isnan(lhs.x)) || rhs.x == lhs.x) &&
           ((std::isnan(rhs.y) && std::isnan(lhs.y)) || rhs.y == lhs.y) &&
           ((std::isnan(rhs.z) && std::isnan(lhs.z)) || rhs.z == lhs.z);
}

std::ostream& operator<<(std::ostream& str, Mocap::Quaternion const& quaternion)
{
    str << std::setprecision(15);
    str << "quaternion:" << '\n' << "{\n";
    str << "    w: " << quaternion.w << '\n';
    str << "    x: " << quaternion.x << '\n';
    str << "    y: " << quaternion.y << '\n';
    str << "    z: " << quaternion.z << '\n';
    str << '}';
    return str;
}

bool operator==(const Mocap::VisionPositionEstimate& lhs, const Mocap::VisionPositionEstimate& rhs)
{
    return (rhs.time_usec == lhs.time_usec) && (rhs.position_body == lhs.position_body) &&
           (rhs.angle_body == lhs.angle_body) && (rhs.pose_covariance == lhs.pose_covariance);
}

std::ostream&
operator<<(std::ostream& str, Mocap::VisionPositionEstimate const& vision_position_estimate)
{
    str << std::setprecision(15);
    str << "vision_position_estimate:" << '\n' << "{\n";
    str << "    time_usec: " << vision_position_estimate.time_usec << '\n';
    str << "    position_body: " << vision_position_estimate.position_body << '\n';
    str << "    angle_body: " << vision_position_estimate.angle_body << '\n';
    str << "    pose_covariance: " << vision_position_estimate.pose_covariance << '\n';
    str << '}';
    return str;
}

bool operator==(const Mocap::VisionSpeedEstimate& lhs, const Mocap::VisionSpeedEstimate& rhs)
{
    return (rhs.time_usec == lhs.time_usec) && (rhs.speed_ned == lhs.speed_ned) &&
           (rhs.speed_covariance == lhs.speed_covariance);
}

std::ostream& operator<<(std::ostream& str, Mocap::VisionSpeedEstimate const& vision_speed_estimate)
{
    str << std::setprecision(15);
    str << "vision_speed_estimate:" << '\n' << "{\n";
    str << "    time_usec: " << vision_speed_estimate.time_usec << '\n';
    str << "    speed_ned: " << vision_speed_estimate.speed_ned << '\n';
    str << "    speed_covariance: " << vision_speed_estimate.speed_covariance << '\n';
    str << '}';
    return str;
}

bool operator==(const Mocap::AttitudePositionMocap& lhs, const Mocap::AttitudePositionMocap& rhs)
{
    return (rhs.time_usec == lhs.time_usec) && (rhs.q == lhs.q) &&
           (rhs.position_body == lhs.position_body) && (rhs.pose_covariance == lhs.pose_covariance);
}

std::ostream&
operator<<(std::ostream& str, Mocap::AttitudePositionMocap const& attitude_position_mocap)
{
    str << std::setprecision(15);
    str << "attitude_position_mocap:" << '\n' << "{\n";
    str << "    time_usec: " << attitude_position_mocap.time_usec << '\n';
    str << "    q: " << attitude_position_mocap.q << '\n';
    str << "    position_body: " << attitude_position_mocap.position_body << '\n';
    str << "    pose_covariance: " << attitude_position_mocap.pose_covariance << '\n';
    str << '}';
    return str;
}

std::ostream& operator<<(std::ostream& str, Mocap::Odometry::MavFrame const& mav_frame)
{
    switch (mav_frame) {
        case Mocap::Odometry::MavFrame::MocapNed:
            return str << "Mocap Ned";
        case Mocap::Odometry::MavFrame::LocalFrd:
            return str << "Local Frd";
        default:
            return str << "Unknown";
    }
}
bool operator==(const Mocap::Odometry& lhs, const Mocap::Odometry& rhs)
{
    return (rhs.time_usec == lhs.time_usec) && (rhs.frame_id == lhs.frame_id) &&
           (rhs.position_body == lhs.position_body) && (rhs.q == lhs.q) &&
           (rhs.speed_body == lhs.speed_body) &&
           (rhs.angular_velocity_body == lhs.angular_velocity_body) &&
           (rhs.pose_covariance == lhs.pose_covariance) &&
           (rhs.velocity_covariance == lhs.velocity_covariance);
}

std::ostream& operator<<(std::ostream& str, Mocap::Odometry const& odometry)
{
    str << std::setprecision(15);
    str << "odometry:" << '\n' << "{\n";
    str << "    time_usec: " << odometry.time_usec << '\n';
    str << "    frame_id: " << odometry.frame_id << '\n';
    str << "    position_body: " << odometry.position_body << '\n';
    str << "    q: " << odometry.q << '\n';
    str << "    speed_body: " << odometry.speed_body << '\n';
    str << "    angular_velocity_body: " << odometry.angular_velocity_body << '\n';
    str << "    pose_covariance: " << odometry.pose_covariance << '\n';
    str << "    velocity_covariance: " << odometry.velocity_covariance << '\n';
    str << '}';
    return str;
}

std::ostream& operator<<(std::ostream& str, Mocap::Result const& result)
{
    switch (result) {
        case Mocap::Result::Unknown:
            return str << "Unknown";
        case Mocap::Result::Success:
            return str << "Success";
        case Mocap::Result::NoSystem:
            return str << "No System";
        case Mocap::Result::ConnectionError:
            return str << "Connection Error";
        case Mocap::Result::InvalidRequestData:
            return str << "Invalid Request Data";
        case Mocap::Result::Unsupported:
            return str << "Unsupported";
        default:
            return str << "Unknown";
    }
}

} // namespace mavsdk

1	// WARNING: THIS FILE IS AUTOGENERATED! As such, it should not be edited.
2	// Edits need to be made to the proto files
3	// (see https://github.com/mavlink/MAVSDK-Proto/blob/master/protos/mocap/mocap.proto)
4
5	#include <iomanip>
6
7	#include "mocap_impl.h"
8	#include "plugins/mocap/mocap.h"
9
10	namespace mavsdk {
11
12	using PositionBody = Mocap::PositionBody;
13	using AngleBody = Mocap::AngleBody;
14	using SpeedBody = Mocap::SpeedBody;
15	using SpeedNed = Mocap::SpeedNed;
16	using AngularVelocityBody = Mocap::AngularVelocityBody;
17	using Covariance = Mocap::Covariance;
18	using Quaternion = Mocap::Quaternion;
19	using VisionPositionEstimate = Mocap::VisionPositionEstimate;
20	using VisionSpeedEstimate = Mocap::VisionSpeedEstimate;
21	using AttitudePositionMocap = Mocap::AttitudePositionMocap;
22	using Odometry = Mocap::Odometry;
23
24	Mocap::Mocap(System& system) : PluginBase(), _impl{std::make_unique<MocapImpl>(system)} {}	×
25
26	Mocap::Mocap(std::shared_ptr<System> system) :	×
27	PluginBase(),
28	_impl{std::make_unique<MocapImpl>(system)}	×
29	{}	×
30
31	Mocap::~Mocap() {}	×
32
33	Mocap::Result
34	Mocap::set_vision_position_estimate(VisionPositionEstimate vision_position_estimate) const	×
35	{
36	return _impl->set_vision_position_estimate(vision_position_estimate);	×
37	}
38
NEW 39	Mocap::Result Mocap::set_vision_speed_estimate(VisionSpeedEstimate vision_speed_estimate) const	×
40	{
NEW 41	return _impl->set_vision_speed_estimate(vision_speed_estimate);	×
42	}
43
44	Mocap::Result
45	Mocap::set_attitude_position_mocap(AttitudePositionMocap attitude_position_mocap) const	×
46	{
47	return _impl->set_attitude_position_mocap(attitude_position_mocap);	×
48	}
49
50	Mocap::Result Mocap::set_odometry(Odometry odometry) const	×
51	{
52	return _impl->set_odometry(odometry);	×
53	}
54
55	bool operator==(const Mocap::PositionBody& lhs, const Mocap::PositionBody& rhs)	×
56	{
57	return ((std::isnan(rhs.x_m) && std::isnan(lhs.x_m)) \|\| rhs.x_m == lhs.x_m) &&	×
58	((std::isnan(rhs.y_m) && std::isnan(lhs.y_m)) \|\| rhs.y_m == lhs.y_m) &&	×
59	((std::isnan(rhs.z_m) && std::isnan(lhs.z_m)) \|\| rhs.z_m == lhs.z_m);	×
60	}
61
62	std::ostream& operator<<(std::ostream& str, Mocap::PositionBody const& position_body)	×
63	{
64	str << std::setprecision(15);	×
65	str << "position_body:" << '\n' << "{\n";	×
66	str << " x_m: " << position_body.x_m << '\n';	×
67	str << " y_m: " << position_body.y_m << '\n';	×
68	str << " z_m: " << position_body.z_m << '\n';	×
69	str << '}';	×
70	return str;	×
71	}
72
73	bool operator==(const Mocap::AngleBody& lhs, const Mocap::AngleBody& rhs)	×
74	{
75	return ((std::isnan(rhs.roll_rad) && std::isnan(lhs.roll_rad)) \|\|	×
76	rhs.roll_rad == lhs.roll_rad) &&	×
77	((std::isnan(rhs.pitch_rad) && std::isnan(lhs.pitch_rad)) \|\|	×
78	rhs.pitch_rad == lhs.pitch_rad) &&	×
79	((std::isnan(rhs.yaw_rad) && std::isnan(lhs.yaw_rad)) \|\| rhs.yaw_rad == lhs.yaw_rad);	×
80	}
81
82	std::ostream& operator<<(std::ostream& str, Mocap::AngleBody const& angle_body)	×
83	{
84	str << std::setprecision(15);	×
85	str << "angle_body:" << '\n' << "{\n";	×
86	str << " roll_rad: " << angle_body.roll_rad << '\n';	×
87	str << " pitch_rad: " << angle_body.pitch_rad << '\n';	×
88	str << " yaw_rad: " << angle_body.yaw_rad << '\n';	×
89	str << '}';	×
90	return str;	×
91	}
92
93	bool operator==(const Mocap::SpeedBody& lhs, const Mocap::SpeedBody& rhs)	×
94	{
95	return ((std::isnan(rhs.x_m_s) && std::isnan(lhs.x_m_s)) \|\| rhs.x_m_s == lhs.x_m_s) &&	×
96	((std::isnan(rhs.y_m_s) && std::isnan(lhs.y_m_s)) \|\| rhs.y_m_s == lhs.y_m_s) &&	×
97	((std::isnan(rhs.z_m_s) && std::isnan(lhs.z_m_s)) \|\| rhs.z_m_s == lhs.z_m_s);	×
98	}
99
100	std::ostream& operator<<(std::ostream& str, Mocap::SpeedBody const& speed_body)	×
101	{
102	str << std::setprecision(15);	×
103	str << "speed_body:" << '\n' << "{\n";	×
104	str << " x_m_s: " << speed_body.x_m_s << '\n';	×
105	str << " y_m_s: " << speed_body.y_m_s << '\n';	×
106	str << " z_m_s: " << speed_body.z_m_s << '\n';	×
107	str << '}';	×
108	return str;	×
109	}
110
NEW 111	bool operator==(const Mocap::SpeedNed& lhs, const Mocap::SpeedNed& rhs)	×
112	{
NEW 113	return ((std::isnan(rhs.north_m_s) && std::isnan(lhs.north_m_s)) \|\|	×
NEW 114	rhs.north_m_s == lhs.north_m_s) &&	×
NEW 115	((std::isnan(rhs.east_m_s) && std::isnan(lhs.east_m_s)) \|\|	×
NEW 116	rhs.east_m_s == lhs.east_m_s) &&	×
NEW 117	((std::isnan(rhs.down_m_s) && std::isnan(lhs.down_m_s)) \|\| rhs.down_m_s == lhs.down_m_s);	×
118	}
119
NEW 120	std::ostream& operator<<(std::ostream& str, Mocap::SpeedNed const& speed_ned)	×
121	{
NEW 122	str << std::setprecision(15);	×
NEW 123	str << "speed_ned:" << '\n' << "{\n";	×
NEW 124	str << " north_m_s: " << speed_ned.north_m_s << '\n';	×
NEW 125	str << " east_m_s: " << speed_ned.east_m_s << '\n';	×
NEW 126	str << " down_m_s: " << speed_ned.down_m_s << '\n';	×
NEW 127	str << '}';	×
NEW 128	return str;	×
129	}
130
UNCOV 131	bool operator==(const Mocap::AngularVelocityBody& lhs, const Mocap::AngularVelocityBody& rhs)	×
132	{
133	return ((std::isnan(rhs.roll_rad_s) && std::isnan(lhs.roll_rad_s)) \|\|	×
134	rhs.roll_rad_s == lhs.roll_rad_s) &&	×
135	((std::isnan(rhs.pitch_rad_s) && std::isnan(lhs.pitch_rad_s)) \|\|	×
136	rhs.pitch_rad_s == lhs.pitch_rad_s) &&	×
137	((std::isnan(rhs.yaw_rad_s) && std::isnan(lhs.yaw_rad_s)) \|\|	×
138	rhs.yaw_rad_s == lhs.yaw_rad_s);	×
139	}
140
141	std::ostream& operator<<(std::ostream& str, Mocap::AngularVelocityBody const& angular_velocity_body)	×
142	{
143	str << std::setprecision(15);	×
144	str << "angular_velocity_body:" << '\n' << "{\n";	×
145	str << " roll_rad_s: " << angular_velocity_body.roll_rad_s << '\n';	×
146	str << " pitch_rad_s: " << angular_velocity_body.pitch_rad_s << '\n';	×
147	str << " yaw_rad_s: " << angular_velocity_body.yaw_rad_s << '\n';	×
148	str << '}';	×
149	return str;	×
150	}
151
152	bool operator==(const Mocap::Covariance& lhs, const Mocap::Covariance& rhs)	×
153	{
154	return (rhs.covariance_matrix == lhs.covariance_matrix);	×
155	}
156
157	std::ostream& operator<<(std::ostream& str, Mocap::Covariance const& covariance)	×
158	{
159	str << std::setprecision(15);	×
160	str << "covariance:" << '\n' << "{\n";	×
161	str << " covariance_matrix: [";	×
162	for (auto it = covariance.covariance_matrix.begin(); it != covariance.covariance_matrix.end();	×
163	++it) {	×
164	str << *it;	×
165	str << (it + 1 != covariance.covariance_matrix.end() ? ", " : "]\n");	×
166	}
167	str << '}';	×
168	return str;	×
169	}
170
171	bool operator==(const Mocap::Quaternion& lhs, const Mocap::Quaternion& rhs)	×
172	{
173	return ((std::isnan(rhs.w) && std::isnan(lhs.w)) \|\| rhs.w == lhs.w) &&	×
174	((std::isnan(rhs.x) && std::isnan(lhs.x)) \|\| rhs.x == lhs.x) &&	×
175	((std::isnan(rhs.y) && std::isnan(lhs.y)) \|\| rhs.y == lhs.y) &&	×
176	((std::isnan(rhs.z) && std::isnan(lhs.z)) \|\| rhs.z == lhs.z);	×
177	}
178
179	std::ostream& operator<<(std::ostream& str, Mocap::Quaternion const& quaternion)	×
180	{
181	str << std::setprecision(15);	×
182	str << "quaternion:" << '\n' << "{\n";	×
183	str << " w: " << quaternion.w << '\n';	×
184	str << " x: " << quaternion.x << '\n';	×
185	str << " y: " << quaternion.y << '\n';	×
186	str << " z: " << quaternion.z << '\n';	×
187	str << '}';	×
188	return str;	×
189	}
190
191	bool operator==(const Mocap::VisionPositionEstimate& lhs, const Mocap::VisionPositionEstimate& rhs)	×
192	{
193	return (rhs.time_usec == lhs.time_usec) && (rhs.position_body == lhs.position_body) &&	×
194	(rhs.angle_body == lhs.angle_body) && (rhs.pose_covariance == lhs.pose_covariance);	×
195	}
196
197	std::ostream&
198	operator<<(std::ostream& str, Mocap::VisionPositionEstimate const& vision_position_estimate)	×
199	{
200	str << std::setprecision(15);	×
201	str << "vision_position_estimate:" << '\n' << "{\n";	×
202	str << " time_usec: " << vision_position_estimate.time_usec << '\n';	×
203	str << " position_body: " << vision_position_estimate.position_body << '\n';	×
204	str << " angle_body: " << vision_position_estimate.angle_body << '\n';	×
205	str << " pose_covariance: " << vision_position_estimate.pose_covariance << '\n';	×
206	str << '}';	×
207	return str;	×
208	}
209
NEW 210	bool operator==(const Mocap::VisionSpeedEstimate& lhs, const Mocap::VisionSpeedEstimate& rhs)	×
211	{
NEW 212	return (rhs.time_usec == lhs.time_usec) && (rhs.speed_ned == lhs.speed_ned) &&	×
NEW 213	(rhs.speed_covariance == lhs.speed_covariance);	×
214	}
215
NEW 216	std::ostream& operator<<(std::ostream& str, Mocap::VisionSpeedEstimate const& vision_speed_estimate)	×
217	{
NEW 218	str << std::setprecision(15);	×
NEW 219	str << "vision_speed_estimate:" << '\n' << "{\n";	×
NEW 220	str << " time_usec: " << vision_speed_estimate.time_usec << '\n';	×
NEW 221	str << " speed_ned: " << vision_speed_estimate.speed_ned << '\n';	×
NEW 222	str << " speed_covariance: " << vision_speed_estimate.speed_covariance << '\n';	×
NEW 223	str << '}';	×
NEW 224	return str;	×
225	}
226
UNCOV 227	bool operator==(const Mocap::AttitudePositionMocap& lhs, const Mocap::AttitudePositionMocap& rhs)	×
228	{
229	return (rhs.time_usec == lhs.time_usec) && (rhs.q == lhs.q) &&	×
230	(rhs.position_body == lhs.position_body) && (rhs.pose_covariance == lhs.pose_covariance);	×
231	}
232
233	std::ostream&
234	operator<<(std::ostream& str, Mocap::AttitudePositionMocap const& attitude_position_mocap)	×
235	{
236	str << std::setprecision(15);	×
237	str << "attitude_position_mocap:" << '\n' << "{\n";	×
238	str << " time_usec: " << attitude_position_mocap.time_usec << '\n';	×
239	str << " q: " << attitude_position_mocap.q << '\n';	×
240	str << " position_body: " << attitude_position_mocap.position_body << '\n';	×
241	str << " pose_covariance: " << attitude_position_mocap.pose_covariance << '\n';	×
242	str << '}';	×
243	return str;	×
244	}
245
246	std::ostream& operator<<(std::ostream& str, Mocap::Odometry::MavFrame const& mav_frame)	×
247	{
248	switch (mav_frame) {	×
249	case Mocap::Odometry::MavFrame::MocapNed:	×
250	return str << "Mocap Ned";	×
251	case Mocap::Odometry::MavFrame::LocalFrd:	×
252	return str << "Local Frd";	×
253	default:	×
254	return str << "Unknown";	×
255	}
256	}
257	bool operator==(const Mocap::Odometry& lhs, const Mocap::Odometry& rhs)	×
258	{
259	return (rhs.time_usec == lhs.time_usec) && (rhs.frame_id == lhs.frame_id) &&	×
260	(rhs.position_body == lhs.position_body) && (rhs.q == lhs.q) &&	×
261	(rhs.speed_body == lhs.speed_body) &&	×
262	(rhs.angular_velocity_body == lhs.angular_velocity_body) &&	×
263	(rhs.pose_covariance == lhs.pose_covariance) &&	×
264	(rhs.velocity_covariance == lhs.velocity_covariance);	×
265	}
266
267	std::ostream& operator<<(std::ostream& str, Mocap::Odometry const& odometry)	×
268	{
269	str << std::setprecision(15);	×
270	str << "odometry:" << '\n' << "{\n";	×
271	str << " time_usec: " << odometry.time_usec << '\n';	×
272	str << " frame_id: " << odometry.frame_id << '\n';	×
273	str << " position_body: " << odometry.position_body << '\n';	×
274	str << " q: " << odometry.q << '\n';	×
275	str << " speed_body: " << odometry.speed_body << '\n';	×
276	str << " angular_velocity_body: " << odometry.angular_velocity_body << '\n';	×
277	str << " pose_covariance: " << odometry.pose_covariance << '\n';	×
278	str << " velocity_covariance: " << odometry.velocity_covariance << '\n';	×
279	str << '}';	×
280	return str;	×
281	}
282
283	std::ostream& operator<<(std::ostream& str, Mocap::Result const& result)	×
284	{
285	switch (result) {	×
286	case Mocap::Result::Unknown:	×
287	return str << "Unknown";	×
288	case Mocap::Result::Success:	×
289	return str << "Success";	×
290	case Mocap::Result::NoSystem:	×
291	return str << "No System";	×
292	case Mocap::Result::ConnectionError:	×
293	return str << "Connection Error";	×
294	case Mocap::Result::InvalidRequestData:	×
295	return str << "Invalid Request Data";	×
296	case Mocap::Result::Unsupported:	×
297	return str << "Unsupported";	×
298	default:	×
299	return str << "Unknown";	×
300	}
301	}
302
303	} // namespace mavsdk

mavlink / MAVSDK / 14459937051

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous